泛型

泛型(Generic)

1、泛形的作用：JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。

代码说明：

（1）

List list=new ArrayList();

                list.add("abc");

                //String类型不能强转成Integer类型，编译时不报错，运行出错

             Integer i=(Integer)list.get(0);

（2）

list.add(newRandom());

list.add(new ArrayList());

for(int i=0;i<list.size();i++){

             //此处取出来的对象应转换成什么类型

            (?)list.get(i);        }

为了编译时就报错，防止安全性问题，所以应用泛型！

2、 JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。

注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

泛形的基本术语，以ArrayList<E>为例：<>念着typeof

1）ArrayList<E>中的E称为类型参数变量

2）ArrayList<Integer>中的Integer称为实际类型参数

3）整个称为ArrayList<E>泛型类型

4）整个ArrayList<Integer>称为参数化的类型ParameterizedType

3、泛型典型应用

1）使用迭代器迭代泛形集合中的元素。

代码说明：

   //获取迭代器

        Iterator<String>it=list.iterator();

        while(it.hasNext()){

            String str=it.next();

            System.out.println(str);

        }

2）使用增强for循环迭代泛形集合中的元素。

代码说明：

//使用泛型

        List <String> list =new ArrayList<String>();

        list.add("a");

        list.add("b");

        for(String str:list)

        {

            System.out.println(str);

     }

3）存取HashMap中的元素（如果要保证有序用LinkHashMap）

代码说明：

publicvoid test3()

    {

        Map<Integer,String> map=new HashMap<Integer,String>();

        map.put(1,"a");

        map.put(2,"b");

        map.put(3,"c");

        //Entry<键的类型,值得类型>

        Set<Map.Entry<Integer,String>> set=map.entrySet();

        Iterator<Map.Entry<Integer,String>>it =set.iterator();

        while(it.hasNext()){

            Map.Entry<Integer, String>me=it.next();

            //getKey()返回的是Integer类型

            System.out.println(me.getKey()+" "+me.getValue());

        }

    }

4、注意使用泛形时的几个常见问题：

1）使用泛形时，泛形类型须为引用类型，不能是基本数据类型

2)两边的类型必须一致：ArrayList<String>list = new ArrayList<String>();

3)两边只有一边用泛型(为了保持兼容性)：ArrayList<String> list = newArrayList ();     ArrayList list = new ArrayList<String>();

5、自定义泛形——泛型方法

Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法：<T>，T可以是任意字母，但通常必须要大写。<T>通常需放在方法的返回值声明之前。例如：public static <T> void method(T t);

注意：

只有对象类型才能作为泛型方法的实际参数。

在泛型中可以同时有多个类型

在类上加的泛型（在引用对象是用）可以应用于任意非静态方法

代码说明：

packagecom.hbsi.genertic;

importjava.util.Arrays;

publicclass Demo3 {

    /**

     * @param args

     */

    publicstaticvoid main(String[] args) {

        /*

        Integer arr[]={1,2,3,4};

        test1(arr,0,3);

         for(Integer i:arr)

         {

         System.out.println(i);

         }

        System.out.println(Arrays.asList(arr));*/

        String arr[]={"a","b","c","d"};

        test2(arr);

        System.out.println(Arrays.asList(arr));

    }

    //编写一个泛型方法，实现数组元素的交换

    publicstatic <T>void test1(T arr[],int i,int j)

    {

        Ttemp=arr[i];

        arr[i]=arr[j];

        arr[j]=temp;

    }

    //编写一个泛型方法，接受一个任意数组，颠倒数组中的元素

    publicstatic <T>void test2(T arr[])

    {

        intstart=0;

        int end=arr.length-1;

        while(true){

            if(start>=end){

                break;

            }

        T temp=arr[start];

        arr[start]=arr[end];

        arr[end]=temp;

        start++;

        end--;

        }

    }

}

6、 自定义泛形——泛型类

如果一个类多处都要用到同一个泛型，这时可以把泛形定义在类上（即类级别的泛型），语法格式如下：

public classGenericDao<T> {

       private Tfield1;

       public voidsave(T obj){}

       public TgetId(int id){}

}

注意：

    在类级别上定义的泛型,只对类的非静态成员有效

    静态方法不能使用类定义的泛形，而应单独定义泛形。

7、 泛型的典型应用是：BaseDao(数据访问对象用)例如：对学生进行增删改查。

8、 泛型的高级应用——通配符

定义一个方法，接收一个集合，并打印出集合中的所有元素，如下所示：

  voidprint (Collection<String> c) {

          for (String e : c) {

                System.out.println(e);

          }

} 

为了使方法能打印其它集合，方法的定义可改写为：

  void print (Collection<?> c)  {　　　//Collection<?>(发音为:"collection of unknown")

for (Object  e : c) {

System.out.println(e);

}

}

注意：由于print方法c参数的类型为Collection<?>，即表示一种不确定的类型，因此在方法体内不能调用与类型相关的方法，例如add()方法。

       但可以调用与类型无关的方法，例如size()方法

代码说明：

Public static void print (Collection<?> c){

//不行该方法与类型无关

// c.add(“xxxx”);

//可以，该方法与类型无关

c.size();

for(Object e:c){

System.out.println(e);

}

}

使用?通配符主要用于引用对象，使用了?通配符，就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。

9、 泛型的高级应用——有限制的通配符

限定通配符的上边界(?的类型必须是Number的子类)

  (限定通配符总是包括自己。)

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界(?的类型必须是Integer的父类)

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();