java毕向东听课笔记26（集合框架-泛型）

泛型是在JDK1.5以后出现了，用于解决安全问题，是一个类型安全机制。怎么体现安全的呢：

我们知道，数组是比较安全的，因为定义数组的时候，规定了里面存储元素的类型，如果在int类型的数组里添加了double类型的数据则会出现编译失败，如：

class ArrayDemo2{
	public static void main(String[] args){
		int[] arr = new int[4];
		arr[0] = 1;
		arr[1] = 1.5;
	}
}

集合存在的安全隐患就是，集合什么都可以存储，没有事先规定里面装的元素是什么类型，所以泛型出现了。

好处：

          1.将运行时期出现问题ClassCastException转移到了编译时期，方便于程序员解决问题，让运行时问题减少，提高安全性

          2.避免了强制转换的麻烦

如：

import java.util.*;

class GenericDemo{
	public static void main(String[] args){
		ArrayList<String> al = new ArrayList<String>();//规定集合里的元素都为String类型
		
		al.add("abc001");
		al.add("abc713892");
		al.add("abc423");
		
		//al.add(4);//al.add(new Integer(4));//会报错
		Iterator<String> it = al.iterator();
		
		while(it.hasNext()){
			String s = it.next();//不用强制类型转换
			System.out.println(s+":"+s.length());
		}
		
	}
}

之前学集合框架时提示的安全隐患也消失了。

---------------------------------------------------------

泛型格式：通过<>来定义要操作的引用数据类型

在使用java提供的对象时，什么时候写泛型呢？通常在集合框架中很常见，只要见到<>就要定义泛型。

其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可。

泛型在Comparator中的应用

      之前在TreeSet中讲了关于Comparator，现在可以改进一下

import java.util.*;

class GenericDemo2{
	public static void main(String[] args){
		TreeSet<String> ts =new TreeSet<String>(new StringLengthComparator());
		
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("z");
		ts.add("hahaha");
		
		Iterator it = ts.iterator();
		
		while(it.hasNext()){
			sop(it.next());
		}
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

class StringLengthComparator implements Comparator<String>{
	public int compare(String o1,String o2){
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		
		if(num==0)
			return o1.compareTo(o2);
		return num;
	}
}

没有警告了。

-------------------------------------------------------------

泛型类：

           在没有泛型之前，我们定义一个工人类(Worker），一个学生类(Student)和一个对这两个类操作的工具类(Tool)

import java.util.*;

class Student{
	
}

class Worker{
	
}

class Tool{
	private Object obj;
	public void setObject(Worker obj){
		this.obj = obj;
	}
	public Object getObject(){
		return obj;
	}
}

class GenericDemo3{
	public static void main(String[] args){
		Tool t = new Tool();
		t.setObject(new Worker());
		Worker w = (Worker)t.getObject();
		
		
	}
}

import java.util.*;

class Student{
	
}

class Worker{
	
}

class GenericDemo3{
	public static void main(String[] args){
		Util<Worker> u = new Util<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();
	}
}

class Util<QQ>{//泛型类
	private QQ q;
	public void setObject(QQ q){
		this.q = q;
	}
	public QQ getObject(){
		return q;
	}
}

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展

-----------------------------------------

      泛型方法

       为了让不同方法可以操作不同类型，而且类型还不确定，那么可以把泛型定义在方法上

class Demo{
	public <T> void show(T t){
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q){
		System.out.println("print:"+q);
	}
}

class GenericDemo4{
	public static void main(String[] args){
		Demo d = new Demo();
		d.show(new Integer(4));
		d.show("haha");
	}
}

特别的，静态方法不可以访问类上定义的泛型。

如果静态方法操作的数据类型不确定，可以将泛型定义在方法上。

---------------------------------------------------------------------

泛型接口：

interface Inter<T>{
	void show(T t);
}

class InterImpl implements Inter<String>{
	public void show(String str){
		System.out.println("show:"+str);
	}
}

class GenericDemo5{
	public static void main(String[] args){
		InterImpl i = new InterImpl();
		i.show("haha");
	}
}

如果实现接口的时候也不知道要传入数据的类型，可以这么办：

interface Inter<T>{
	void show(T t);
}

class InterImpl<T> implements Inter<T>{
	public void show(T t){
		System.out.println("show:"+t);
	}
}

class GenericDemo5{
	public static void main(String[] args){
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
	}
}

泛型限定

使用占位符?（也叫通配符）

import java.util.*;
class GenericDemo6{
	public static void main(String[] args){
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(2);
		al1.add(6);
		al1.add(3);
		
		printColl(al);
		printColl(al1);
	}
	
	public static void printColl(ArrayList<?> al){
		Iterator<?> it = al.iterator();
		
		while(it.hasNext())
			System.out.println(it.next());
	}
}

泛型的限定：

                  ? extends E;可以接收E类型或者E的子类型。上限。

                  ? super E：可以接收E类型或者E的父类型。下限。