Generic 泛型

第一讲     泛型（Generic）
一、概述
1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的元素，无法加入指定类型以外的数据。

/*
	在JDK1.5之前，集合定义时不能预集合将要存入的元素是那种类型，只要是引用类型都能add。
	这导致两方面问题，1.取出集合后需要强转；2.程序运行时可能导致java.lang.ClassCastException异常导致程序挂掉；
	如下：
*/
class GenericDemo 
{
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add("abc01");
		al.add("abc0991");
		al.add("abc014");
		al.add(4);//al.add(new Integer(4));		
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			String s = (String)it.next();
			System.out.println(s+":"+s.length());
		}
	}
}

泛型的出现，1方面将ClassCastException的隐患，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2同时，避免了强制转换麻烦。

class GenericDemo 
{
	public static void main(String[] args) 
	{

		ArrayList<String> al = new ArrayList<String>();

		al.add("abc01");
		al.add("abc0991");
		al.add("abc014");

		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());
		}
	}
}

泛型应用示例：

/*
	TreeSet集合。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
	定义一个TreeSet集合，使用泛型。向集合中存入字符串，按字符串长度排序，如果字符串长度相同再按字符大小排序 */

import java.util.*;
class GenericDemo2 
{
	public static void main(String[] args){
		TreeSet<String> set = new TreeSet<String>(new LenComparator());
		set.add("abcdefabcd");
		set.add("hello");
		set.add("nihaom");
		set.add("aaa");
		set.add("aab");
		
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
	}
}

class LenComparator implements Comparator<String>{//实现public interface Comparator<T>接口，此接口支持泛型
	public int compare(String s1, String s2){
		int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
		if(num==0)
			return s2.compareTo(s1);
		return num;
	}
}

二、泛型类

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

/*
//最初做法，对每一种实体类分别定义工具类，通用性差
class Tool
{
	private Worker w;
	public void setWorker(Worker w)
	{
		this.w = w;
	}
	public Worker getWorker()
	{
		return w;
	}
}
*/

class Worker
{

}
class Student
{
}
//泛型前做法。//需要强转，可能产生ClassCastException
class Tool
{
	private Object obj;
	public void put(Object obj)
	{
		this.obj = obj;
	}
	public Object get()
	{
		return obj;
	}
}

//泛型类。
/*
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
*/
class Utils<QQ>
{
	private QQ q;
	public void put(QQ q)
	{
		this.q = q;
	}
	public QQ get()
	{
		return q;
	}
}


class  GenericDemo3
{
	public static void main(String[] args) 
	{

		Utils<Worker> u = new Utils<Worker>();

		u.put(new Worker());
		Worker w = u.get();;
		/*
		Tool t = new Tool();
		t.put(new Student());
		Worker w = (Worker)t.get();
		*/
	}
}

三、泛型方法
泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

//泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
class Tool<T>{
	public void show(T t){
		System.out.println(t);
	}
	public void print(T t){
		System.out.println(t);
	}
}

public class Gen{
	public static void main(String[] args){
			
		Tool<String> tool = new Tool<String>();
		tool.show("abc");
//		tool.print(new Integer(12));//编译报错：错误: 无法将类 Tool<T>中的方法 show应用到给定类型;
	
		
	}
}

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

//泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
class Tool{
	public <T> void show(T t){
		System.out.println(t);
	}
	public <Q> void print(Q q){
		System.out.println(q);
	}
}

public class Gen{
	public static void main(String[] args){			
		Tool tool = new Tool();
		tool.show("abc");
		tool.print(new Integer(12));		
	}
}

//本例中Tool类上定义了泛型，Tool类中的print方法也定义了泛型，则main方法调用print时，可以传入任意引用类型
class Tool <T> {
	public void show(T t){
		System.out.println(t);
	}
	public <Q> void print(Q q){
		System.out.println(q);
	}
}

public class Gen{
	public static void main(String[] args){			
		Tool tool = new Tool();
		tool.show("abc");
		tool.print(new Integer(12));
		tool.print("def");		
	}
}

/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

*/
class Tool <T> {
	public void show(T t){
		System.out.println(t);
	}
	public <Q> void print(Q q){
		System.out.println(q);
	}
	public static void staticmethod(T t){
		System.out.println(t);
	}
}

public class Gen{
	public static void main(String[] args){			
		Tool tool = new Tool();
		tool.show("abc");
		tool.print(new Integer(12));
		tool.print("def");	
		tool.staticmethod(" 无法从静态上下文中引用非静态 类型变量 T");
			
	}
}

/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

*/
class Tool <T> {
	public void show(T t){
		System.out.println(t);
	}
	public <Q> void print(Q q){
		System.out.println(q);
	}
	public static <W> void staticmethod(W w){
		System.out.println(w);
	}
}

public class Gen{
	public static void main(String[] args){			
		Tool tool = new Tool();
		tool.show("abc");
		tool.print(new Integer(12));
		tool.print("def");	
		tool.staticmethod(" 静态方法操作的应用数据类型不确定，可以将泛型定义在方法上");
			
	}
}

