14. Java基础之泛型

一. 泛型概念的提出(为什么需要泛型)?

首先,我们看下下面这段简短的代码:

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4         List list = new ArrayList();
 5         list.add("qqyumidi");
 6         list.add("corn");
 7         list.add(100);
 8 
 9         for (int i = 0; i < list.size(); i++) {
10             String name = (String) list.get(i); // 1
11             System.out.println("name:" + name);
12         }
13     }
14 }
View Code

定义了一个List类型的集合,先向其中加入了两个字符串类型的值,随后加入一个Integer类型的值。这是完全允许的,因为此时list默认的类型为Object类型。在之后的循环中,由于忘记了之前在list中也加入了Integer类型的值或其他编码原因,很容易出现类似于//1中的错误。因为编译阶段正常,而运行时会出现“java.lang.ClassCastException”异常。因此,导致此类错误编码过程中不易发现。

 在如上的编码过程中,我们发现主要存在两个问题:

1.当我们将一个对象放入集合中,集合不会记住此对象的类型,当再次从集合中取出此对象时,改对象的编译类型变成了Object类型,但其运行时类型任然为其本身类型。

2.因此,//1处取出集合元素时需要人为的强制类型转化到具体的目标类型,且很容易出现“java.lang.ClassCastException”异常。

那么有没有什么办法可以使集合能够记住集合内元素各类型,且能够达到只要编译时不出现问题,运行时就不会出现“java.lang.ClassCastException”异常呢?答案就是使用泛型。

二.什么是泛型?

泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

 看着好像有点复杂,首先我们看下上面那个例子采用泛型的写法。

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4         /*
 5         List list = new ArrayList();
 6         list.add("qqyumidi");
 7         list.add("corn");
 8         list.add(100);
 9         */
10 
11         List<String> list = new ArrayList<String>();
12         list.add("qqyumidi");
13         list.add("corn");
14         //list.add(100);   // 1  提示编译错误
15 
16         for (int i = 0; i < list.size(); i++) {
17             String name = list.get(i); // 2
18             System.out.println("name:" + name);
19         }
20     }
21 }
View Code

采用泛型写法后,在//1处想加入一个Integer类型的对象时会出现编译错误,通过List<String>,直接限定了list集合中只能含有String类型的元素,从而在//2处无须进行强制类型转换,因为此时,集合能够记住元素的类型信息,编译器已经能够确认它是String类型了。

结合上面的泛型定义,我们知道在List<String>中,String是类型实参,也就是说,相应的List接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型(也就是对应的传入的类型实参)。下面就来看看List接口的的具体定义:

 1 public interface List<E> extends Collection<E> {
 2 
 3     int size();
 4 
 5     boolean isEmpty();
 6 
 7     boolean contains(Object o);
 8 
 9     Iterator<E> iterator();
10 
11     Object[] toArray();
12 
13     <T> T[] toArray(T[] a);
14 
15     boolean add(E e);
16 
17     boolean remove(Object o);
18 
19     boolean containsAll(Collection<?> c);
20 
21     boolean addAll(Collection<? extends E> c);
22 
23     boolean addAll(int index, Collection<? extends E> c);
24 
25     boolean removeAll(Collection<?> c);
26 
27     boolean retainAll(Collection<?> c);
28 
29     void clear();
30 
31     boolean equals(Object o);
32 
33     int hashCode();
34 
35     E get(int index);
36 
37     E set(int index, E element);
38 
39     void add(int index, E element);
40 
41     E remove(int index);
42 
43     int indexOf(Object o);
44 
45     int lastIndexOf(Object o);
46 
47     ListIterator<E> listIterator();
48 
49     ListIterator<E> listIterator(int index);
50 
51     List<E> subList(int fromIndex, int toIndex);
52 }
View Code

我们可以看到,在List接口中采用泛型化定义之后,<E>中的E表示类型形参,可以接收具体的类型实参,并且此接口定义中,凡是出现E的地方均表示相同的接受自外部的类型实参。

自然的,ArrayList作为List接口的实现类,其定义形式是:

 1 public class ArrayList<E> extends AbstractList<E> 
 2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
 3     
 4     public boolean add(E e) {
 5         ensureCapacityInternal(size + 1);  // Increments modCount!!
 6         elementData[size++] = e;
 7         return true;
 8     }
 9     
