day15TreeSet，二叉树原理，比较器，泛型，自定义泛型

最新推荐文章于 2022-06-23 16:12:48 发布
火鱼
最新推荐文章于 2022-06-23 16:12:48 发布
阅读量721
点赞数
本文链接：https://blog.csdn.net/luck28/article/details/8964303
版权
/*
TreeSet，二叉树原理，比较器，泛型，自定义泛型
*/


/*
|--Set:元素是无序的（存入和取出的顺序不一致），元素不可重复
	|--HashSet:底层数据结构是哈希表。线程是非同步的。
		是如何保证元素的唯一性的呢？(依据)
		判断是通过元素的两个方法，先判断hashCode，如果相同，再判断equals来完成
		如果元素Hashcode一样，才会判断equals是否为真
		如果元素的Hashcode不同，不会调用equals.

		注意，对于判断元素是否存在，以及删除等操作，依赖hashCode和equals方法来完成

	|--TreeSet:可以对Set集合中的元素进行排序。
				底层数据结构是二叉树。
				保证元素唯一性的依据
				compareTo方法，相同return 0 ;
				
				二叉树存：大的在右下，小的在左下。
				取值：先取小的，再取大的
					
				排序技巧：当compareTo()总是返回1：正序。就是和存入顺序一样了。
								返回-1，逆序。

				TreeSet排序的第一种方式。让元素自身具备可比性
				元素需要实现Comparable接口，覆盖compareTo方法
				这种方式就是元素的自然顺序。

				TreeSet的第二种排序方式。比较器
				当元素自身不具备比较性时，或者具备的比较性不是所需要的
				这时就需要让集合具备比较性。
				定义一个类，实现Comparator接口，覆盖compare方法。
				在集合初始化时，传入这个类的对象，就有了比较方式。
				TreeSet ts = new TreeSet(new Mycompare());

Set集合的功能和Collect是一致的，
哈希表存对象。
先比较哈希值，如果相同，再比较对象equals。


练习需求：往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序。

comparable compareTo , comparator compare
记住。排序时，当主要条件相同时，按照次要条件再排序。
*/
import java.util.*;

class  TreeSetDemo
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));//为什么存一个没事？存二个就出错？
										//向Tree里面存对象，是要排序的，必须要有比较性，类的自然顺序。
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));//如果年龄相同，那么存不进去？判断唯一性。

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
			//System.out.println(it.next());
		}
		
	}
}

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)//覆盖接口方法
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
			
		Student s = (Student)obj;
		System.out.println(this.name+".compareto."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age == s.age)
			//return 0;当年龄相同，再判断姓名。主副条件
		{
			return this.name.compareTo(s.name);//String也实现了此接口
		}
		return -1;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}

import java.util.*;
/*
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性。
构造函数：在集合初始化时，就有了比较方式。

当二种都存在时，以比较器为主（好）。
比较器类：定义一个类，实现Comparator接口，覆盖compare方法。

我们发现，当我们定义一个学生类时，要有自己的hashCode，equals,compareTo方法,
当然还有toString方法。
*/

class  TreeSetDemo2
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new Mycompare());//以比较器为主
		ts.add(new Student("lisi02",22));//没有比较器时，为什么存一个没事？存二个就出错？
										//向Tree里面存对象，是要排序的，必须要有比较性，类的自然顺序。
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));//如果年龄相同，那么存不进去？Set是无序，元素不重复。

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
			//System.out.println(it.next());
		}	
	}
}

class Mycompare implements Comparator//比较器方式
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num =  s1.getName().compareTo(s2.getName());//按名字排序
		if (num==0)//名字相同，再比较年龄
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}

		return num;
	}
}

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)
	{
		if(!(obj instanceof Student))
		throw new RuntimeException("不是学生对象");
			
		Student s = (Student)obj;
		//System.out.println(this.name+".compareto."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age == s.age)
			//return 0;当年龄相同，再判断姓名。
		{
			return this.name.compareTo(s.name);//String 也实现了此接口
		}
		return -1;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}

/*
练习：按照字符串长度排序

字符串本身具备比较性。但这个排序方式不是我们想要的
*/
import java.util.*;
class  TreeSetTest
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new  StrLenComparator());
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("z");
		ts.add("hahaha");

		Iterator it = ts.iterator();
		while (it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

class StrLenComparator implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;

		/*
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()==s2.length())
			return 0;
			
		return -1;
			*///为什么不相接用int比较？那不是对象，没有compareTo方法。
		int num = new  Integer(s.length()).compareTo(new Integer(s2.length()));
		if(num ==0)
		{
			return s1.compareTo(s2);
		}
		return num;
	}
}

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

好处：
1.把运行时出现的ClassCastException问题放到编译时.
让程序员解决问题，减少安全问题。

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

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

在使用java提供的对象时，什么时候写泛型呢？
在集合框架中很常见。
只要有<>就要定义泛型。
其实<>就是用来接受类型的。

当使用集合时，将集合中要存储的数据类型作为参数
传递到<>中就可以了。