四、泛型定义在接口上
示例：

//泛型定义在接口上
interface MyInterface<T>{
	void show(T t);
}

class MyClass implements MyInterface<String>{
	public void show(String s){
		System.out.println(s);
	}
}

class Gen{
	public static void main(String[] args){
		MyClass mc = new MyClass();
		mc.show("hello");
	}
}

//泛型定义在接口上
interface MyInterface<T>{
	void show(T t);
}

class MyClass<T> implements MyInterface<T>{
	public void show(T t){
		System.out.println(t);
	}
}

class Gen{
	public static void main(String[] args){
		MyClass<String> mc = new MyClass<String>();
		mc.show("hello");
	}
}

五、泛型的限定
1.? 通配符。也可以理解为占位符。

//? 通配符。也可以理解为占位符。
import java.util.*;
class Gen{
	public static void main(String[] args){
		ArrayList<String> al1 = new ArrayList<String>();
		al1.add("abc");
		al1.add("def");
		al1.add("ghk");
		
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		al2.add(1);
		al2.add(2);
		al2.add(3);
		
		printColl(al1);
		printColl(al2);
		
	}
	
	public static void printColl(ArrayList<?> al){
		Iterator<?> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

//?通配符，此外也可以在静态方法上定义个<T>来实现上例的功能
import java.util.*;
class Gen{
	public static void main(String[] args){
		ArrayList<String> al1 = new ArrayList<String>();
		al1.add("abc");
		al1.add("def");
		al1.add("ghk");
		
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		al2.add(1);
		al2.add(2);
		al2.add(3);
		
		printColl(al1);
		printColl(al2);
		
	}
	
	public static <T> void printColl(ArrayList<T> al){
		Iterator<T> it = al.iterator();
		while(it.hasNext()){
			T t = it.next();
			System.out.println(t);
		}
	}
}

2.泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。

import java.util.*;
class Gen{
	public static void main(String[] args){
		ArrayList<Person> al1 = new ArrayList<Person>();
		al1.add(new Person("zhangsan"));
		al1.add(new Person("lisi"));
		al1.add(new Person("wangwu"));

		ArrayList<Student> al2 = new ArrayList<Student>();
		al1.add(new Student("xuesheng1"));
		al1.add(new Student("xuesheng2"));
		al1.add(new Student("xuesheng3"));

		
		printColl(al1);
		printColl(al2);
		
	}
	
	public static  void printColl(ArrayList<Person> al){
	//  此处相当于ArrayList<Person> al = ArrayList<Student> al2
	//  错误提示：
	//  需要: ArrayList<Person>	 
	// 找到: ArrayList<Student>   
	// 原因: 无法通过方法调用转换将实际参数ArrayList<Student>转换为ArrayList<Person>
		Iterator<Person> it = al.iterator();
		while(it.hasNext()){		
			System.out.println(it.next());
		}
	}
}

class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public String toString(){
		return this.name;
	}
}
class Student extends Person{
	Student(String name){
		super(name);
	}
}

import java.util.*;
class Gen{
	public static void main(String[] args){
		ArrayList<Person> al1 = new ArrayList<Person>();
		al1.add(new Person("zhangsan"));
		al1.add(new Person("lisi"));
		al1.add(new Person("wangwu"));

		ArrayList<Student> al2 = new ArrayList<Student>();
		al1.add(new Student("xuesheng1"));
		al1.add(new Student("xuesheng2"));
		al1.add(new Student("xuesheng3"));

		
		printColl(al1);
		printColl(al2);
		
	}
	
	public static  void printColl(ArrayList<? extends Person> al){
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext()){		
			System.out.println(it.next());
		}
	}
}

class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public String toString(){
		return this.name;
	}
}
class Student extends Person{
	Student(String name){
		super(name);
	}
}

3. ？ super E: 可以接收E类型或者E的父类型。下限

import java.util.*;
class Gen{
	public static void main(String[] args){
		//注意TreeSet的构造方法：Comparator里面比较的可以是E或者E的父类
		//TreeSet(Comparator<? super E> comparator) 
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("zhangsan"));
		ts.add(new Student("a"));
		ts.add(new Student("bcd"));
		printColl(ts);
	}
	
	public static  void printColl(TreeSet<? extends Person> ts){
		Iterator<? extends Person> it = ts.iterator();
		while(it.hasNext()){		
			System.out.println(it.next());
		}
	}
}

class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public String toString(){
		return this.name;
	}
}
class Student extends Person{
	Student(String name){
		super(name);
	}
}
//注意TreeSet的构造方法：
//TreeSet(Comparator<? super E> comparator) 
//Comparator里面比较的可以是E或者E的父类
//此例中比较器比较的是Student的父类
class Comp implements Comparator<Person>{
	public int compare(Person p1,Person p2){
		return p1.getName().compareTo(p2.getName());
	}
}

第二讲       Collections
一、概述
   Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象。并未封装特有数据。
   在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。

