泛型（generic）

集合中的数据类型

n 集合类中可以存储各种数据，数据一旦存入，其类型均会转化为 Object 类型。

n 从集合类中取出数据时，一般均需要将 Object 类型转换回存入之前的实际类型

Vector v=new Vector();

v.add("张三"); //存入字符串

String name=(String)v.get(0); //强制类型转换，OK

v.add(newDate()); //存入当前时间对象，OK

/*

由于Date类型不能转换为String，下面语句会在运行时发生错误，但这种错误在编译时不会被检查出来

*/

String date=(String)v.get(1); //编译器不会发现这里有问题

n 传统的集合类的实例中可以存储任意类型数据，这种集合类称为弱类型集合类。

n JDK1.5 以后，引入了强类型集合类

= 强类型集合类中，只能存储指定类型的数据

= 在强类型集合类中取出数据时，无需进行类型转换处理，如果数据类型不配备，编译时会直接报错

= 强类型集合并没有引入新的类名，只需在定义原有集合对象时，用尖括号 (<>) 指明其存储的数据类型名称即可。

//下面的向量类的实例中只能存储字符串类型数据

Vector<String>v=new Vector<String>();

v.add("张三");//加入的是字符串，OK

String name=v.get(0); //取出时，无需做类型转换

/*

如果想在这种强类型集合中加入日期数据，在编译时就会报告错误

*/

v.add(newDate()); //编译器会直接报告类型不匹配错误

n 强类型集合采用了 JDK1.5 引入的泛型语法。

n 泛型相当于类中一种特殊的类型，这种类型的特点是在实例化该类时可指定为某个具体的实际类型。

n 声明包含泛型的类的格式如下：

[访问修饰符]class 类名<泛型1,泛型2,…>{

泛型1 泛型成员1;

泛型2 泛型成员2;

//....

}

n 声明中的泛型 1 、泛型 2 等等泛型符号可以是任意合法的 Java 标识符。

/*

此处声明了一个包含泛型T的泛型类,T代表所有可能的类型，而T

的实际类型在Generic类实例化时指定。

*/

public class Generic<T> {

privateTf; //f为泛型成员

public void setF(T f) {//setF方法的参数类型为泛型T

this.f = f;

}

publicTgetF(){//getF方法的返回类型为泛型T

return f;

}

}

n 创建泛型类的实例时，可以使用一对尖括号指定泛型的真正类型

n 泛型类实例化时，并不一定要指明泛型对应的实际类型，此时会使用 Object 作为泛型的默认类型

n 如果要建立泛型类的数组，需要注意 new 关键字后面不要加入泛型的实际类型名，如下所示：

Generic<String>[] gs; //声明泛型类的数组

//先对泛型数组进行初始化

gs=new Generic[5]; //不要写成newGeneric<String>[5]

//再分别为每一个数组元素进行初始化

gs[0]=new Generic<String>();//为第一个数组元素赋值

//....

泛型

JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。
public void test1()
{
List list= new ArrayList();
List.add("abc");
Integer k=(Integer)List.get(0);
//编译时不会出现错误，运行时会出现错误
}

为了避免这种情况，使其错误在编译时出现。所以引用啦泛型

List<Integer> List2= new ArrayList<Integer>();
List2.add(1);

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

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

泛型典型应用
a 使用迭代器迭代泛型集合中的元素

eg
public void test2(){
List<Integer> List = newArrayList<Integer>;
List.add(1);
List.add(2);
List.add(3);
Iterator<Integer> it=List.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
b 使用增强for循环迭代泛型集合中的元素

eg
public void text3(){
List<Integer> List=new ArrayList<Integer>;
List.add(1);
List.add(2);
List.add(3);
for(Integer i:List){
System.out.ptintln(i);
}
}
c 存取HashMap中的元素
public void test4(){
Map<String,Integer>map=new HashMap<String.Integer>{};
map.put{"key1",1};
map.put{"key2",2};
map.put{"key3",3};

Set<MapEntry<String,Integer>> set = map.entrySet()};
}

使用泛形时的几个常见问题：
使用泛形时，泛形类型须为引用类型，不能是基本数据类型
ArrayList<String> list = new ArrayList<Object>(); //错
ArrayList<Object> list = new ArrayList<String>(); //错
ArrayList<String> list = new ArrayList (); //行
ArrayList list = new ArrayList<String>(); //行
注:使用泛型
* 两边的类型必须一致
ArrayList<String> list = new ArrayList<String>();
* 两边只有一边用泛型(为了保持兼容性)
ArrayList<String> list = new ArrayList ();
ArrayList list = new ArrayList<String>();

Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法：<T> ，T可以是任意字母，但通常必须要大写。<T>通常需放在方法的返回值声明之前。例如：
public static <T> void method(T t);
注意：
只有对象类型才能作为泛型方法的实际参数。
在泛型中可以同时有多个类型，例如：
编写一个泛型方法，实现数组元素的交换

public void test1(){
String[] arr={"a","b","c"};
swap(arr,0,2);
List list=Arrays.asList(arr);
System.out.println(list);
public <T> void swap(T[] arr,Integer pos1,Integer pos2){
T temp=arr[pos1];
arr[pos1]=arr[pos2];
arr[pos2]=temp;
}
}

编写一个泛型方法，接收一个任意数组，并颠倒数组中所有的元素

public <T> void reverse(T[] arr)
{
int start=0;
int end=arr.length-1;
while(true){
if(start>=end){
break;
}
T temp=arr[end];
arr[start]=arr[end];
arr[end]=temp;
start++;
end--;
}
}
public void test2(){
Integer[] arr={1,2,3};
swap(arr,0,2);
List list=Array.asList(arr);
System.out.println(list);
}
自定义泛型----泛型类
如果一个类多处都要用到同一个泛型，这时可以把泛形定义在类上（即类级别的泛型），语法格式如下：
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getId(int id){}
}
注意
* 在类级别上定义的泛型,只对类的非静态成员有效
* 静态方法不能使用类定义的泛形，而应单独定义泛形

public class DemoClass3<T>
{
public void method1(T t)
{

}
public void method2(T t){

}
public static <T>void method3(T t)
{

}
}
注意： 静态方法不能使用类定义的泛型，而应单独使用定义。

泛型的高级应用--通配符

定义一个方法，接收一个集合，并打印出集合中的所有元素，如下所示：
voidprint（Collection<String>c）
{
for(String e:c)
{
System.out.println(e);
}
该方法只能打印保存了String对象的集合，不能打印其它集合。通配符用于解决此类问题，方法的定义可改写为如下形式：
void print(Collection<?>c)
{
for(Object e:c){
System.out.println(e);
}
此种形式下需要注意的是：由于print方法c参数的类型为Collection<?>，即表示一种不确定的类型，因此在方法体内不能调用与类型相关的方法，例如add()方法。
但可以调用与类型无关的方法，例如size()方法
总结：使用?通配符主要用于引用对象，使用了?通配符，就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。

public static void main(String[] args){
List<String>List=new ArrayList<String>();
List.add("a1");
List.add("a2");
println(List2);
}
public static void println(Collection<?>c)
{
c.size();
for(Object e:c)
{
System.out.println(e);
}

}