类似数组一样。
装入时候明确要装入的<类型>。
ArrayList<String> al = new ArrayList<String>();
*/
class  GenericDemo
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc0001");
		al.add("abc014");
		//al.add(4);问题所在。编译可以通过，运行出问题。
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			String s = it.next();//2避免了强制转换的麻烦。
			System.out.println(s+":"+s.length());
		}
	}
}

//------下面是泛型一个例子。字符串长度排序。
import java.util.*;

class  GenericDemo2
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new StrLenComparator());
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("z");
		ts.add("hahaha");

		Iterator<String> it = ts.iterator();
		while (it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

class StrLenComparator implements Comparator<String>
{
	public int compare(String o1,String o2)//当类上加上<String>,此处不是Object了
	{
		int num = new Integer(o1.length()).compareTo(new  Integer(o2.length()));
		
		if(num == 0)
		{
			return o1.compareTo(o2);
		}
		return num;
	}
}

/*
自定义泛型类
我们能不能在自己定义的类中使用泛型来完成程序设计呢？
什么时候使用泛型类：
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。现在定义泛型来完成扩展。

只能是引用的，基本数据类型定义不了，
基本数据类型比如说char类型，
本来就是char了，就不能再用泛型规范了。

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

class Tool
{
	private Worker w;
	public void setWorker(Worker w)
	{
		this.w = w;
	}

	public Worker getWorker()
	{
		return w;
	}
}第一次
*/
/*
class Worker
{

}

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

	public Object getObject()
	{
		return obj;
	}
}第二次


class Student
{

}
class GenericDemo3 
{
	public static void main(String[] args) 
	{
		Tool t = new Tool();
		t.setObject(new Student());
		//不小心传了学生，编译通过，运行出错。
		//这时自己明确传什么，拿什么。
		Worker w = (Worker)t.getObject();
	}
}
*/
//以上是早期做法，是可以的，得有强转。
//对象都是后过来的，泛型之前用object
//避免一个类要一个工具类操作

//我要操作对象，什么类型不确定。
//由对方来指定要操作什么类型的对象

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

class Student
{

}
class GenericDemo3
{
	public static void main(String[] args) 
	{
		/*
		Tool t = new Tool();
		t.setObject(new Student());
		//不小心传了学生，编译通过，运行出错。
		//这时自己明确传什么，拿什么。
		Worker w = (Worker)t.getObject();
		*/
		Utils<Worker> u = new Utils<Worker>();//泛型
		u.setObject(new Worker());
		Worker w = u.getObject();//可以不用强转，传入其他的就失败。

	}
}

/*泛型方法*/
class  GenericDemo4
{
	public static void main(String[] args) 
	{
		/*
		Demo<Integer> d = new Demo<Integer>();
		d.show(new Integer(4));
		d.print(9);
		定义在类上时
		*/
		Demo d = new Demo();
		d.show("haah");
		d.show(new Integer(4));
		d.print("heihei");
	}
}
class Demo
{
	public <T> void show(T t)//<T>定义在方法上,<T>只在方法中有效
	{
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q)//这里写<T>也可以
	{
		System.out.println("print:"+q);
	}
}

/*
class Demo<T>//泛型定义在类上
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
	public void print(T t)
	{
		System.out.println("print:"+t);
	}
	//以前要明确操作类型，现在可以这样写，传什么都行。

	//泛型类的局限性：当new一个对象时，已经定义类型了。
	//Demo<Integer> d = new Demo<Integer>();
	//泛型类定义的泛型在整个类中有效。如果被方法使用，
	//那么如果泛型类的对象已经明确操作的具体类型后，所
	//有要操作的类型就已经固定了。

	//为了让不同方法可以操作不同类型，而且类型还不确定。
	//那么可以将泛型定义在方法上。public <T> void print(Q q)

	泛型类和方法可以同时定义。
}
*/
/*特殊之处：
当类有静态方法时，不可以访问在类上定义的泛型。
如果静态方法操作的引用数据类型不确定，
可以将泛型定义在方法上。因为静态方法先加载。
public static <W> void method(W w)
{//注意泛型方法书写格式，<W>在void前，返回类型前。
	System.out.println("method" + w);
}
*/
/*
泛型接口：如果类不能确定自己要传什么，也可以定义泛型
*/
interface Inter<T>
{
	void show(T t);
}
/*
class InterImpl implements Inter<String> 
{
	public void show(String s)
	{
		System.out.println("show"+s);
	} 
}//第一种
*/
//后来我自己也不知道自己要传什么类型，
//子类也不知道，由调用者来指定
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 i = new InterImpl();
		//i.show("haha");
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
		//由调用者自己指定Integer
	}
}

/*import java.util.*;
<T>具体类型。<?>占位符，通配符。
<?>不明确类型，iterator时不能打印it.next().length().
ArrayList<Person> al = new ArrayList<Student>();
这是不允许的。左右二边要一致。泛型没有继承关系。

泛型的限定：
1.？extends E:可以接收E类型或者E的子类型。上限
2.？super E:可以接收E类型或者E的父类型。下限。
*/
class  GenericDemo6
{
	
}