二、常见操作
1、查找
        T max(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素
        T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
        int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
2、替换
        void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
        boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
        void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
3排序：
        void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
        void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
        void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4、反转
        reverse(List<?> list);//反转list集合中元素的顺序
        Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
        Comparator reverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序
5、同步的集合
        List<T> synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合
        Map<K,V> synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合

三、Collections和Collection的区别
        Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
        它有两个常用的子接口：
                List：对元素都有定义索引。有序的。可以重复元素。       
                Set：不可以重复元素。无序
        Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法
       通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

/*
需求：使用Collections中的方法fill对List集合中的部分元素进行替换
思路：1、将List集合中要替换的部分元素取出,并存入另一集合中
	  2、将原集合中的要替换元素移除
	  3、用fill将要替换的元素进行替换
	  4、将取出的部分增加进集合
*/
import java.util.*;
class  FillTest
{
	public static void main(String[] args) 
	{
		List<String> list = new ArrayList<String>();

		list.add("abc");
		list.add("ab");
		list.add("abcd");
		list.add("a");
		list.add("abcde");

		try
		{
			fillSome(list,1,5,"shenma");
		}
		catch (InputException e)
		{
			System.out.println(e.toString());
		}
		System.out.println(list);
	}
	//替换部分元素方法
	public static void fillSome(List<String> list,int start,int end,String s)throws InputException
	{
		if(start>=end)
			throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常

		//定义一个新集合
		List<String> li=new ArrayList<String>();

		//因为每移除一次，后面的元素就会补上，所以这里用y来控制次数
		for (int x=start,y=start;y<end ; y++)
		{
			li.add(list.get(x));//将需要替换的元素增加到新集合
			list.remove(x);//移除需要替换的元素
		}
		
		Collections.fill(li,s);//替换成需要的元素s
		
		list.addAll(start,li);//将替换的部分增加进原集合
	}

}

//自定义异常
class InputException extends Exception
{
	InputException(String Massage)
	{
		super(Massage);
	}
}

第三讲       Arrays
一、概述
        Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
       把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。

二、常见方法
1、Lsit<T> asList(T... a);//将数组转换为集合
注意：
        a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，通过编译，但运行时会因产生UnsupportedOperationException异常而中断运行。
        b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
        c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
2、binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
       特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。
       如：sort(T[]a,Comparator<? super T> c)
                fill(int[]a,int from,int to)等
3、String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。

import java.util.*;
class  Test
{
	public static <T> void sop(T t){
		System.out.println(t);
	}
	
	public static void main(String[] args) 
	{
		int[] arr = {2,4,5};
		String s = Arrays.toString(arr);
		sop(s);
		
		//把数组变成list集合有什么好处？
		/*
		可以使用集合的思想和方法来操作数组中的元素。

		注意：将数组变成集合，不可以使用集合的增删方法。
		因为数组的长度是固定。
		contains。
		get
		indexOf()
		subList();

		如果你增删。那么会反生UnsupportedOperationException */
		String[] ss = {"aaa","bbb","ccc"};
		List ls = Arrays.asList(ss);
		sop("contains:"+ls.contains("bbb"));
		sop("indexof:"+ls.indexOf("bbb"));
	//	ls.add("UnsupportedOperationException");
		
		/*
		如果数组中的元素是对象。那么变成集合时，集合中的元素与数组元素类型相同。
		如果数组中的元素是基本数据类型，变成集合时，该数组作为集合中的唯一元素存在。
		*/
		int[] numbers = {2, 5, 7};
		List lnumbers = Arrays.asList(numbers);
		sop(lnumbers);//[[I@19e0bfd] List内的元素类型为 int[] 类型
		
		Integer[] num = {2, 5, 7};
		List list = Arrays.asList(num);
		sop(list);//[2, 5, 7] List内的元素类型为Integer
	}
}

/*
集合变数组。
Collection接口中的toArray方法。


*/
import java.util.*;
class  Test
{
	public static <T> void sop(T t){
		System.out.println(t);
	}
	
	public static void main(String[] args) 
	{
		
		List<String> list =  new ArrayList<String>();
		list.add("hello");
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
				
		/*
		1,指定类型的数组到底要定义多长呢？
		当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
		当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
		所以创建一个刚刚好的数组最优。
		
		2,为什么要将集合变数组？
		为了限定对元素的操作。不需要进行增删了。
		*/
		String[] ss = list.toArray(new String[5]);
		sop(Arrays.toString(ss));
	}
}

2. 增强for循环
高级for循环
格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{ }

对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

/*
	例子：用增强for循环遍历HashMap
*/
import java.util.*;

class  Test
{
	public static <T> void sop(T t){
		System.out.println(t);
	}
	
	public static void main(String[] args) 
	{
		
		Map<String , Integer> map =  new HashMap<String , Integer>();
		map.put("abc", 11);
		map.put("def", 12);
		map.put("hjk", 13);
		
		Set<String> set = map.keySet();
		//Iterator<String> it = set.iterator();
		
		for(String s : set){
			sop("key: "+ s + " value: "+map.get(s));
		}
		
		for(Map.Entry<String, Integer> entry : map.entrySet()){
			sop(entry.getKey()+" "+entry.getValue());
		}
		

	}
}