【Java基础】TreeSet集合、自然排序、比较器排序、成绩排序及不重复随机数案例

Myth丶恋晨 2024-04-07 15:11 40阅读 0赞

**目录**

一、TreeSet集合概述和特点

二、自然排序Comparable的使用

三、比较器排序Comparator的使用

四、成绩排序案例

五、不重复的随机数案例

--------------------

## 一、TreeSet集合概述和特点 ##

TreeSet集合概述：

> 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
> 
> ■ TreeSet()：根据其元素的自然排序进行排序
> 
> ■ TreeSet(Comparator comparator)：根据指定的比较器进行排序
> 
> 没有带索引的方法，所以不能使用普通for循环遍历
> 
> 由于是Set集合，所以不包括重复元素的集合

TreeSet集合基本使用

public class TreeSetDemo01 { 
        public static void main(String[] args) { 
            //创建集合对象 
            TreeSet<Integer> ts = new TreeSet<Integer>(); 
    
            //添加元素 
            ts.add(10); 
            ts.add(40); 
            ts.add(30); 
            ts.add(50); 
            ts.add(20); 
    
            ts.add(30); 
    
            //遍历集合 
            for(Integer i : ts) { 
                System.out.println(i); 
            } 
        } 
    }

## 二、自然排序Comparable的使用 ##

需求：

> 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
> 
> 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

实现步骤：

> ● 用TreeSet存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
> 
> ● 自然排序，就是让元素多属的类实现Comparable接口，重写compareTo(T o)方法
> 
> ● 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现：

学生类

public class Student implements Comparable<Student> {
        private String name;
        private int age;
    
        public Student() {
        }
    
        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;
        // return 1;
        // return -1;
            //按照年龄从小到大排序
            int num = this.age - s.age;
            // int num = s.age - this.age;
            //年龄相同时，按照姓名的字母顺序排序
            int num2 = num == 0 ? this.name.compareTo(s.name) : num;
            return num2;
        }
    }

测试类：

public class TreeSetDemo02 {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<Student> ts = new TreeSet<Student>();
    
            //创建学生对象
            Student s1 = new Student("xishi", 29);
            Student s2 = new Student("wangzhaojun", 28);
            Student s3 = new Student("diaochan", 30);
            Student s4 = new Student("yangyuhuan", 33);
            Student s5 = new Student("linqingxia", 33);
            Student s6 = new Student("linqingxia", 33);
    
            //把学生添加到集合
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
    
            //遍历集合
            for (Student s : ts) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

## 三、比较器排序Comparator的使用 ##

需求：

> 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
> 
> 要求：按照年龄从小到大的排序，年龄相同时，按照姓名的字母顺序排序

实现步骤：

> ● 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
> 
> ● 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
> 
> ● 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现：

学生类

public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        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;
        }
    }

测试类

public class TreeSetDemo {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
                @Override
                public int compare(Student s1, Student s2) {
                    //this.age - s.age
                    //s1,s2
                    int num = s1.getAge() - s2.getAge();
                    int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                    return num2;
                }
            });
    
            //创建学生对象
            Student s1 = new Student("xishi", 29);
            Student s2 = new Student("wangzhaojun", 28);
            Student s3 = new Student("diaochan", 30);
            Student s4 = new Student("yangyuhuan", 33);
    
            Student s5 = new Student("linqingxia", 33);
            Student s6 = new Student("linqingxia", 33);
    
            //把学生添加到集合
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
    
            //遍历集合
            for (Student s : ts) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

## 四、成绩排序案例 ##

需求：

> 用TreeSet集合存储多个学生信息（姓名，语文成绩，数学成绩），并遍历该集合
> 
> 要求：按照总分从高到低出现

代码实现：

学生类

public class Student { 
        private String name; 
        private int chinese; 
        private int math; 
    
        public Student() { 
        }
    
        public Student(String name, int chinese, int math) { 
            this.name = name; 
            this.chinese = chinese; 
            this.math = math; 
        }
    
        public String getName() { 
            return name; 
        }
    
        public void setName(String name) { 
            this.name = name; 
        }
    
        public int getChinese() { 
            return chinese; 
        }
    
        public void setChinese(int chinese) { 
            this.chinese = chinese; 
        }
    
        public int getMath() { 
            return math; 
        }
    
        public void setMath(int math) { 
            this.math = math; 
        }
    
        public int getSum() { 
            return this.chinese + this.math; 
        } 
    }

测试类：

public class TreeSetDemo {
        public static void main(String[] args) {
            //创建TreeSet集合对象，通过比较器排序进行排序 
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
    
                @Override
                public int compare(Student s1, Student s2) {
    // int num = (s2.getChinese()+s2.getMath())- (s1.getChinese() + s1.getMath());
                    //主要条件 
                    int num = s2.getSum() - s1.getSum();
                    //次要条件 
                    int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                    int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
                    return num3;
                }
            });
    
            //创建学生对象 
            Student s1 = new Student("林青霞", 98, 100);
            Student s2 = new Student("张曼玉", 95, 95);
            Student s3 = new Student("王祖贤", 100, 93);
            Student s4 = new Student("柳岩", 100, 97);
            Student s5 = new Student("风清扬", 98, 98);
            Student s6 = new Student("左冷禅", 97, 99);
            Student s7 = new Student("赵云", 97, 99);
    
            //把学生对象添加到集合 
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
            ts.add(s7);
    
            //遍历集合 
            for (Student s : ts) {
                System.out.println(s.getName() + "," + s.getChinese() + "," +
                        s.getMath() + "," + s.getSum());
            }
        }
    }

## 五、不重复的随机数案例 ##

需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

代码实现：

public class SetDemo { 
        public static void main(String[] args) { 
            //创建Set集合对象 
    // Set<Integer> set = new HashSet<Integer>(); 
            Set<Integer> set = new TreeSet<Integer>(); 
    
            //创建随机数对象 
            Random r = new Random(); 
    
            //判断集合的长度是不是小于10 
            while (set.size()<10) { 
                //产生一个随机数，添加到集合 
                int number = r.nextInt(20) + 1; 
                set.add(number); 
            }
    
            //遍历集合 
            for(Integer i : set) { 
                System.out.println(i); 
            } 
        } 
    }