为什么android studio会警告我有关为输入项创建通用数组的信息

Question

I have an adapter in my android project which takes in a reusable map and for simplicity keeps an array of its data to use.

private Entry<String, String>[] mData;

public MyAdapter(@NonNull Map<String, String> data) {
    mData = (Entry<String, String>[]) data.entrySet().toArray();
}

Now I wanted to make it a little more efficient and get rid of the unchecked warning, so I changed to using a specific array type

mData = data.entrySet().toArray( new Entry<String, String>[ data.size() ] );

However the new Entry<String, String>[ data.size() ] part is now flagged " Generic array creation " with no further information. Why is this illegal?

I understand that Java has Type erasure and that generics result in different types (such as explained here ), but the above line of code still seems like it should be legal to me.

Answer 1

Why is this illegal?

Because arrays are covariant. Suppose you were able to compile the following code:

Entry<String, String>[] array = new Entry<String, String>[ isoMap.size() ];
Object[] objArray = array;

// Does not throw an ArrayStoreException.
objArray[0] = new AbstractMap.SimpleEntry<>(Integer.valueOf(0), Integer.valueOf(0));
String key = array[0].getKey();

At runtime, an ArrayStoreException would not be thrown by the assignment because AbstractMap.SimpleEntry (the runtime type of AbstractMap.SimpleEntry<Integer, Integer> ) is covariant with Map.Entry (the runtime type of Entry<String, String> ) - but it would then fail with a ClassCastException when you try to execute the last line because they key is an Integer , not a String .

However, you now have to worry about every element potentially being of the wrong type - given a reference to a Entry<String, String>[] , you can't know exactly how the array was initialized or updated, so accessing any given element in the wrong way could result in a runtime exception.

(When I say "the wrong way", I am constrasting String key = array[0].getKey() with something like invoking something like array[0].toString() - all objects have a toString() method, so that would not attempt a cast).

The safest way to avoid such a situation is simply to make creation of generic arrays illegal.

Note that this is different from the case of non-generic-but-covariant arrays:

String[] array = new String[1];
Object[] objArray = array;
// Throws an ArrayStoreException.
objArray[0] = Integer.valueOf(0);

Because that assignment would throw an ArrayStoreException , a value of the wrong type can never be added to the array.

As such, although you still have to worry about an ArrayStoreException when trying to put a value into the array, you don't have to worry about ClassCastException s when reading a value from the array.