泛型 Treeset的排序

1.
//将泛型定义在类上

public class Demo<T> {
	private T demo;
//成员方法
	public T getDemo() {
		return demo;
	}


	public void setDemo(T demo) {
		this.demo = demo;
	}
//测试
public class DemoTest {
	public static void main(String[] args) {
		Demo<String> d = new Demo<String>();//创建工具类的时候 已经将数据类型给定了
		d.setDemo("ss");//使用泛型提高了程序安全性
	}
}

2.

public class Demo {
	//将泛型定义在方法中  格式:public <T> void 方法名
	public <T> void show(T t){
		System.out.println(t);
	}


}
//测试
public class DemoTest {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.show("hello");
		d.show(true);
	}
}

3.
将泛型定义在接口上

public interface Demo <T>{
	public abstract void show(T t);


}
//子实现类
public class InterImpl<T> implements Demo<T> {


        @Override
	public  void show(T t) {
		
		System.out.println(t);
	}


}
//测试类
public class DemoTest {
	
	public static void main(String[] args) {
		Demo<String> d = new InterImpl<String>();
		d.show("hello");
	}
}

4.
List:是有序的(存储和取出一致的),集合中的元素可以重复
Set:是无序的(存储和取出不一致),集合中的元素不可以重复
  
  Set接口的子实现类:hashSet这个子实现类:它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变
       为什么set不可以重复？
HashSet的add方法,底层依赖于HashMap(属于Map接口的实现类)的put(Key,Value)
首先判断它们的hash(),底层是调用HashCode()方法,已经重写了;如果HashCode():哈西码值一样,然后在比较
他们的内容是否相同(equals():底层重写了Obejct的equals()方法)


练习：获取10个1-20之间的随机数，要求不能重复

public static void main(String[] args) {
		//创建一个Random随机数对象
		Random r = new Random();
		
		//创建一个ArrayList集合对象
		ArrayList<Integer> array = new ArrayList<Integer>() ;
		
		//定义一个统计变量
		int count = 0 ;
		
		//判断统计变量是否是10个
		while(count < 10){
			//存在10个随机数,获取1-20之间的随机数,使用随机数的这个对象
			int number = r.nextInt(20) +1 ;
			
			//判断集合中是否存在该数据,不存在,添加数据,统计变量++
			if(!array.contains(number)){//利用list集合的不能重复性
				array.add(number) ;
				count ++;
			}
		}
		
		//遍历集合
		for(Integer i : array){
			System.out.println(i);
		}
	}
}

5.
TreeSet集合中有两种排序:(Set集合中的一个重点)
  保证元素的唯一性并且排序
   自然排序
   比较器排序

   TreeMap<K,V>----><String,Integer>/<Ineteger,String>基于红黑树

6.

用TreeSet集合用来存储自定义的对象,自定义的对象一定要实现Compareable接口(自然排序),
  比较器排序(Copartor):另外一种方式(单独讲)
  用TreeSet集合存储8个学生,遍历每个学生的信息
  
  当前并没有给学生对象进行排序,要排序指定一个主要条件
  要按照年龄进行从小到大排序
  如果对象的成员变量值一样,就认为是同一个变量
1.1 使用自然排序（默认的）
//要自定义的类中实现Compareable接口:进行自然排序

public class Student implements Comparable<Student>{
	private String name;
	private int age ;
	
	
	public Student() {
		super();
	}




	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}




	public String getName() {
		return name;
	}




	public void setName(String name) {
		this.name = name;
	}




	public int getAge() {
		return age;
	}




	public void setAge(int age) {
		this.age = age;
	}




	@Override
	public int compareTo(Student s) {
//		return 0;
		
		//返回值是要按照刚才的主要条件进行实现
		//要按照年龄进行从小到大排序:主要条件(需求中明确给出主要条件),你自己要分析附件的次要条件!
		//用当前对象的年龄和传入的实际年龄进行比较
		int num = this.age - s.age;//从小到达大排序
		//num==0,说明年龄一样,但是有时候姓名不一样
		//使用三元运算符进行实现
		int num2 = num==0 ? this.name.compareTo(s.name) : num ;
		return num2 ;
		
	}
//测试
import java.util.TreeSet;


public class Test {
	public static void main(String[] args) {
		TreeSet<Student> ts = new TreeSet<Student>();
		
		Student s1 = new Student(11, "gao");
		Student s2 = new Student(12,"li");
		Student s3 = new Student(14,"zhao");
		Student s4 = new Student(33,"li");
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		//自定义的对象一定要实现Compareable接口（自然排序） 所以需要在自定义类里面实现接口
		for(Student s : ts){//增强for遍历
			System.out.println(s.getAge()+s.getName());
		}
	}


}

1.2 
使用匿名内部类

//开发中使用
		//开发效率高
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {//匿名内部类


			@Override
			public int compare(Student s1, Student s2) {
				//按照长度进行比较
				int num = s2.getName().length() - s1.getName().length() ;
				//姓名长度一样,不代表姓名的内容一样
				int num2 = num == 0? s1.getName().compareTo(s2.getName()): num ;
				//姓名内容一样,有可能年龄不一样
				int num3 = num2 ==0 ? s1.getAge()-s2.getAge() : num2 ;
				
				return num3;
			}
		});
		//创建学生对象
		//创建学生对象
		Student s1 = new Student("gaoyuanyuan", 27) ;
		Student s2 = new Student("zhangguorong", 29) ;
		Student s3 = new Student("wanglihong", 27) ;
		Student s4 = new Student("liushishi", 27) ;
		Student s5 = new Student("feqingyan", 38) ;
		Student s6 = new Student("linqingxia", 38) ;
		Student s7 = new Student("gaoyuanyuan", 26) ;
		Student s8 = new Student("gaoyuanyuan", 27) ;
		
		//给集合中添加元素
		ts.add(s1) ;
		ts.add(s2) ;
		ts.add(s3) ;
		ts.add(s4) ;
		ts.add(s5) ;
		ts.add(s6) ;
		ts.add(s7) ;
		ts.add(s8) ;
		
		
		//增强for遍历
		for(Student s: ts){
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}