【黑马程序员】集合框架（二）泛型 第十六天

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------

知识点

01）TreeSet

/*
 * |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
 * 		|--HashSet：底层的数据结构是哈希表。
 * 			HashSet是如何保证元素唯一性的呢？
 * 			是通过元素的两个方法，hasCode和equals来完成的。
 * 			如果元素的hashCode值相同，才会判断equals是否为true。
 * 			如果hashCode的值不同，就不会判断equals。
 * 		|--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
 */
public class TreeSetDemo {//TreeSet
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
	}
	public static void method_1(){
		TreeSet ts = new TreeSet();
		ts.add("aaa");
		ts.add("abb");
		ts.add("aab");
		ts.add("bba");
		ts.add("baa");
		for (Iterator<E> it = ts.iterator(); it.hasNext();){
			sop("ts = " + it.next());
		}
	}
}

运行结果如下图所示：

02）TreeSet存储自定义对象

/*
 * 需求：
 * 往TreeSet集合中存储自定义对象（学生）。
 * 按照学生的年龄进行排序。
 * 
 * 注意：排序时，当主要条件相同时，一定要往后判断次要条件。
 */
public class TreeSetDemo_2 {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
	}
	public static void method_1(){
		TreeSet ts = new TreeSet();
		ts.add(new Student("汤姆（1）", 20));
		ts.add(new Student("杰瑞（2）", 20));
		ts.add(new Student("汤姆（1）", 20));
		ts.add(new Student("杰瑞（2）", 20));
		ts.add(new Student("汤姆（2）", 21));
		ts.add(new Student("杰瑞（2）", 21));
		System.out.println("-------------------------------");
		for (Iterator it = ts.iterator(); it.hasNext();){
			Student st = (Student)it.next();
			sop(st.getName() + " 的年龄是 = " + st.GetAge());
		}
	}
}
class Student implements Comparable{
	private String name;
	private int age;
	Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj){//复写compareTo。
		if (!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student st = (Student)obj;
		System.out.println(this.name + this.age + " ----比较---- " + st.name + this.age);
		if (this.age > st.age)
			return 1;
		if (this.age == st.age && this.name.equals(st.name))
			return 0;
		return -1;
	}
	public String getName(){
		return name;
	}
	public int GetAge(){
		return age;
	}
}

运行结果如下图所示：

03）二叉树

/*
 * |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
 * 		|--HashSet：底层的数据结构是哈希表。
 * 				HashSet是如何保证元素唯一性的呢？
 * 				是通过元素的两个方法，hasCode和equals来完成的。
 * 		|--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
 * 				底层数据结构是（二叉树）。
 * 				保证元素唯一性的依据是：compareTo方法，return 0;
 * 			TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。
 * 								这种方式也称为元素的自然顺序，默认顺序。
 */
