Qfyilyi

Why does the following condition return true with JDK 1.8.0_131, whereas it returns false with JDK 11.0.1?

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 11 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 11 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 11 it returns Object, so in jdk 11 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-11

@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