泛型——List 优于数组

落日映苍穹つ 2024-03-22 10:58 66阅读 0赞

#### 数组与泛型有很大的不同： ####

**1. 数组是协变的（covariant）**  
意思是：如果Sub是Super的子类型，则数组类型Sub\[\] 是数组类型Super\[\] 的子类型。

**2. 泛型是不变的（invariant）**  
对于任何两种不同的类型Type1 和Type2，List<Type1> 既不是List<Type2> 的子类型也不是父类型。

现在有两段代码：

Object[] objectArray = new Long[1];
    objectArray[0] = "I don't fit in";

List<Object> ol = new ArrayList<Long>(); // Incompatible types
    ol.add("I don't fit in");

无论哪种方式都会报错，因为不能把一个String 类型放到一个Long 类型容器中，但是用一个数组的话，在运行时才会报错；对于列表，可以在编译时就能发现错误。所以使用列表就有优势，因为运行时报错的代价太高

**3. 数组是具体化的，在运行时才知道和强化他们的类型**

就比如上面的代码，将String保存到Long数组中就会得到ArrayStoreException异常

**4. 泛型在编译时就强化它的类型信息，并在运行时擦除它的元素类型信息**

由于上面这些区别，数组和泛型不能很好地混用，所以`new List<E>[]`，`new List<String>`，`new E[]`这些语法都是错误的！在编译时会产生一个泛型数组创建错误。

非法的原因是它不安全，以下面这段代码为例：

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)

*  假设第1行创建一个泛型数组是合法的
 *  第2行创建并初始化包含单个元素的List<Integer>
 *  第3行将List<String> 数组存储到Object数组变量中，这是合法的，因为数组是协变的
 *  第4行将List<Integer> 存储在Object数组的唯一元素中，这是因为泛型是通过擦除来实现的：List<String>\[\] 实例是List\[\]，所以这个赋值不会产生ArrayStoreException 异常

现在问题就来了，我们将一个List<Integer> 实例存储到一个声明为List<String> 实例的数组中，为了防止这种情况出现，第一行必须报错。

E，List<E> 和List<String> 等在技术上被称为不可具体化的类型，指其运行时表示法包含的信息比它的编译时表示法包含的信息更少。唯一可具体化的参数化类型是无限制的通配符类型，如List<?>等，创建无限制通配符类型的数组是合法的，但并不常用。

--------------------

当泛型数组创建错误时，最佳解决方案是使用集合类型List<E> 。例如编写一个带有集合的Chooser类和一个方法，方法返回集合中随机选择的一个元素。

public class Chooser {
        private final Object[] choiceArray;
        
        public Chooser(Collection choices) {
            choiceArray = choices.toArray();
        }
        
        public Object choose() {
            Random rnd = ThreadLocalRandom.current();
            return choiceArray[rnd.nextInt(choiceArray.length)];
        }
    
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("1");
            list.add("2");
            list.add("3");
            Chooser chooser = new Chooser(list);
            Object choose = chooser.choose();
            System.out.println(choose);
        }
    }

如果想将choose方法的返回值从Object转换成每次调用该方法时想要的类型

public class Chooser<T> {
    	private final T[] choiceArray;
    	
    	public Chooser(Collection<T> choices) {
    		choiceArray = choices.toArray();
    	}
     
    	// choose 方法不变
    }

上面的类会报错：

![9b8f3585bdbd498c8df1e76df9b48550.png][]

如果加一条强制类型转换的话：

choiceArray = (T[]) choices.toArray();

仍有报警信息：

![e18f37ab03364c068142b779f0a51272.png][]

要消除上面的警告，需要用列表代替数组：

public class Chooser<T> {
        private final List<T> choiceList;
     
        public Chooser(Collection<T> choices) {
            choiceList = new ArrayList<>(choices);
        }
     
        public T choose() {
            Random rnd = ThreadLocalRandom.current();
            return choiceList.get(rnd.nextInt(choiceList.size()));
        }
    }

总结一下，数组和泛型有着截然不同的类型规则：  
**1. 数组是协变且可以具体化的**  
**2. 泛型是不可变的且可以被擦除的**

[9b8f3585bdbd498c8df1e76df9b48550.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1887ca280d8542f980c01e3958661b1e.png
[e18f37ab03364c068142b779f0a51272.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f0ba4c746ecd461b8445872162e73b38.png