public class TreeSetDemo_3 {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
	}
	public static void method_1(){
		TreeSet ts = new TreeSet();
		ts.add(new Student_3("汤姆（1）", 20));
		ts.add(new Student_3("杰瑞（2）", 20));
		ts.add(new Student_3("汤姆（1）", 20));
		ts.add(new Student_3("杰瑞（2）", 20));
		ts.add(new Student_3("汤姆（2）", 21));
		ts.add(new Student_3("杰瑞（2）", 21));
		for (Iterator it = ts.iterator(); it.hasNext();){
			Student_3 st = (Student_3)it.next();
			sop(st.getName() + " 的年龄是 = " + st.getAge());
		}
	}
}
class Student_3 implements Comparable{
	private String name;
	private int age;
	Student_3(String name, int age){
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj){
		return 1;//值大于0，所以所有的元素都将被存储。（按age值的升序排列）
//		return 0;//值等于0，所以只有第一个元素被存储。
//		return -1;//值大小于0，所有的元素都将被存储。（按age值的降序排列）
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}

运行结果如下图所示：

04）实现Comparator方法排序

/*
 * /*
 * |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
 * 		|--HashSet：底层的数据结构是哈希表。
 * 		|--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
 * 			TreeSet排序的第二种方式：当元素不具备比较性或者具备的比较性不是所需要的。
 * 								这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
 * 定义比较器，将比较器作为参数传递给TreeSet集合的构造函数。
 * 
 * 当两种方式都存在时：以比较器为主。			
 * 定义一个类，实现Comparator接口，覆盖compare方法。	
 */
public class TreeSetDemo_4 {//Comparator
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_4();
		System.out.println("--------------------");
		method_5();
	}
	public static void method_4(){//Comparable
		TreeSet ts = new TreeSet();
		ts.add(new Student_4("汤姆（1）", 20));
		ts.add(new Student_4("杰瑞（2）", 20));
		ts.add(new Student_4("汤姆（1）", 20));
		ts.add(new Student_4("杰瑞（2）", 20));
		ts.add(new Student_4("汤姆（2）", 21));
		ts.add(new Student_4("杰瑞（2）", 21));
		for (Iterator it = ts.iterator(); it.hasNext();){
			Student_4 st = (Student_4)it.next();
			sop(st.getName() + " 的年龄是 = " + st.getAge());
		}
	}
	public static void method_5(){//Comparator
		TreeSet ts = new TreeSet(new MyCompare());//将比较器作为参数传递给TreeSet集合的构造函数。
		ts.add(new Student_4("汤姆（1）", 20));
		ts.add(new Student_4("杰瑞（2）", 20));
		ts.add(new Student_4("汤姆（1）", 20));
		ts.add(new Student_4("杰瑞（2）", 20));
		ts.add(new Student_4("汤姆（2）", 21));
		ts.add(new Student_4("杰瑞（2）", 21));
		for (Iterator it = ts.iterator(); it.hasNext();){
			Student_4 st = (Student_4)it.next();
			sop(st.getName() + " 的年龄是 = " + st.getAge());
		}
	}
}
class Student_4 implements Comparable{
	private String name;
	private int age;
	Student_4(String name, int age){
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj){//复写compareTo。TreeSet只看结果（return），是正还是负。
		if (!(obj instanceof Student_4))
			throw new RuntimeException("不是学生对象");
		Student_4 st = (Student_4)obj;
		if (this.age > st.age)
			return 1;
		if (this.age == st.age)
			return this.name.compareTo(st.name);
		return -1;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}
class MyCompare implements Comparator{//定义比较器。
	public int compare(Object obj1, Object obj2){
		Student_4 st1 = (Student_4)obj1;
		Student_4 st2 = (Student_4)obj2;
		int num = st1.getName().compareTo(st2.getName());//姓名相同的元素将不存储。
		if (num == 0){
			return new Integer(st1.getAge()).compareTo(new Integer(st2.getAge()));
		}
		return num;
	}
}

运行结果如下图所示：

05）TreeSet（练习）

/*
 * 练习：按照字符串长度排序。
 * 
 * 字符串本身具备比较性，但是它的比较方式不是所需要的。
 * 这时只能创建比较器。
 */
public class TreeSetTest {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_test();
	}
	public static void method_test(){
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("stre");
		ts.add("hgjfgh");
		ts.add("xvc");
		ts.add("wgre");
		ts.add("mfhfg");
		for (Iterator it = ts.iterator(); it.hasNext();){
			sop(it.next());
		}
	}
}
class StrLenComparator implements Comparator{
	public int compare(Object o1, Object o2) {
		String s1 = (String)o1;
		String s2 = (String)o2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));//主要条件满足：比较字符串长度
		if (num == 0)//比较次要条件：比较字符串值
			return s1.compareTo(s2);
		return num;
	}
}

运行结果如下图所示：

06）泛型（概述）

/*
 * 泛型：jdk1.5版本以后出现的新特性。用于解决安全隐患，是一个类型安全机制。
 * 好处：
 * 	1：将运行时期出现的问题ClassCastException，转移到编译时期，方便于程序员发现并解决问题。安全。
 *  2：避免了强制转换麻烦。
 */
public class GenericDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
		System.out.println("--------------------");
		method_2();
	}
	public static void method_1(){
		ArrayList<String> al = new ArrayList<String>();
		al.add("yert");
		al.add("nbvwc");
		al.add("q1aqed");
		al.add("sgdhdfghd");
		al.add("q2rqed");
		al.add("fqwdfd");
//		al.add(5);//传入错误的参数类型，类型转换异常：ClassCastException
		for (Iterator<String> it = al.iterator(); it.hasNext();){
			String s = it.next();
			sop(s + " = " + s.length());
		}
	}
	public static void method_2(){
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(1);
		al.add(2);
		al.add(3);
		al.add(3);
		al.add(2);
		al.add(1);
//		al.add(5);//传入错误的参数类型，类型转换异常：ClassCastException
		for (Iterator<Integer> it = al.iterator(); it.hasNext();){
			Integer i = it.next();
			sop(i);
		}
	}
}

运行结果如下图所示：

07）泛型（使用）

/*
 * 泛型格式：通过<>来定义要操作的引用数据类型。
 * 在使用Java提供的对象时，什么时候使用泛型呢？
 * 		通常在集合框架中很常见，只要剑道<>就要定义泛型。
 * 其实<>就是用来接收类型的：当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
 */