10     public E get(int index) {
11         rangeCheck(index);
12         checkForComodification();
13         return ArrayList.this.elementData(offset + index);
14     }
15     
16     //...省略掉其他具体的定义过程
17 
18 }
View Code

由此,我们从源代码角度明白了为什么//1处加入Integer类型对象编译错误,且//2处get()到的类型直接就是String类型了。源码get方法已经说明了返回的时T类型,无需强转。

三.自定义泛型接口、泛型类和泛型方法

从上面的内容中,大家已经明白了泛型的具体运作过程。也知道了接口、类和方法也都可以使用泛型去定义,以及相应的使用。是的,在具体使用时,可以分为泛型接口、泛型类和泛型方法。

自定义泛型接口、泛型类和泛型方法与上述Java源码中的List、ArrayList类似。如下,我们看一个最简单的泛型类和方法定义:

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<String> name = new Box<String>("corn");
 6         System.out.println("name:" + name.getData());
 7     }
 8 
 9 }
10 
11 class Box<T> {
12 
13     private T data;
14 
15     public Box() {
16 
17     }
18 
19     public Box(T data) {
20         this.data = data;
21     }
22 
23     public T getData() {
24         return data;
25     }
26 
27 }
View Code

在泛型接口、泛型类和泛型方法的定义过程中,我们常见的如T、E、K、V等形式的参数常用于表示泛型形参,由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参,生成的相应对象实例的类型是不是一样的呢?

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<String> name = new Box<String>("corn");
 6         Box<Integer> age = new Box<Integer>(712);
 7 
 8         System.out.println("name class:" + name.getClass());      // com.qqyumidi.Box
 9         System.out.println("age class:" + age.getClass());        // com.qqyumidi.Box
10         System.out.println(name.getClass() == age.getClass());    // true
11 
12     }
13 
14 }
View Code

由此,我们发现,在使用泛型类时,虽然传入了不同的泛型实参,但并没有真正意义上生成不同的类型,传入不同泛型实参的泛型类在内存上只有一个,即还是原来的最基本的类型(本实例中为Box),当然,在逻辑上我们可以理解成多个不同的泛型类型。

究其原因,在于Java中的泛型这一概念提出的目的,导致其只是作用于代码编译阶段,在编译过程中,对于正确检验泛型结果后,会将泛型的相关信息擦出,也就是说,成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话:泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型。

 举例:

先来看一个没有泛型的情况下的容器类如何定义

 1 public class Container {
 2     private String key;
 3     private String value;
 4  
 5     public Container(String k, String v) {
 6         key = k;
 7         value = v;
 8     }
 9     
10     public String getKey() {
11         return key;
12     }
13  
14     public void setKey(String key) {
15         this.key = key;
16     }
17  
18     public String getValue() {
19         return value;
20     }
21  
22     public void setValue(String value) {
23         this.value = value;
24     }
25 }
View Code

Container类保存了一对key-value键值对,但是类型是定死的,也就说如果我想要创建一个键值对是String-Integer类型的,当前这个Container是做不到的,必须再自定义。那么这明显重用性就非常低。

当然,我可以用Object来代替String,并且在Java SE5之前,我们也只能这么做,由于Object是所有类型的基类,所以可以直接转型。但是这样灵活性还是不够,因为还是指定类型了,只不过这次指定的类型层级更高而已,有没有可能不指定类型?有没有可能在运行时才知道具体的类型是什么?

所以,就出现了泛型。

1. 自定义泛型类

 1 public class Container<K, V> {
 2     private K key;
 3     private V value;
 4  
 5     public Container(K k, V v) {
 6         key = k;
 7         value = v;
 8     }
 9  
10     public K getKey() {
11         return key;
12     }
13  
14     public void setKey(K key) {
15         this.key = key;
16     }
17  
18     public V getValue() {
19         return value;
20     }
21  
22     public void setValue(V value) {
23         this.value = value;
24     }
25 }
View Code

