Item 28: Prefer lists to arrays

28. Use lists rather than arrays

• Sequences differ in two important ways compared to generic types.
• The array is covariant. For example, the Sub class is a subclass of the Super class, and the Sub [] class is a subclass of the Super [] class. On the other hand, Generics are not on the same side. List and List cannot have a parent-child relationship in any two Type1 and Type2 classes. Due to this property, in the following code, the result is not known until the array is executed, but the List is known at compile time.

package tryAny.effectiveJava;

public class GenericsTest5 {
    public static void main(String[] args) {

        Object[] objAry = new Long[1];
        objAry[0] = "aa";

        // Won't compile!
        // List<Object> ol = new ArrayList<Long>(); // Incompatible

    }
}

• Arrays are reified. Arrays know the elements at run time and process the elements. Generics, on the other hand, are implemented by erasures. Generics are type-restricted only at compile time, and element type information is discarded at run time.

• Due to the fundamental differences mentioned above, sequences and generics cannot be mixed well. For example, code such as ``` new List []` `` is rejected at compile time. I will explain the reason why the array of generics cannot be created, assuming that the first line of the following code does not cause a compile error (actually, the first line is a compile error). The second line creates a List with one element. The third line stores the array of List in the array of Object. This is true because the array is covariant. The 4th line stores List in the Object array. This does not cause an ArrayStoreException because List is just a List and List [] is just a List []. Then, the element extracted from List on the 5th line is Integer, and ClassCastException occurs. To prevent this from happening, generic type arrays have a compilation error.

// Why generic array creation is illegal - won't compile!
List<String>[] stringLists = new List<String>[1];  // (1)
List<Integer> intList = List.of(42);               // (2)
Object[] objects = stringLists;                    // (3)
objects[0] = intList;                              // (4)
String s = stringLists[0].get(0);                  // (5)

Types such as * E and List are called ** non-reifiable **. The intuitive meaning of this word is that it has less information at runtime than at compile time. Only generic types that use the? Wildcard are reifiable, but arrays of generics that use wildcards have no practical value.

• Because a generic type array cannot be created, it becomes troublesome to handle when using a method with variable length arguments. When using a variadic method, an array is created to hold the variadic. If these element types are non-reifiable, a warning will be issued. To deal with this, use the SafeVarargs annotation (Item32).
• If you are faced with a situation where you cannot create a generic type array or cast to an array, use the collection type ** List ** rather than the element type array ** E [] **. we have to. This ensures type safety and interoperability at the expense of simplicity and performance.
• As an example, suppose you write a Chooser class that takes a collection in its constructor and randomly retrieves the elements in that collection with the only method. If you write it without using generics, it will be as follows. If you use this class, you always have to cast the type you want when you use the method, and if the cast fails you will get an error at runtime.

package tryAny.effectiveJava;

import java.util.Collection;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class Chooser1 {
    private final Object[] choiceArray;

    public Chooser1(Collection choices) {
        choiceArray = choices.toArray();
    }

    public Object choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceArray[rnd.nextInt(choiceArray.length)];
    }

}

According to Item29, I wrote the following in Generics. It's a bit verbose and performance degradation, but it doesn't throw a ClassCastException at runtime.

package tryAny.effectiveJava;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

//List-based Chooser - typesafe
public class Chooser2<T> {
    private final List<T> choiceList;

    public Chooser2(Collection<T> choices) {
        choiceList = new ArrayList<>(choices);
    }

    public T choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceList.get(rnd.nextInt(choiceList.size()));
    }
}