java提高（7）---TreeSet--排序

2年前 (2022) 程序员胖胖胖虎阿

283 0 0

TreeSet(一)

一、TreeSet定义：

与HashSet是基于HashMap实现一样，TreeSet同样是基于TreeMap实现的。

1）TreeSet类概述

使用元素的自然顺序对元素进行排序

或者根据创建 set 时提供的 Comparator 进行排序

具体取决于使用的构造方法。

2）TreeSet是如何保证元素的排序和唯一性的

底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

（1） 自然排序

import java.util.TreeSet;  
  
    /** TreeSet集合的特点：排序和唯一 
     * 
     * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。 
     */  
    public class TreeTest1 {  
        public static void main(String[] args) {  
            // 创建集合对象  
            // 自然顺序进行排序  
            TreeSet<Integer> treeSet = new TreeSet<Integer>();  
            // 创建元素并添加  
            treeSet.add(8);  
            treeSet.add(4);  
            treeSet.add(5);  
            treeSet.add(6);  
            treeSet.add(6);                      
            // 遍历  
            for(Integer i : treeSet){  
                System.out.print(i);  
            }  
        }  
    }  
    /*后台输出：4568     重复会被覆盖*/

（2）如果存入对象怎么排序，记住如果是对象一定要重写Comparator方法

People对象

 1 public class People implements Comparable {  
 2   
 3     private String name;  
 4     private String sex;  
 5     private int age;  
 6       
 7     /*提供set和get方法，全参和无参构造方法*/  
 8   
 9     @Override  
10     public int compareTo(Object o) {  
11   
12         People people = (People) o;  
13         if (people.age > this.age) {  
14   
15             return 1;  
16         }  
17         if (this.age == people.age) {  
18   
19             return this.name.compareTo(people.name);  
20         }  
21         if ( people.age<this.age ) {  
22   
23             return -1;  
24         }  
25   
26         return 0;  
27     }  
28 }

测试类

 1 public class SortTest {  
 2   
 3     public static void main(String[] args) {  
 4   
 5         People people1 = new People("小a", "男", 18);  
 6         People people2 = new People("小a", "女", 16);  
 7         People people3 = new People("小c", "女", 18);  
 8         People people4 = new People("小b", "女", 22);  
 9         People people5 = new People("小d", "男", 19);  
10   
11         Set<People> treeSet = new TreeSet<People>();  
12   
13         treeSet.add(people1);  
14         treeSet.add(people2);  
15         treeSet.add(people3);  
16         treeSet.add(people4);  
17         treeSet.add(people5);  
18   
19         Iterator iterator = treeSet.iterator();  
20   
21         while (iterator.hasNext()) {  
22   
23             People people = (People) iterator.next();  
24   
25             System.out.println("姓名：" + people.getName() + "\t年龄:" + people.getAge());  
26         }  
27   
28     }  
29 }

运行结束：后台报错：

Exception in thread "main" java.lang.ClassCastException: com.treeset.sort.People cannot be cast to java.lang.Comparable

java提高（7）---TreeSet--排序

（3）举例一个学生有语文、数学、英语三门课，按总分从高到底排序

Student对象

 1 public class Student {  
 2   
 3     private String name;  
 4     private int   chinese;  
 5     private int   math;  
 6     private int   english;  
 7        
 8     /*提供set和get方法，同时提供无参数，有参数构造方法*/  
 9       
10       
11     //同时单独要加上getSum方法  
12     public int getSum(){  
13         return this.chinese + this.english + this.math;  
14     }     
15 }

测试类

 1 import java.util.Iterator;  
 2 import java.util.TreeSet;  
 3   
 4 public class TreeTest2 {  
 5   
 6     public static void main(String[] args) {  
 7       
 8         Student student1=new Student("小明", 80, 90, 70);  
 9         Student student2=new Student("小王", 60, 80, 90);  
10         Student student3=new Student("小钱", 100, 100, 80);  
11         Student student4=new Student("小徐", 20, 10, 90);  
12         Student student5=new Student("小李", 80, 80, 80);  
13         Student student6=new Student("小李", 70, 80, 90);  
14   
15           
16         TreeSet<Student>  treeSet=new TreeSet(new MyComparable());  
17           
18         treeSet.add(student1);  
19         treeSet.add(student2);  
20         treeSet.add(student3);  
21         treeSet.add(student4);  
22         treeSet.add(student5);  
23         treeSet.add(student6);  
24           
25         Iterator<Student>  iterator=treeSet.iterator();  
26           
27         while(iterator.hasNext()){  
28               
29             Student student=iterator.next();  
30               
31             System.out.println(student.toString());  
32         }     
33     }     
34 }

MyComparable类

 1 import java.util.Comparator;  
 2   
 3 public class MyComparable implements Comparator<Student>{  
 4       
 5     @Override  
 6     public int compare(Student s1, Student s2) {  
 7      
 8          // 总分从高到低（注意这里是s2减s1）  
 9         int num = s2.getSum() - s1.getSum();  
10           
11         if(num>0){  
12             return 1;  
13         }  
14         if(num<0){  
15             return -1;  
16         }  
17           
18         if(num==0){  
19             //这步非常关键，没有这个如果总成绩相同名字不同 ，那set集合就默认是相同元素，就会被覆盖掉  
20             return s2.getName().compareTo(s1.getName());  
21         }         
22             return 0;     
23     }     
24 }

java提高（7）---TreeSet--排序

 1   /** 
 2  * 是不是很奇怪为什么只有五条数据，而不是六条，那是因为有一条数据被覆盖了。 
 3  * 你的Comparator实现类，是先比较成绩，成绩相同，在比较名字，那如果总成绩 
 4  * 相同，姓名也相同，那不是默认是重复数据，TreeSet当然给你覆盖掉了。所以这 
 5  * 里有个小李被覆盖掉了。那如何写才规范，下面这样就不会出现覆盖。 
 6         */  
 7 @Override  
 8    // 创建一个TreeSet集合  
 9    public int compare(Student s1, Student s2) {  
10        // 总分从高到低（注意这里是s2减s1）  
11        int num = s2.getSum() - s1.getSum();  
12        // 总分相同的不一定语文相同  
13        int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;  
14        // 总分相同的不一定数学相同  
15        int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;  
16        // 总分相同的不一定英语相同  
17        int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;  
18        // 姓名还不一定相同  
19        int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4;  
20        return num5;  
21    }

最后在思考，set集合在开发中到底有啥用，好像我们开发当中要用集合一般会用ArrayList，好像很少用到TreeSet集合

这个时候你就要想TreeSet集合的特点了：排序和唯一

举个小例子：

（4）编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

 1 import java.util.Iterator;  
 2 import java.util.TreeSet;  
 3 import java.util.Random;  
 4 /* 
 5  * 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。 
 6  * 
 7  * 分析： 
 8  *         A:创建随机数对象 
 9  *         B:创建一个TreeSet集合 
10  *         C:判断集合的长度是不是小于10 
11  *             是：就创建一个随机数添加 
12  *             否：不搭理它 
13  *         D:遍历TreeSet集合 
14  */  
15 public class HashSetDemo {  
16     public static void main(String[] args) {  
17         // 创建随机数对象  
18         Random r = new Random();  
19         // 创建一个Set集合  
20         TreeSet<Integer> treeSet = new TreeSet<Integer>();  
21         // 判断集合的长度是不是小于10  
22         while (treeSet.size() < 10) {  
23             int x = r.nextInt(20) + 1;  
24             treeSet.add(x);  
25         }          
26         // 遍历Set集合  
27         for (int x : treeSet) {  
28             System.out.println(x);  
29         }  
30     }  
31 }