在编译期,是无法知道KV具体是什么类型,只有在运行时才会真正根据类型来构造和分配内存。可以看一下现在Container类对于不同类型的支持情况:

 1 public class Main {
 2  
 3     public static void main(String[] args) {
 4         Container<String, String> c1 = new Container<String, String>("name", "findingsea");
 5         Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
 6         Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
 7         System.out.println(c1.getKey() + " : " + c1.getValue());
 8         System.out.println(c2.getKey() + " : " + c2.getValue());
 9         System.out.println(c3.getKey() + " : " + c3.getValue());
10     }
11 }
View Code
1 name : findingsea
2 age : 24
3 1.1 : 2.2
View Code

2. 自定义泛型接口

1 public interface Generator<T> {
2     public T next();
3 }
View Code

然后定义一个生成器类来实现这个接口:

 1 public class FruitGenerator implements Generator<String> {
 2  
 3     private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
 4  
 5     @Override
 6     public String next() {
 7         Random rand = new Random();
 8         return fruits[rand.nextInt(3)];
 9     }
10 }
11 
12 
13 public class Main {
14  
15     public static void main(String[] args) {
16         FruitGenerator generator = new FruitGenerator();
17         System.out.println(generator.next());
18         System.out.println(generator.next());
19         System.out.println(generator.next());
20         System.out.println(generator.next());
21     }
22 }
23 
24 
25 Banana
26 Banana
27 Pear
28 Banana
View Code

3. 自定义泛型方法

一个基本的原则是:无论何时,只要你能做到,你就应该尽量使用泛型方法。也就是说,如果使用泛型方法可以取代将整个类泛化,那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义:

 1 public class Main {
 2  
 3     public static <T> void out(T t) {
 4         System.out.println(t);
 5     }
 6  
 7     public static void main(String[] args) {
 8         out("findingsea");
 9         out(123);
10         out(11.11);
11         out(true);
12     }
13 }
View Code

可以看到方法的参数彻底泛化了,这个过程涉及到编译器的类型推导和自动打包,也就说原来需要我们自己对类型进行的判断和处理,现在编译器帮我们做了。这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数,大大增加了编程的灵活性。

再看一个泛型方法和可变参数的例子

 1 public class Main {
 2  
 3     public static <T> void out(T... args) {
 4         for (T t : args) {
 5             System.out.println(t);
 6         }
 7     }
 8  
 9     public static void main(String[] args) {
10         out("findingsea", 123, 11.11, true);
11     }
12 }
View Code

输出和前一段代码相同,可以看到泛型可以和可变参数非常完美的结合。

四.类型通配符

接着上面的结论,我们知道,Box<Number>和Box<Integer>实际上都是Box类型,现在需要继续探讨一个问题,那么在逻辑上,类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢?

为了弄清这个问题,我们继续看下下面这个例子:

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<Number> name = new Box<Number>(99);
 6         Box<Integer> age = new Box<Integer>(712);
 7 
 8         getData(name);
 9         
10         //The method getData(Box<Number>) in the type GenericTest is 
11         //not applicable for the arguments (Box<Integer>)
12         getData(age);   // 1
13 
14     }
15     
16     public static void getData(Box<Number> data){
17         System.out.println("data :" + data.getData());
18     }
19 
20 }
View Code

我们发现,在代码//1处出现了错误提示信息:The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然,通过提示信息,我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类那么,原因何在呢?

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<Integer> a = new Box<Integer>(712);
 6         Box<Number> b = a;  // 1
 7         Box<Float> f = new Box<Float>(3.14f);
 8         b.setData(f);        // 2
 9 
10     }
11 
12     public static void getData(Box<Number> data) {
13         System.out.println("data :" + data.getData());
14     }
15 
16 }
17 
18 class Box<T> {
19 
20     private T data;
21 
22     public Box() {
23 
24     }
25 
26     public Box(T data) {
27         setData(data);
28     }
29 
30     public T getData() {
31         return data;
32     }
33 
34     public void setData(T data) {
35         this.data = data;
36     }
37 
38 }
View Code

这个例子中,显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。

