1、请不要在新代码中使用原生态类型

• 1、在没有泛型之前，从集合中读取到每一个对象都必须进行转换。如果有人不小心插入了类型错误的对象，在运行时的转换处理就会出错。有了泛型之后，可以告诉编译器每个集合中接受哪些对象类型。编译器自动地为你的插入进行转换，并在编译时告知是否插入了类型错误的对象。这样就可以使程序更加安全和清楚。

在java1.5版发行之前，没有泛型时，集合声明：

// Now a raw collection type - don't do this!

/**
 * My stamp collection, Contains only Stamp instance.
 */

private final Collection stamps = ...;

如果不小心将一个coin放进了stamp集合中，这一错误的插入照样得以编译和运行并且不会出现任何错误提示：

// Erroneous insertion of coin into stamp collection
stamps.add(new Coin( ... ));

直到从stamp集合中获取coin时才会收到错误提示。

//Now a raw interator type - don't do this !
for (Iterator i = stamps.iterator(); i.hasNext();) 
    Stamp s = (Stamp) i.next(); // Throws ClassCastException
    ... // Do something with the stamp

出错之后应该尽快发现，最好是编译时就发现。上述例子，直到运行时才发现错误，已经错误了很久。

有了泛型，就可以改进后的类型声明来代替集合中的这种注释，告诉编译器之前的注释中所隐含的信息：

// Parameterized collection type - typesafe
private final Collection<Stamp> stamps = ...;

通过这条声明，编译器直到stamps应该只包括Stamp实例，并给予保证，假设整个代码是利用java 1.5机器之后的编译器进行编译的，所有代码在编译国企成都没有发出任何警告。当stamps利用一个参数化的类型进行声明时，错误的插入会产生一条编译时的错误消息，准确地告诉你那里出错了。

• 2、声明中具有一个或者多个类型参数的类或者接口，就是泛型类或者接口。从java1.5开始，List接口就只有单个类型参数E，表示列表的元素类型，从技术的角度看，这个接口的名称应该是指现在的List<E >（读作"E的列表"），但是人们经常把它简称为List。泛型类和接口统称为泛型。
• 3、每种泛型定义一组参数化的类型，构成格式为：先是类或者接口的名称，接着用尖括号(<>)把对应于泛型形式类型参数的实际类型参数列表括起来。比如说：List<String>（读作"字符串列表"）是一个参数化的类型，表示元素类型为String的列表。（String是与形式类型参数E相对应的实际类型参数）
• 4、每个泛型都定义一个原生态类型，即不带有任何实际类型参数的泛型名称。比如说：List< E>相对应的原生态类型是List。原生态类型就像从类型声明中删除了所有泛型信息一样。实际上，原生态类型List与java平台没有泛型之前的接口类型List完全一样。

5、原生态类型和泛型类型相比较：

原始类型：

 public static void main(String[] args) 
        //Now a raw collection type - do not do this  现在是原始集合类型-不要这样做
        List list=new ArrayList();
        //Erroneous insertion of coin into stamp collection  添加的时候错误的插入元素
        list.add("dasd");
        list.add(11);
        //Now a raw iterator type - do not do this  现在是原始迭代器类型-不要这样做
        for (Iterator i =list.iterator();i.hasNext();) 
            Object s = (String)i.next();
            System.out.println(s);
        
    

• 6.泛型使得从集合中删除元素时不再需要进行手工转换了。编译器会替你插入隐式的转换，并确保他们不会失败（依然假设所有代码都是通过支持泛型的编译器进行编译并且没有产生或者禁止任何警告）。

  List<String> stringList=new ArrayList<String>();
        for (Iterator<String> i =stringList.iterator();i.hasNext();) 
            Object s =i.next();
            System.out.println(s);
        

• 7.如果使用原生态类型，就失掉了泛型在安全性和表述性方面的所有优势。为了提供兼容性，因为泛型出现的时候，java平台即将进入他的第二个10年，已经存在大量没有使用泛型的java代码。人们认为让所有这些代码保持合法，并且能够与使用泛型的新代码互用，这一点很重要。它必须合法，才能将参数化类型的实例传递给那些被设计成使用普通类型的方法，反之亦然。这种需要被称作移植兼容性，促成了支持原生态类型的决定。
• 8.原生态类型List和参数化类型List< Object >之间的区别：
  • 1）比严格地说，原生态类型List逃避了泛型检查，参数化类型List< Object >明确告知编译器，他能够持有任意类型的对象。
  • 2）虽然可以将List< String >传递给类型List的参数，但是不能将它传给类型List< Object >的参数。
  • 3）泛型有子类型化的规则，List< String >是原生态类型List的一个子类型，而不是参数化类型List< Object>的子类型。
• 9.如果使用像List这样的原生态类型，就会失掉类型安全性，但是如果使用像List< Object >这样的参数化类型就不会。下面我们举个例子：

