Actually, because for compatibility reasons, the signature of a method, which is using varargs function(Object... args) is the equivalent of a method declared with an array function(Object[] args).

Therefore in order to pass and spread any collection to function which expects varargs, you need to transform it to the array:

import java.util.Arrays;
import java.util.stream.Stream;

public class MyClass {
  
  static void printMany(String ...elements) {
     Arrays.stream(elements).forEach(System.out::println);
  }
  
  public static void main(String[] args) {
    printMany("one", "two", "three");
    printMany(new String[]{"one", "two", "three"});
    printMany(Stream.of("one", "two", "three").toArray(String[]::new));
    printMany(Arrays.asList("foo", "bar", "baz").toArray(new String[3]));
  }
}

All these calls of printMany will print:

one

two

three

It's not exactly the same as spread operator, but in most cases, it's good enough.

I took a look at the bytecode, and the only maps involved are the maps that are created to initialize the Car objects.

Once the two car objects are initialized, they are put into a list. The spread operator translates (in this case) to a call to ScriptBytecodeAdapter.getPropertySpreadSafe.

Looking at the source of that method, you'll see that it basically just creates a new ArrayList and adds the requested property (in this case make) of each object:

public static Object More ...getPropertySpreadSafe(Class senderClass, Object receiver, String messageName) throws Throwable {
    if (receiver == null) return null;

    List answer = new ArrayList();
    for (Iterator it = InvokerHelper.asIterator(receiver); it.hasNext();) {
        answer.add(getPropertySafe(senderClass, it.next(), messageName));
    }
    return answer;
}