假设Box<Number>在逻辑上可以视为Box<Integer>的父类,那么//1和//2处将不会有错误提示了,那么问题就出来了,通过getData()方法取出数据时到底是什么类型呢?Integer? Float? 还是Number?且由于在编程过程中的顺序不可控性,导致在必要的时候必须要进行类型判断,且进行强制类型转换。显然,这与泛型的理念矛盾,因此,在逻辑上Box<Number>不能视为Box<Integer>的父类。

好,那我们回过头来继续看“类型通配符”中的第一个例子,我们知道其具体的错误提示的深层次原因了。那么如何解决呢?总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的,因此,我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型,由此,类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了,此处是类型实参,而不是类型形参!且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此,我们依然可以定义泛型方法,来完成此类需求。

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<String> name = new Box<String>("corn");
 6         Box<Integer> age = new Box<Integer>(712);
 7         Box<Number> number = new Box<Number>(314);
 8 
 9         getData(name);
10         getData(age);
11         getData(number);
12     }
13 
14     public static void getData(Box<?> data) {
15         System.out.println("data :" + data.getData());
16     }
17 
18 }
View Code

有时候,我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢?

在上面的例子中,如果需要定义一个功能类似于getData()的方法,但对类型实参又有进一步的限制:只能是Number类及其子类。此时,需要用到类型通配符上限。

 1 public class GenericTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Box<String> name = new Box<String>("corn");
 6         Box<Integer> age = new Box<Integer>(712);
 7         Box<Number> number = new Box<Number>(314);
 8 
 9         getData(name);
10         getData(age);
11         getData(number);
12         
13         //getUpperNumberData(name); // 1
14         getUpperNumberData(age);    // 2
15         getUpperNumberData(number); // 3
16     }
17 
18     public static void getData(Box<?> data) {
19         System.out.println("data :" + data.getData());
20     }
21     
22     public static void getUpperNumberData(Box<? extends Number> data){
23         System.out.println("data :" + data.getData());
24     }
25 
26 }
View Code

此时,显然,在代码//1处调用将出现错误提示,而//2 //3处调用正常。

类型通配符上限通过形如Box<? extends Number>形式定义,相对应的,类型通配符下限为Box<? super Number>形式,其含义与类型通配符上限正好相反在此不作过多阐述了。

五.泛型特点 & 类型擦除

泛型只在编译阶段有效。看下面的代码:

 1 List<String> stringArrayList = new ArrayList<String>();
 2 List<Integer> integerArrayList = new ArrayList<Integer>();
 3 
 4 Class classStringArrayList = stringArrayList.getClass();
 5 Class classIntegerArrayList = integerArrayList.getClass();
 6 
 7 if(classStringArrayList.equals(classIntegerArrayList)){
 8     Log.d("泛型测试","类型相同");
 9 }
10 
11 输出结果:D/泛型测试: 类型相同。
View Code

通过上面的例子可以证明,在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型,只在编译阶段有效。在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦出,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说,泛型信息不会进入到运行时阶段。

对此总结成一句话:泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型。

六.泛型面试题

1. Java中的泛型是什么 ? 使用泛型的好处是什么?
泛型是一种参数化类型的机制。它可以使得代码适用于各种类型,从而编写更加通用的代码,例如集合框架。

泛型是一种编译时类型确认机制。它提供了编译期的类型安全,确保在泛型类型(通常为泛型集合)上只能使用正确类型的对象,避免了在运行时出现ClassCastException。

2、Java的泛型是如何工作的 ? 什么是类型擦除 ?
泛型的正常工作是依赖编译器在编译源码的时候,先进行类型检查,然后进行类型擦除并且在类型参数出现的地方插入强制转换的相关指令实现的。

编译器在编译时擦除了所有类型相关的信息,所以在运行时不存在任何类型相关的信息。例如List<String>在运行时仅用一个List类型来表示。为什么要进行擦除呢?这是为了避免类型膨胀

3. 什么是泛型中的限定通配符和非限定通配符 ?
限定通配符对类型进行了限制。有两种限定通配符,一种是<? extends T>它通过确保类型必须是T的子类来设定类型的上界,另一种是<? super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化,否则会导致编译错误。另一方面<?>表示了非限定通配符,因为<?>可以用任意类型来替代。