public class GenericDemo_2 {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_2();
	}
	public static void method_2(){
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		ts.add("aa2a");
		ts.add("abbafd");
		ts.add("aabva");
		ts.add("aabva");//false
		ts.add("bwebavc");
		ts.add("weqbaa");
		for (Iterator<String> it = ts.iterator(); it.hasNext();){
			String s = it.next();
			sop(s + " = " + s.length());
		}
	}
}
class LenComparator implements Comparator<String>{
	public int compare(String o1, String o2) {
		int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
		if (num == 0)
			return o2.compareTo(o1);
		return num;
	}
}

运行结果如下图所示：

08）泛型（类）

/*
 * 定义泛型类。
 * 当类中要操作的（引用数据类型）不确定的时候用泛型类。
 * 早期是通过定义Object来完成扩展的，现在通过定义泛型来完成扩展。
 */
public class GenericClassDemo {
	public static void main(String[] args) {
		Utlis<Worker> tls = new Utlis<Worker>();
		tls.setWork(new Worker());
		Worker w = tls.getWork();
	}
}
class Worker{}
class Teacher{}
class Utlis<Job>{//泛型类
	private Job j;
	public void setWork(Job j){
		this.j = j;
	}
	public Job getWork(){
		return j;
	}
}

09）类、方法（泛型）

/*
 * 泛型类（Method_1<D>）定义的泛型，在整个类中有效，如果被方法使用，那么当泛型类的对象明确要操作的具体类型后，所有要操作的类型都将固定。
 * 
 * 为了让不同的方法可以操作不同类型，而且类型还不确定。
 * 那么可以将泛型定义在方法上。（Method_2）
 */
public class GenericMethodDemo {
	public static void main(String[] args) {
		method_1();
		System.out.println("----------------------");
		method_2();
	}
	public static void method_1(){//使用泛型类。
		Method_1<String> m1 = new Method_1<String>();
		m1.show("hah");
		m1.print("heh");
		Method_1<Integer> m1_i = new Method_1<Integer>();
		m1_i.show(new Integer(110));
		m1_i.print(119);
	}
	public static void method_2(){
		Method_2 m2 = new Method_2();
		m2.show("哇哈哈");
		m2.print(222);
		m2.print("嘿嘿");
	}
}

class Method_1<D>{//泛型类。
	public void show(D d){
		System.out.println("（泛型类）Show: " + d);
	}
	public void print(D d){
		System.out.println("（泛型类）Print: " + d);
	}
}
class Method_2{
	public <Q> void show(Q q){//泛型方法。
		System.out.println("（泛型方法）Show: " + q);
	}
	public <Q> void print(Q q){
		System.out.println("（泛型方法）Print: " + q);
	}
}

10）静态方法（泛型）

/*
 * 静态方法泛型。
 * 特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
 */
public class GenericStaticDemo {
	public static void main(String[] args) {
		method();
	}
	public static void method(){
		StaticDemo<String> s = new StaticDemo<String>();
		s.show("hah");
		s.print("heh");
		s.print(119);
		s.method_Static("哇咔咔");
		s.method_Static(new Integer(369));
	}
}
class StaticDemo<Q>{
	public void show(Q q){
		System.out.println("（泛型类）Q： " + q);
	}
	public <Q> void print(Q q){
		System.out.println("（泛型方法）： " + q);
	}
	public static <Q> void method_Static(Q q){
		System.out.println("（静态）（泛型方法）： " + q);
	}
}

运行结果如下图所示：

11）接口（泛型）

public class GenericInterDemo {
	public static void main(String[] args) {
		method();
	}
	public static void method(){
		GenericImpl gi = new GenericImpl();
		gi.show("hah");
		gi.show("heh");
		gi.print(new Integer(119));
		gi.print(120);
		gi.print("哇哈哈");
	}
}
interface GenericInter<I> {//泛型定义在接口上。
	void show(I i);
}
class GenericImpl implements GenericInter<String>{
	public void show(String s){
		System.out.println("（接口）show： " + s);
	}
	public <I> void print(I i){
		System.out.println("（方法）print： " + i);
	}
}

运行结果如下图所示：

12）泛型限定（一）

/*
 * 泛型的一些高级应用。
 * <?>通配符。也可以理解为占位符。
 * <? extends E>：可以接受E类型或者E的子类型。<上限限定>。
 * <? super E>：可以接受E类型或者E的父类型。<下限限定>。
 */
