黑马程序员---集合框架<泛型>

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

 

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

 

加上泛型，解决了以下这个问题：

 

好处：

    1.将运行时期出现的问题ClassCastException，转移到了编译时期。

       方便于程序员解决问题，让运行时期问题减少，安全。

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

 

import java.util.*;
class GenericDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet<String> al = new TreeSet<String>(new LenCompare());
		al.add("hfjz");
		al.add("abcdef");
		al.add("hgf");
		al.add("aaa");
		al.add("a");

		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

class LenCompare implements Comparator<String>
{
	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;
	}
}

 

现在定义一个像 Student这样的自定义 类，我们就 需要实现它的所有基本功能，不管能不能用的上。

包括： hashCode() 、 equals() 、 实现Comparable:覆盖compareTo() 、 toString() 。

 

import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+"::"+age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*39;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
		{
			throw new RuntimeException("不是学生");
		}
		Student s = (Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(0==num)
		{
			return this.name.compareTo(s.name);
		}
		return num;
	}
}

class GenericTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method_HashSet()
	{
		HashSet<Student> hs = new HashSet<Student>();
		hs.add(new Student("lisi03",11));
		hs.add(new Student("lisi01",12));
		hs.add(new Student("lisi01",12));
		hs.add(new Student("lisi09",11));
		hs.add(new Student("lisi03",15));
		Iterator<Student> it = hs.iterator();
		while(it.hasNext())
		{
			sop(it.next().toString());
		}
	}
	public static void method_TreeSet()
	{
		TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
		ts.add(new Student("lisi03",12));
		ts.add(new Student("lisi01",13));
		ts.add(new Student("lisi01",12));
		ts.add(new Student("lisi09",11));
		ts.add(new Student("lisi03",15));
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next().toString());
		}
	}
	public static void main(String[] args)
	{
		//method_TreeSet();
		method_HashSet();
	}
}

class MyCompare implements Comparator<Student>
{
	public int compare(Student s1, Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(0==num)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

 

泛型类：

假如：我们定义了一个Worker类，

 

class  Worker

{

}

 

就需要一个操作Worker类的工具类，

 

class  Tool

{

        private  Worker  w;

        public  void  setWorker ( Worker  w )

        {

                this.w = w;

        }

        public  Worker  getWorker ( )

        {

                return w;

        }

}

 

如果我们又定义了一个Student类，那么我们就又需要一个操作Student类的工具类。

如果我们定义许许多多的类，那么就需要定义许许多多的工具类。

这样很麻烦，所以我们就想办法定义一个特殊的工具类，它能够操作任何的自定义类，下面就产生了它，

 

class Tools

{

        private  Object  obj;

        public  void  setObject ( Object  obj )

        {

                this.obj = obj;

        }

        public  Object  getObject ( )

        {

                return obj;

        }

}

 

这样的工具类也有它的不安全性，比如说，我们误将一个Student类的引用当作参数传递给了一个Worker的引用，但是在编译时期是可以通过的，只能等到在运行时期才会报错，

 

class  GenericTest

{

        public  static  void  main ( String  args[ ] )

        {

                Tools  t  =  new  Tools () ;

                t . setObject ( new  Student () ) ;

                Worker  w  =  ( Worker )  t . getObject () ;  

        }

}

 

 

我们把这种编译时期检测不到的错误看成是不安全性，这时我们就需要通过泛型来把运行时期的问题转移到编译时期来，这样开发人员能看到错误，提高了安全性，

 

class Worker
{
}

class Student
{
}

class Tools<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

class GenericTest1 
{
	public static void main(String[] args) 
	{
		Tools<Worker> t = new Tools<Worker>();
		t.setObject(new Worker());
		Worker w = t.getObject();
	}
}

 

总结：

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

 

泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。

 

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

class GenericDemo1 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show("abcde");
		d.print(3);
	}
}

 

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

class GenericDemo2 
{
	public static void main(String[] args) 
	{
		Demo<String> d = new Demo<String>();
		d.show("abcde");
		d.print(3);
	}
}

 

特殊之处：
静态方法不可以访问类上定义的泛型。

因为泛型类在建立对象之后才能明确要操作的具体类型，产生静态方法的时候，类型还没确定，所以不可以使用类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

 

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

class GenericDemo3 
{
	public static void main(String[] args) 
	{
		Demo<String> d = new Demo<String>();
		d.show("abcde");

		Demo.print(3);
	}
}

 

泛型定义在接口上：

 

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

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

class GenericDemo4 
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> in = new InterImpl<Integer>();
		in.show(3);
	}
}

 

通配符 <?>  和 泛型 <T> 的区别：

 

写泛型 <T> 可以对此T类型进行操作，

 

import java.util.*;
class GenericDemo5 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("aaa01");
		al.add("aaa02");
		al.add("aaa03");
		al.add("aaa04");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(1);
		al1.add(3);
		al1.add(7);

		printColl(al);
		printColl(al1);
	}

	public static <T> void printColl(ArrayList<T> al)
	{
		Iterator<T> it = al.iterator();

		while(it.hasNext())
		{
			T t = it.next();//写泛型，可以使用此类型进行操作。
			System.out.println(t);
		}
	}
}

 

写通配符 <?> 不可以对此类型进行操作，

 

import java.util.*;

class GenericDemo6 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("aaa01");
		al.add("aaa02");
		al.add("aaa03");
		al.add("aaa04");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(1);
		al1.add(3);
		al1.add(7);

		printColl(al);
		printColl(al1);
	}

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

 

这两个符号都叫泛型。用泛型的好处是，可以扩展，提高代码复用性，坏处是不可以使用类型特有的方法如length()；但是可以使用toString()，因为所有类型都具备，不写toString()直接打印默认也是toString()。

 

 ? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。

 

import java.util.*;
class GenericDemo7 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc001"));
		al.add(new Person("abc002"));
		al.add(new Person("abc003"));
		al.add(new Person("abc004"));

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("S-abc--001"));
		al1.add(new Student("S-abc--002"));
		al1.add(new Student("S-abc--003"));
		al1.add(new Student("S-abc--004"));

		ArrayList<Worker> al2 = new ArrayList<Worker>();
		al2.add(new Worker("W-abc--001"));
		al2.add(new Worker("W-abc--002"));
		al2.add(new Worker("W-abc--003"));
		al2.add(new Worker("W-abc--004"));

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

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

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

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

 

import java.util.*;
class GenericDemo8 
{
	public static void main(String[] args) 
	{
		//因为Student本身不具备比较性，所以可以传本身的比较器对象或者父类的比较器对象。
		//TreeSet(Comparator<? super E> comparator) 
		TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
		ts.add(new Student("s-abc--001"));
		ts.add(new Student("s-abc--002"));
		ts.add(new Student("s-abc--003"));
		ts.add(new Student("s-abc--004"));

		TreeSet<Worker> ts1 = new TreeSet<Worker>(new MyCompare());
		ts1.add(new Worker("w-abc--001"));
		ts1.add(new Worker("w-abc--002"));
		ts1.add(new Worker("w-abc--003"));
		ts1.add(new Worker("w-abc--004"));

		printCollection(ts);
		printCollection(ts1);
	}
	
	/*给每一个TreeSet对象定义一个迭代器比较麻烦，所以将功能抽取，封装成函数，
	此函数定义了一个<? extends E>类型参数，指定了上限，可以接收E或者E的子类*/
	public static void printCollection(TreeSet<? extends Person> ts)
	{
		Iterator<? extends Person> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

class MyCompare implements Comparator<Person>//父类比较器
{
	public int compare(Person p1, Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}

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

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net