4. List<? extends T>和List <? super T>之间有什么区别 ?
这和上一个面试题有联系,有时面试官会用这个问题来评估你对泛型的理解,而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子,List<? extends T>可以接受任何继承自T的类型的List,而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。

5. 如何编写一个泛型方法,让它能接受泛型参数并返回泛型类型?
编写泛型方法并不困难,你需要用泛型类型来替代原始类型,比如使用T, E or K,V等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下,一个泛型方法可能会像这样:

1 public V put(K key, V value) {
2     return cache.put(key, value);
3 }
View Code

 6. Java中如何使用泛型编写带有参数的类?

这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类,而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型,而且要使用JDK中采用的标准占位符。
7. 编写一段泛型程序来实现LRU缓存?
对于喜欢Java编程的人来说这相当于是一次练习。给你个提示,LinkedHashMap可以用来实现固定大小的LRU缓存,当LRU缓存已经满了的时候,它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法,该方法会被put()和putAll()调用来删除最老的键值对。
8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗?
对任何一个不太熟悉泛型的人来说,这个Java泛型题目看起来令人疑惑,因为乍看起来String是一种Object,所以List<String>应当可以用在需要List<Object>的地方,但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑,你会发现Java这样做是有意义的,因为List<Object>可以存储任何类型的对象包括String, Integer等等,而List<String>却只能用来存储Strings。

1 List<Object> objectList;
2 List<String> stringList;
3       
4 objectList = stringList;  //compilation error incompatible types
View Code

 9. Array中可以用泛型吗?

这可能是Java泛型面试题中最简单的一个了,当然前提是你要知道Array事实上并不支持泛型这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array,因为List可以提供编译期的类型安全保证,而Array却不能。
10. 如何阻止Java中的类型未检查的警告?
如果你把泛型和原始类型混合起来使用,例如下列代码,Java 5的javac编译器会产生类型未检查的警告
,例如List<String> rawList = new ArrayList()
注意: Hello.java使用了未检查或称为不安全的操作;
这种警告可以使用@SuppressWarnings("unchecked")注解来屏蔽。

 

J2SE提供的最后一个注解是@SuppressWarnings。该批注的作用是给编译器一条指令,告诉它对被批注的代码元素内部的某些警告保持静默。@SuppressWarnings注解允许您选择性地取消特定代码段(即,类或方法)中的警告。其中的想法是当您看到警告时,您将调查它,如果您确定它不是问题,您就可以添加一个@SuppressWarnings注解,以使您不会再看到警告。虽然它听起来似乎会屏蔽潜在的错误,但实际上它将提高代码安全性,因为它将防止您对警告无动于衷 — 您看到的每一个警告都将值得注意。@SuppressWarings注解作用:用于抑制编译器产生警告信息。示例1、抑制单类型的警告:@SuppressWarnings("unchecked")  

 

 

 

11、Java中List<Object>和原始类型List之间的区别?-----结合12题看
原始类型和带参数类型<Object>之间的主要区别是,在编译时编译器不会对原始类型进行类型安全检查,却会对带参数的类型进行检查,通过使用Object作为类型,可以告知编译器该方法可以接受任何类型的对象,比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。它们之间的第二点区别是,你可以把任何带参数的泛型类型传递给接受原始类型List的方法,但却不能把List<String>传递给接受List<Object>的方法,因为会产生编译错误。

 1 package com.test.a;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class Test {
 7     public static void main(String[] args) {
 8 
 9         List<Object> list1 = new ArrayList<Object>();
10         List list2 = new ArrayList<>();
11         List<String> list3 = new ArrayList<>();
12         list1.add("a");
13         list1.add(1);
14         list1.add(list3);
15         list2.add(list3);
16         for (Object i : list1) {
17             System.out.println(i);
18         }
19         List<?> listOfAnyType;
20         List<Object> listOfObject = new ArrayList<Object>();
21         List<String> listOfString = new ArrayList<String>();
22         List<Integer> listOfInteger = new ArrayList<Integer>();
23 
24         listOfAnyType = listOfString; // legal
25         listOfAnyType = listOfInteger; // legal
26         listOfAnyType = listOfObject;
27 
28         listOfObjectType = (List<Object>) listOfString; // compiler error - in-convertible types
29 
30     }
31 
32 }
View Code

