Qfyilyi

Why does the following condition return true with JDK 8, whereas it returns false with JDK 9?

String.class == Arrays.asList("a", "b").toArray().getClass()

The List type returned by asList is Arrays$ArrayList. The toArray method in JDK 8 on that class is:

@Override

public Object toArray() {

    return a.clone();

}

But in JDK 9+ it is:

@Override

public Object toArray() {

    return Arrays.copyOf(a, a.length, Object.class);

}

In both cases a String is passed to asList, but in the JDK 8 case it is cloned, which retains its array type (String), and in JDK 9+ it is copied using Arrays.copyOf with the explicit new array type of Object.

This difference means that in JDK 8 Arrays.asList("a", "b").toArray().getClass() returns String and in JDK 9+ it returns Object, so in JDK 9+ your expression will evaluate to false.

The reason for this change comes from JDK-6260652 with the motivation:

The Collection documentation claims that

collection.toArray()

is "identical in function" to

collection.toArray(new Object[0]);

However, the implementation of Arrays.asList does not follow this: If created with an array of a subtype (e.g. String), its toArray() will return an array of the same type (because it use clone()) instead of an Object.

If one later tries to store non-Strings (or whatever) in that array, an ArrayStoreException is thrown.

So this change was made to fix the previous behaviour.

If this is a problem for you, the related release note offers this as a work-around:

If this problem occurs, rewrite the code to use the one-arg form toArray(T), and provide an instance of the desired array type. This will also eliminate the need for a cast.

String array = list.toArray(new String[0]);

I would say that this was a bug in JDK 8 and before that has been fixed.

List<T>.toArray() was always declared as returning Object (see JavaDoc) - that it did in effect return String in a special case was a mistake.

There are couple of reasons here

1) It is a bug in JDK 8 where should return java.lang.Object but it is not and it is fixed in JDK 9+

@Override

public Object toArray() {

    return a.clone();

}

2) == operator is always used for reference comparison, so java.lang.String or java.lang.Object are objects which are singleton and immutable loaded at the time of JVM starts

System.out.println(String.class.hashCode()); //2018699554

System.out.println(Arrays.asList("a", "b").toArray().getClass().hashCode()); //2018699554