public class Demo 

    public static void main(String[] args) 
        List<String> strings = new ArrayList<String>();
        unsafeAdd(strings, new Integer(11));
        String s = strings.get(0);//Compiler-generated cast
        System.out.println(s);
    

    private static void unsafeAdd(List list,Object o)
        list.add(o);
    

以上代码可以编译成功，但是因为它使用了原生态类型List，你会收到警告。不过如果运行这段程序，在程序试图将strings.get(0)的调用结果转换成一个String时，会爆ClassCastException异常（类型转换异常）。

如果我们在unsafeAdd方法中用参数化类型List< Object >代替原生态类型List，并试着重新编译这段程序，就会发现无法编译，这样就可以提早发现错误。

  private static void unsafeAdd(List<Object> list,Object o)
        list.add(o);
    

• 10.在不确定或者不在乎集合中的元素类型的情况下，你也许会使用原生态类型。比如：

 //Use of raw type for unknown element type - do not do this 对未知元素类型使用原生态类型-不要这样做
    static int numElementsInCommon(Set s1,Set s2)
        int result=0;
        for (Object o : s1) 
            if(s2.contains(o))
                result++;
            
        
        return result;
    

这个方法虽然可以，但是使用了原生态类型，十分危险。从java1.5开始，提供了一种安全的替代方法，称为无限制的通配符类型。如果要使用泛型，但不确定或者不关心实际的类型参数，就可以使用一个问号代替。比如：泛型Set< E >的无限制通配符类型为Set<?>（读作"某个类型的集合"）。

对于上面的代码可以这样写：

 //Unbounded wildcard type - typesafe and flexible  无限制的通配符类型——类型安全且灵活
    static int numElementsInCommonImporve(Set<?> s1,Set<?> s2)
        int result=0;
        for (Object o : s1) 
            if(s2.contains(o))
                result++;
            
        
        return result;
    

• 11.通配符类型是安全的，原生态类型则不安全。由于可以将任何元素放进使用原生态类型的集合中，因此很容易破坏该集合的类型约束条件；但不能将任何元素（除了null之外）放到Collection<? >中。如果尝试这么做的话，会产生编译错误。
• 12.不要在新代码中使用原生态类型，这条规则有两个小小的例外，两者都源于"泛型信息可以在运行时被擦除"这一事实。
  • 1）在类文字中必须使用原生态类型。规范不允许使用参数化类型（虽然允许数组类型和基本类型）。比如说：List.class,String[].class和int.class都合法，但是List<String >.class和List< ? >.class则不合法。
  • 2）由于泛型信息可以在运行时被擦除，因此在参数化类型而非无限制通配符类型上使用instanceof操作符是非法的。用无限制通配符类型代替原生态类型，对instanceof操作符的行为不会产生任何影响。在这种情况下，尖括号<>和问号?就显得多余了。

下面演示一下利用泛型来使用instanceof操作符的首选方法：

  public static void instanceofTest(Object o)
        if(o instanceof Set)
            Set<?> m=(Set<?>) o;
        
    

总结

1）使用原生态类型会在运行时导致异常，因此不要在新代码中使用。原生态类型只是为了与引入泛型之前的遗留代码进行兼容和互用提供的。

2）Set< Object >是个参数化类型，表示可以包含任何对象类型的一个集合。安全。

3）Set<?>则是一个通配符类型，表示只能包含某种未知对象类型的一个集合。安全。

4）Set则是个原生态类型，它脱离了泛型系统。不安全。

	public class ListDemo 
		public static void main(String[] args) 
			List<String> stringList = new ArrayList<String>();
 
 
			// 方法add1和add2显示了List和List<Object>的区别
 
 
			/*
			 * 方法add1由于参数是List，当把List<String>作为参数传进来时，list添加了一个Integer类型，
			 * string列表中添加了Integer类型的元素，破坏了安全性
			 */
			add1(stringList, new Integer(1));
			// 出错，因为是Integer类型
			String s = stringList.get(0);
			System.out.println(s);
			//Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
 
 
			// 方法add2无法通过编译，因为无法接受 List<String>作为参数
			//可以将List<String>类型的对象赋给原生态List类型的变量，但是不能将List<String>类型的对象赋给List<Object>类型的变量。
			add2(stringList, new Integer(1));
 
 
			// 方法add1和add3显示了List和List<?>的区别
 
 
			// 方法add3无法通过编译，List<?>一般只能用于读取，不能add，除非是null
			add3(stringList, new Integer(1));
 
		
 
 
		private static void add1(List list, Object o) 
			list.add(o);
		
		private static void add2(List<Object> list, Object o) 
			list.add(o);
		
		private static void add3(List<?> list, Object o) 
			list.add(o);// 错误
			list.add(null);// 正确，可以添加null
		
	

参考

1、Effective Java笔记第四章泛型第一节请不要在新代码中使用原生态类型
2、Effective Java 泛型 第23条：请不要在新代码中使用原生态类型