12、Java中List<?>和List<Object>之间的区别是什么?

这道题跟上一道题看起来很像,实质上却完全不同。List<?> 是一个未知类型的List,而List<Object>其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>,却不能把List<String>赋值给List<Object>。   

List<?> listOfAnyType;
List<Object> listOfObject = new ArrayList<Object>();
List<String> listOfString = new ArrayList<String>();
List<Integer> listOfInteger = new ArrayList<Integer>();

listOfAnyType = listOfString; //legal
listOfAnyType = listOfInteger; //legal
listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types

note:总结11题和12题:List<Object>是可以加入任何继承该Object的元素的,比如list.add("String"). 但是List<String>和List<Object>确实两种东西,无法将两个引用视为一个引用。但是却可以将List<String>的引用赋值给List<?>的引用。并且,所有的泛型只是在编译器件有效,在经过编译后,其实都是一个对象。比如:

Class class1=list1.getClass();
Class class2=list2.getClass();
Class class3=list3.getClass();
Class class4=listOfAnyType.getClass();
System.out.println((class1==class2)&&(class2==class3)&&(class3==class4));

打印结果就为true

 13、List<String>和原始类型List之间的区别.

该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的,而且其类型安全是由编译器保证的,但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中,而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换,但是对于原始类型,你则需要进行显式的类型转换。

List listOfRawTypes = new ArrayList();
listOfRawTypes.add("abc");
listOfRawTypes.add(123); //编译器允许这样 - 运行时却会出现异常
String item = (String) listOfRawTypes.get(0); //需要显式的类型转换
item = (String) listOfRawTypes.get(1); //抛ClassCastException,因为Integer不能被转换为String

List<String> listOfString = new ArrayList();
listOfString.add("abcd");
listOfString.add(1234); //编译错误,比在运行时抛异常要好
item = listOfString.get(0); //不需要显式的类型转换 - 编译器自动转换

 

note: 无泛型数组这一说法

解释:

在Java中,如果创建泛型数组,会出现以下编译错误, 例如 
List<String>[] stringLists = new List<String>[10]; 
会提示 
Error:(9, 38) java: 创建泛型数组 
但是却可以创建泛型数组的引用 
List<String>[] stringLists = null; 
并将一个普通数组的引用赋值给它。 
List<String>[] stringLists = new List[10];package test;import java.util.ArrayList;
import java.util.List;public class Main {public static void main(String[] args) {List<String>[] stringLists = new List[10];  //每一个元素都是一个List类型得对象stringLists[0] = new ArrayList<>();stringLists[0].add("HelloWorld");}
}使用泛型的作用是使得程序在编译期可以检查出与类型相关的错误,但是如果使用了泛型数组,这种能力就会受到破坏。假如我们可以声明这样一个泛型数组(实际上是不可以的): 
List<String>[] stringLists = new List<String>[10]; 
由于在 Java 中,数组是协变(covariant)的,这意味着基类类型的数组可以接收子类类型的数组,例如: 
Object[] objects = stringLists; 
一旦我们这样做之后,就可以通过objects向 stringLists中添加非List<String>类型的数据。List<Integer> intList = Arrays.asList(1);//Aarrays.asList将一个数组转换成集合
objects[0] = intList;
--------------------- 随后,再使用 stringList 时,stringList[0] 就会保存 intList, 而使用下面的代码,编译器不会提示错误,但运行时,就会出错。 
String str = stringList[0].get(0);即使创建出来“泛型数组”以上错误也依然存在。List<String>[] stringLists = (List<String>[])new List[10];
Object[] objects = stringLists;
List<Integer> intList = Arrays.asList(1);
objects[0] = intList;
String str = stringLists[0].get(0); //runtime error
但是下面这种是可以得public class Main {static class A {}static class B extends A {}public static void main(String[] args) { A[] arraya = new A[5];B[] arrayb = new B[5];// 可以正常赋值,B[] 是 A[] 的子类arraya = arrayb;List<A> lista = new ArrayList<A>();List<B> listb = new ArrayList<B>();// lista = listb 编译错误,List<B> 不是 List<A> 的子类
    }
}

 

 

参考文献:

https://www.cnblogs.com/lwbqqyumidi/p/3837629.html 

https://blog.csdn.net/s10461/article/details/53941091

https://blog.csdn.net/sunxianghuang/article/details/51982979

https://blog.csdn.net/garfielder007/article/details/80502144

转载于:https://www.cnblogs.com/Hermioner/p/9737491.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/426675.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

java学习(15):巩固练习

//任务 1 //编写控制台java程序&#xff0c;使用Scanner 对象相关方法从 //控制台接收用户输入如下数据并使用相关的局部变量接收&#xff0c;在控制台打印输出。 //老师的姓名&#xff1b;老师的性别&#xff1b;老师的工资&#xff1b;老师的年龄&#xff1b;工作时长 import…

java学习(16):巩固练习

/任务 2 编写控制台java程序&#xff0c;将以下数据使用合理类型变量进行接收赋值 3.5&#xff1b;185.59&#xff1b;8500.50 要求在控制台打印这些数据并只显示整数部分。/ import java.util.Scanner; public class test02{ public static void main(String[] args){ Scanner…

mac电脑投屏到小米盒子_苹果手机搜不到小米盒子怎么办?

刚买的小米电视盒子迫不及待想投屏&#xff0c;但是手机是苹果系统&#xff0c;都是连得同一wifi&#xff0c;可是手机就是搜索不到小米家的客厅电视&#xff0c;这种情况该怎么办呢&#xff1f;以下小编给大家详细介绍了苹果手机搜不到小米盒子该怎么办。苹果设备中搜不到小米…

Redis实现之对象(三)

集合对象 集合对象的编码可以是intset或者hashtable&#xff0c;intset编码的集合对象使用整数集合作为底层实现&#xff0c;集合对象包含的所有元素都被保存在整数集合里面。举个栗子&#xff0c;以下代码将创建一个图1-12所示的intset编码集合对象&#xff1a; 127.0.0.1:637…

java学习(17):巩固练习

//#任务 3 //#已知有三个人&#xff0c;张无忌&#xff0c;任盈盈&#xff0c;任我行。当前只知道任盈盈的年龄 //#可以被用户从控制台输入&#xff0c;并且用户可以告知任盈盈的年龄比张无忌的年龄小几岁&#xff0c; //#任我行年龄是张无忌和任盈盈年龄和还要大几岁&#xff…

mysql innodb redolog_MySQL · 引擎特性 · InnoDB redo log漫游(转)

前言InnoDB 有两块非常重要的日志&#xff0c;一个是undo log&#xff0c;另外一个是redo log&#xff0c;前者用来保证事务的原子性以及InnoDB的MVCC&#xff0c;后者用来保证事务的持久性。和大多数关系型数据库一样&#xff0c;InnoDB记录了对数据文件的物理更改&#xff0c…

Jenkins配置:添加用户和管理权限

Jenkins配置&#xff1a;添加用户和管理权限 参考文章&#xff1a;http://www.cnblogs.com/zz0412/p/jenkins_jj_14.html 今天给大家说说使用Jenkins专有用户数据库的配置&#xff0c;和一些常用的权限配置。 配置用户注册 在新安装好的jenkins中&#xff0c;默认是没有设置用户…

java学习(18):巩固练习

/任务 4 白大壮和白二壮是双胞胎兄弟&#xff0c; 白大壮的身高增加1厘米正好是白二壮的身高 &#xff0c;白二壮体重正好是妹妹白无瑕体重&#xff0c;编写程序完成白大壮 和白二壮身高的计算并输出&#xff0c;并计算白无瑕的体重输出是多少/ import java.util.Scanner; publ…

java-appium-527进阶-1 UiAutomator12区别和封装

1.UiAutomator和UiAtumator2的区别&#xff1a; 1.1 UiAutomator1有关于id定位的策略 UiAutomator1 id定位在resourceid匹配失败时&#xff0c;会匹配contentDesc。 安卓会根据id进行3种情况的判断&#xff1a; 1.resourceId 如user_profile_icon2.accessibility id3.Strings.…

java学习(19):巩固练习

/任务 5 有三位老师&#xff0c;王老师&#xff0c;孙老师和小李老师&#xff0c; 王老师工龄最长(15年)&#xff0c;孙老师工龄比王老师小3年&#xff0c; 小李老师工龄最短&#xff0c;是王老师和孙老师工龄和的二分之一 再除以2的余数正好是他的工龄&#xff0c;编写程序从控…

mysql分组获取其他字段_sqlserver group by后获取其他字段(多种方法)

大家都知道用group by的话&#xff0c;select 后面指定的字段必须与group by后面的一致。group by 只有个别字段&#xff0c;如果拿出其他未分组的字段信息呢&#xff1f;在网上搜了下&#xff0c;总结如下&#xff1a;使用了group by 之后&#xff0c;就要求select后面的字段包…

搜索引擎基础概念(1)—— 倒排索引

“ 吾有三剑&#xff0c;唯子所择&#xff1b;皆不能杀人&#xff0c;且先言其状。一曰含光&#xff0c;视之不可见&#xff0c;运之不知有。其所触也&#xff0c;泯然无际&#xff0c;经物而物不觉。二曰承影&#xff0c;将旦昧爽之交&#xff0c;日夕昏明之际&#xff0c;北面…

java学习(20):巩固练习

//用运算符判断2019是不是闰年 /①、普通年能被4整除且不能被100整除的为闰年。 &#xff08;如2004年就是闰年,1901年不是闰年&#xff09;地球公转示意图②、世纪年能被400整除的是闰年。 (如2000年是闰年&#xff0c;1900年不是闰年) ③、 对于数值很大的年份能整除3200,但同…

汇编软件的安装与实验一

软件的安装在课程邮箱里有详尽的介绍&#xff0c;但在安装调试的时候还是出了一点小问题&#xff0c;创建虚拟盘符的时候&#xff0c;我将masm文件夹前面套上了一层名为masm文件夹&#xff0c;导致虚拟盘符创建之后无法使用debug。 随后就是实验 实验1.1写入程序段并且执行 a命…

upc 9519 New Game

New Game 时间限制: 1 Sec 内存限制: 128 MB Special Judge提交: 157 解决: 53[提交] [状态] [讨论版] [命题人:admin]题目描述 Eagle Jump公司正在开发一款新的游戏。泷本一二三作为其员工&#xff0c;获得了提前试玩的机会。现在她正在试图通过一个迷宫。这个迷宫有一些特…

java学习(21):移位运算符

//移位运算符 public class test{ public static void main(String[] args){ int num3; //向左移位 System.out.println(“移位之前的二进制为”Integer.toBinaryString(num)); int moveleftnum<<2; System.out.println(“移位之后的值为”moveleft); //向右移位 int num…

Datagridview绘制

#region 绘制private void dataGridView_main_RowPrePaint(object sender, DataGridViewRowPrePaintEventArgs e){int status_column_index 14;//会诊状态所在列DataGridViewRow row dataGridView_main.Rows[e.RowIndex];//获取行DataGridViewCell cell row.Cells[15];//按钮…

java学习(22):if语句

/任务 1&#xff1a;if语句 编写控制台java程序&#xff0c;使用Scanner 对象相关方法从控制台接收用户输入学生年龄&#xff0c; 如果输入的年龄大于18&#xff0c;则输出“你是一个成年人了&#xff0c;该有担当了&#xff01;/ import java.util.Scanner; public class test…

java学习(23):if..else

/任务2&#xff1a;if else 语句 编写控制台java程序&#xff0c;模拟银行取款的功能。 使用Scanner对象相关方法从控制台接收用户输入的银行卡账号和密码&#xff0c; 与预先定义好的银行卡账号密码相同则输出用户名密码正确&#xff0c;可以取款&#xff1b;如果账号或者密码…

android 面试汇总二

AnimationQ&#xff1a;Android中有哪几种类型的动画&#xff1f; 技术点&#xff1a;动画类型参考回答&#xff1a; 常见三类动画 View动画&#xff08;View Animation&#xff09;/补间动画&#xff08;Tween animation&#xff09;&#xff1a;对View进行平移、缩放、旋转和…