public class GenericAdvDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
		method_2();
		method_3();
	}
	public static void method_1(){
		ArrayList<String> al1 = new ArrayList<String>();
		al1.add("Java01");
		al1.add("Java02");
		al1.add("Java03");
		printColl_1(al1);
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		al2.add(01);
		al2.add(02);
		al2.add(03);
		printColl_1(al2);
	}
	public static void method_2(){
		ArrayList<Person_adv> ap1 = new ArrayList<Person_adv>();
		ap1.add(new Person_adv("汤姆"));
		ap1.add(new Person_adv("汤姆"));
		ap1.add(new Person_adv("汤姆"));
		printColl_2(ap1);
		ArrayList<Student_Adv> ap2 = new ArrayList<Student_Adv>();
		ap2.add(new Student_Adv("杰瑞"));
		ap2.add(new Student_Adv("杰瑞"));
		ap2.add(new Student_Adv("杰瑞"));
		printColl_2(ap2);
	}
	public static void method_3(){
		TreeSet<Student_Adv> ts = new TreeSet<Student_Adv>(new Comp());
		ts.add(new Student_Adv("斯派克一号"));
		ts.add(new Student_Adv("斯派克二号"));
		ts.add(new Student_Adv("斯派克二号"));
		ts.add(new Student_Adv("斯派克三号"));
		ts.add(new Student_Adv("斯派克五号"));
		printColl_3(ts);
	}
	public static void printColl_1(ArrayList<?> al){//<上限限定>
		for (Iterator<?> it = al.iterator(); it.hasNext();){
			sop(it.next());
		}
		System.out.println("-----------------------");
	}
	public static void printColl_2(ArrayList<? extends Person_adv> ap){
		for (Iterator<? extends Person_adv> it = ap.iterator(); it.hasNext();){
			sop(it.next().getName());
		}
		System.out.println("-----------------------");
	}
	public static void printColl_3(TreeSet<? extends Person_adv> ap){
		for (Iterator<? extends Person_adv> it = ap.iterator(); it.hasNext();){
			sop(it.next().getName());
		}
		System.out.println("-----------------------");
	}
}

class Person_adv{
	private String name;
	Person_adv(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}
class Student_Adv extends Person_adv{
	Student_Adv(String name){
		super(name);
	}
}
class Comp implements Comparator<Student_Adv>{//比较器。
	public int compare(Student_Adv s1, Student_Adv s2){
		return s1.getName().compareTo(s2.getName());
	}
}

运行结果如下图所示：

13）泛型限定（二）

/*
 * TreeSet通过直接传入父类比较器。
 */
public class GenericAdvDemo_2 {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_1();
		method_2();
	}
	public static void method_1(){
		TreeSet<Student_Adv_2> ts = new TreeSet<Student_Adv_2>(new StuComp());//传入父类比较器。
		ts.add(new Student_Adv_2("（Stu）Java01"));
		ts.add(new Student_Adv_2("（Stu）Java04"));
		ts.add(new Student_Adv_2("（Stu）Java02"));
		ts.add(new Student_Adv_2("（Stu）Java06"));
		ts.add(new Student_Adv_2("（Stu）Java05"));
		ts.add(new Student_Adv_2("（Stu）Java02"));
		printColl_1(ts);
		System.out.println("---Student_Adv_2---");
	}
	public static void method_2(){
		TreeSet<Worker_Adv_2> tw = new TreeSet<Worker_Adv_2>(new AllComp());//传入StuComp（子类）比较器。
		tw.add(new Worker_Adv_2("（Wok）Java01"));
		tw.add(new Worker_Adv_2("（Wok）Java04"));
		tw.add(new Worker_Adv_2("（Wok）Java02"));
		tw.add(new Worker_Adv_2("（Wok）Java06"));
		tw.add(new Worker_Adv_2("（Wok）Java05"));
		tw.add(new Worker_Adv_2("（Wok）Java02"));
		printColl_1(tw);
		System.out.println("---Person_adv_2---");
	}
	public static void printColl_1(TreeSet<? extends Person_adv_2> ts){
		for (Iterator<? extends Person_adv_2> it = ts.iterator(); it.hasNext();){
			sop(it.next().getName());
		}
	}
}
class AllComp implements Comparator<Person_adv_2>{//AllComp（父类）比较器
	public int compare(Person_adv_2 p1, Person_adv_2 p2){
		return p2.getName().compareTo(p1.getName());
	}
}
class StuComp implements Comparator<Student_Adv_2>{//StuComp（子类）比较器
	public int compare(Student_Adv_2 s1, Student_Adv_2 s2){
		return s1.getName().compareTo(s2.getName());
	}
}
class WorkComp implements Comparator<Worker_Adv_2>{//WorkComp（子类）比较器
	public int compare(Worker_Adv_2 w1, Worker_Adv_2 w2){
		return w1.getName().compareTo(w2.getName());
	}
}
class Person_adv_2{
	private String name;
	Person_adv_2(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public String toString(){
		return "Person_adv_2： " + name;
	}
}
class Student_Adv_2 extends Person_adv_2{
	Student_Adv_2(String name){
		super(name);
	}
}
class Worker_Adv_2 extends Person_adv_2{
	Worker_Adv_2(String name){
		super(name);
	}
}

运行结果如下图所示：

附言：我是Java新人，如有错误的地方请指出。

                       每天学习一点点，纠错一点点，进步很大点。

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------