泛型与集合

Java 5.0中最大的特性是引入了泛型，而引入泛型影响最大的就是几个集合类。前一次我简要记录了一下学习List的笔记，本次我将概要地描述一下泛型在集合中的其他应用。
1.指定一个类型参数
一个类型参数主要针对List、Set等集合类而言，具体处理和List大同小异，不再赘述。
2.指定两个类型参数
两个类型参数主要针对Map集合类。Map类会存储一对元素：键－值对，自然就会对应着两种类型。通List一样，使用Map时只需要指定参数类型就可以了，不同之处在于需同时指定键类型和值类型：
        Map<String, String> map = new HashMap<String, String>();
如果理解了泛型的核心概念：所谓参数类型，不过是占位符而已；那么使用一个类型参数还是两个类型参数其实没有任何差别。
3.使用Iterator
如果集合类使用了类型参数，则定义相应的迭代器时也必须指定类型参数，例如：
        Map<Integer, String> map = new TreeMap<Integer, String>();
        Interator iter = map.keySet().iterator();
上面的语句就是无法编译的，因为Iterator和Map不配套；不过，反过来，如果集合类没有使用类型参数，而Iterator使用了类型参数，这种情况是允许的，之所以这样，主要是为了方便，省掉获取元素必须进行映射的步骤。例如下面的语句：
        Map map = new TreeMap();
        Interator<Integer> iter = map.keySet().iterator();
则是合法的，不过建议你别这么做，否则你是自找麻烦。因为对于下面的语句：

Map map  =   new  HashMap();
        map.put( " zero " ,  " class 1 " );
        map.put( 1 ,  " class 2 " );
        map.put( " two " ,  " class 3 " );
        map.put( " three " ,  " class 4 " );
        map.put( " four " ,  3 );
        
        Iterator < String >  iter  =  map.keySet().iterator();    
         while (iter.hasNext())  {
            System.out.println(iter.next());
        }

你能期望得到什么？上面的语句编译时不会出错，不过运行时可能让你大吃一惊。所以为了减少运行时出错的可能，建议你尽量使用参数化类型。
4.函数形参参数类型化
我们也可以指定函数形参的参数类型，例如：

private   void  printListOfStrings(List < String >  list, PrintStream out)  throws  IOException  {
        for  (Iterator < String >  i  =  list.iterator( ); i.hasNext( ); )  {
       out.println(i.next( ));
       }
     }

5.返回值参数类型化
除了可以使用集合体时采用参数化类型，返回值也可以采用参数类型化，例如：

private  List < String >  getListOfStrings( )  {
        List < String >  list  =   new  LinkedList < String > ();
        list.add( " Hello " );
         return  list;
      }

总之，引入泛型的目的就是为了减少编程时的错误，尽量将错误在编译时就发现，而不是遗留到运行时，所以我们应该尽可能地运用好泛型这一强大的工具提高我们的编程能力。下面以一个很粗糙的例子作为本文的终结：

package  com.jiang.tiger.chap1;

import  java.util.ArrayList;
import  java.util.Collection;
import  java.util.Iterator;
import  java.util.List;
import  java.util.Map;
import  java.util.HashMap;
import  java.util.Set;
import  java.util.TreeMap;

public   class  IteratorTester  {
     public   static  Map MapInitial(Class type)  {
        Map < Integer, String >  map  =   null ;
         try   {
            map  =  (Map < Integer, String > ) type.newInstance();
            map.put( 0 ,  " class 1 " );
            map.put( 1 ,  " class 2 " );
            map.put( 2 ,  " class 3 " );
            map.put( 3 ,  " class 4 " );
            map.put( 4 ,  " calss 4 " );
        }   catch  (InstantiationException e)  {
             //  TODO 自动生成 catch 块
            e.printStackTrace();
        }   catch  (IllegalAccessException e)  {
             //  TODO 自动生成 catch 块
            e.printStackTrace();
        }
         return  map;
    }
    
     public   static   void  CollectionIterator()  {
        Map < Integer, String >  map  =  MapInitial(( new  HashMap < Integer, String > ()).getClass());
        Collection < String >  list  =  map.values();
        Iterator < String >  iter  =  list.iterator();
        
         while (iter.hasNext())  {
            System.out.println(iter.next());
        }
     }
    
     public   static   void  ListIterator()  {
        Map < Integer, String >  map  =  MapInitial(( new  TreeMap < Integer, String > ()).getClass());
        List < String >  list  =   new  ArrayList < String > ();
        Set < Integer >  set  =  map.keySet();
        Iterator < Integer >  iter  =  set.iterator();
        
         while (iter.hasNext())  {
            list.add(map.get(iter.next()));
        }
        
        Iterator < String >  iterator  =  list.iterator();
         while (iterator.hasNext())  {
            System.out.println(iterator.next());
        }
    }
    
     public   static   void  main(String[] args) {
        CollectionIterator();
        ListIterator();
    }
}

上面程序的运行结果如下所示：

class  3
calss  4
class  2
class  4
class  1
class  1
class  2
class  3
class  4
calss  4