Java泛型的注意事项以及使用

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

比如：



泛型的作用：

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

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

泛形的基本术语，以ArrayList<E>为例：<>念做typeof
ArrayList<E>中的E称为类型参数变量
ArrayList<Integer>中的Integer称为实际类型参数
整个称为ArrayList<E>泛型类型
整个ArrayList<Integer>称为参数化的类型ParameterizedType

泛型的应用：

使用迭代器迭代泛形集合中的元素：



增强for循环迭代泛形集合中的元素：



HashMap中的元素：

import java.util.*;
import java.util.Map.Entry;
public class MapTest{
public static void main(String [] args){
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(1,"x");
map.put(2,"a");
map.put(3,"z");
map.put(4,"s");//添加数据

/**
*两种遍历Map集合中数据的方法
*/

//通过set来遍历
Set<Integer> set=map.keySet();//返回键值的set视图
Iterator<Integer> it=set.iterator();//在这里，如果不加上泛型约束的话，就无法找到需要的类型
while(it.hasNext()){
Integer e=it.next();
String v=map.get(e);
System.out.println(v);
}

//通过Entry来遍历
Set<Entry<Integer,String>> entrys=map.entrySet();//返回映射项的set视图
Iterator<Entry<Integer,String>> its=entrys.iterator();
while(its.hasNext()){
Entry<Integer,String> entry=its.next();
System.out.println(entry.getKey()+"->"+entry.getValue());
}
}
}

¨使用泛形时的几个常见问题：

使用泛型时，泛型类型须为引用类型，不能是基本数据类型
使用泛型时，两边的类型必须一致或者两边只有一边用泛型（为了保持兼容性）

自定义泛型：Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法：<T>，T可以是任意字母，但通常必须要大写。<T>通常需放在方法的返回值声明之前。
下有两个泛型方法：

实现交换的泛型方法：

import java.util.Arrays;
import java.util.List;

//编写泛型方法，实现数组元素交换
public class Swap {
/**
* 将数组中指定两个位置的元素进行交换
*/
public static <T> void swap(T[] arr,Integer pos1,Integer pos2){

T temp=arr[pos1];//记录第一个值
arr[pos1]=arr[pos2];//交换
arr[pos2]=temp;
}
public static void main(String[] args) {
String []arr={"a","b","c"};
swap(arr,0,arr.length-1);
List list=Arrays.asList(arr);//把数组转换为集合
System.out.println(list);
}
}

效果：



实现颠倒顺序的泛型方法：

import java.util.Arrays;
import java.util.List;

//编写一个泛型方法，接受一个任意数组，并颠倒数组中的所有元素
public class Reserve {
public static void main(String[] args) {
Integer[] arr={1,2,3,4,5,6,7,8,9,0};
swap(arr);
List list=Arrays.asList(arr);
System.out.println(list);
}
/**
* 泛型方法的定义权限 <T>修饰符  返回值 方法名(参数列表)
* @param <T>
* @param arr
*/
public static <T> void swap(T[] arr){
int start=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--;
}
}
}

效果：



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

privateT field1;

publicvoid save(T
obj){}

publicT getId(int id){}

}

注意：

*
在类级别上定义的泛型,只对类的非静态成员有效
* 静态方法不能使用类定义的泛形，而应单独定义泛形