Comparable接口和Comparator接口实战

拼搏现实的明天。 2021-07-24 14:18 540阅读 0赞

**一 Comparable介绍**

Comparable：定义默认比较规则。

Comparable——可比较的。

*  实现该接口表示：这个类实例是可以比较的，可进行自然排序。
 *  定义了默认的比较规则。
 *  其实现类需要实现compareTo()方法
 *  compareTo()方法返回正数表示大，负数表示小，0表示相等。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

**二 Comparator介绍**

Comparator：定义临时比较规则。

Comparator接口——比较工具接口

用于定义临时比较规则，而不是默认比较规则。

其实现类需要实现compare()方法。

Comparator和Comparable都是Java集合框架的成员。

**三 实战**

1 Student

package CollectionPart;
    
    
    import java.util.HashSet;
    import java.util.Set;
    
    
    /**
    * 学生类
    *
    * @author Administrator
    */
    public class Student implements Comparable<Student> {
    
    
        public String id;
    
    
        public String name;
    
    
        public Set<Course> courses;
    
    
        public Student( String id, String name ) {
            this.id = id;
            this.name = name;
            this.courses = new HashSet<Course>();
        }
    
    
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
    
    
        @Override
        public boolean equals( Object obj ) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (!(obj instanceof Student))
                return false;
            Student other = (Student) obj;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    
    
        //@Override
        public int compareTo( Student o ) {
            // TODO Auto-generated method stub
            return this.id.compareTo(o.id);
        }
    }

2 StudentComparator

package CollectionPart;
    
    
    import java.util.Comparator;
    
    
    public class StudentComparator implements Comparator<Student> {
    
    
       @Override
       public int compare(Student o1, Student o2) {
          // TODO Auto-generated method stub
          return o1.name.compareTo(o2.name);
       }
    
    
    }

3 测试类

package CollectionPart;
    
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    
    /**
    * 将要完成
    * 1 通过Collections.sort()方法，对Integer泛型List进行排序
    * 2 对String泛型的List进行排序
    * 3 对其他类型泛型的List进行排序，以Student为例。
    */
    public class CollectionsTest {
    
    
        /**
         * 1.通过Collections.sort()方法，对Integer泛型List进行排序
         * 创建Integer泛型List，插入十个100以内的不重复随机整数，
         * 调用Collections.sort()方法对其进行排序
         */
        public void testSort1() {
            List<Integer> integerList = new ArrayList<Integer>();
            // 插入十个100以内的不重复随机整数
            Random random = new Random();
            Integer k;
            for (int i = 0; i < 10; i++) {
                do {
                    k = random.nextInt(100);
                } while (integerList.contains(k));
                integerList.add(k);
                System.out.println("成功添加整数：" + k);
            }
            System.out.println("-------------排序前--------------");
            for (Integer integer : integerList) {
                System.out.println("元素：" + integer);
            }
            Collections.sort(integerList);
            System.out.println("----------------排序后-------------------");
            for (Integer integer : integerList) {
                System.out.println("元素：" + integer);
            }
        }
    
    
        /**
         * 2 对String泛型的List进行排序
         * 创建String泛型的List，添加三个乱序的String元素
         * 调用sort方法，再次输出排序后的顺序
         */
        public void testSort2() {
            List<String> stringList = new ArrayList<String>();
            stringList.add("microsoft");
            stringList.add("google");
            stringList.add("lenovo");
            System.out.println("------------排序前-------------");
            for (String string : stringList) {
                System.out.println("元素：" + string);
            }
            Collections.sort(stringList);
            System.out.println("--------------排序后---------------");
            for (String string : stringList) {
                System.out.println("元素：" + string);
            }
        }
    
    
        /**
         * 3 对其他类型泛型的List进行排序，以Student为例。
         */
        public void testSort3() {
            List<Student> studentList = new ArrayList<Student>();
            Random random = new Random();
            studentList.add(new Student(random.nextInt(1000) + "", "Mike"));
            studentList.add(new Student(random.nextInt(1000) + "", "Angela"));
            studentList.add(new Student(random.nextInt(1000) + "", "Lucy"));
            studentList.add(new Student(10000 + "", "Beyonce"));  // 按字符串排序规则排序
            System.out.println("--------------排序前---------------");
            for (Student student : studentList) {
                System.out.println("学生：" + student.id + ":" + student.name);
            }
            Collections.sort(studentList);
            System.out.println("----------------排序后------------------");
            for (Student student : studentList) {
                System.out.println("学生：" + student.id + ":" + student.name);
            }
            Collections.sort(studentList, new StudentComparator());
            System.out.println("----------------按照姓名排序后-----------------");
            for (Student student : studentList) {
                System.out.println("学生：" + student.id + ":" + student.name);
            }
        }
    
    
        /**
         * @param args
         */
        public static void main( String[] args ) {
            CollectionsTest ct = new CollectionsTest();
            ct.testSort1();
            ct.testSort2();
            ct.testSort3();
        }
    
    
    }

**四 结果**

成功添加整数：48
    成功添加整数：92
    成功添加整数：28
    成功添加整数：53
    成功添加整数：74
    成功添加整数：60
    成功添加整数：41
    成功添加整数：91
    成功添加整数：66
    成功添加整数：65
    -------------排序前--------------
    元素：48
    元素：92
    元素：28
    元素：53
    元素：74
    元素：60
    元素：41
    元素：91
    元素：66
    元素：65
    ----------------排序后-------------------
    元素：28
    元素：41
    元素：48
    元素：53
    元素：60
    元素：65
    元素：66
    元素：74
    元素：91
    元素：92
    ------------排序前-------------
    元素：microsoft
    元素：google
    元素：lenovo
    --------------排序后---------------
    元素：google
    元素：lenovo
    元素：microsoft
    --------------排序前---------------
    学生：413:Mike
    学生：554:Angela
    学生：923:Lucy
    学生：10000:Beyonce
    ----------------排序后------------------
    学生：10000:Beyonce
    学生：413:Mike
    学生：554:Angela
    学生：923:Lucy
    ----------------按照姓名排序后-----------------
    学生：554:Angela
    学生：10000:Beyonce
    学生：923:Lucy
    学生：413:Mike
    
    
    Process finished with exit code 0

**五 多字段比较排序**

1 需求

对工人进行排序：首先按工资有由低到高排序（升序），当工资相同则按年龄由高到底排序（降序）。

2 实现

package Comparable;
    
    import java.util.Arrays;
    import java.util.Collections;
    
    /**
     * Copyright (C), 2020-2020, XXX有限公司
     * FileName: Worker
     * Author:   cakin
     * Date:     2020/3/19 10:26
     * Description: 工人类
     */
    public class Worker implements Comparable<Worker> {
        private String name;
        private int age;
        private int salary;
    
        public Worker( String name, int age, int salary ) {
            super();
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
        public int getSalary() {
            return salary;
        }
    
        /**
         * 实现Comparable接口的compareTo方法，在此方法中定义自己的比较规则 首先按工资有由低到高排序，当工资相同则按年龄由高到底排序
         */
        @Override
        public int compareTo( Worker other ) {
            // TODO Auto-generated method stub
            if (this.salary < other.getSalary()) { // 工资小于其他人时返回负值
                return -1;
            } else if (this.salary > other.getSalary()) { // 工资大于其他人时返回正值
                return 1;
            } else { // 工资等于其他人时按照年龄再排序
                if (this.age < other.getAge()) {
                    return 1;// 表示由高到低排序
                } else if (this.age >= other.getAge()) {
                    return -1;
                }
            }
            return 0;
        }
    
        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return this.name + "\t" + this.age + "\t" + this.salary;
        }
    
    
        public static void main( String[] args ) {
            // TODO Auto-generated method stub
    
            Worker[] workers = new Worker[5];
            workers[0] = new Worker("test1", 25, 2000);
            workers[1] = new Worker("test2", 24, 2100);
            workers[2] = new Worker("test3", 26, 2100);
            workers[3] = new Worker("test4", 27, 2200);
            workers[4] = new Worker("test5", 28, 1900);
    
            //调用Arrays.sort()方法进行排序
            Collections.sort(Arrays.asList(workers));
            for (Worker w : workers) {
                System.out.println(w);
            }
        }
    }

3 测试

test5	28	1900
    test1	25	2000
    test3	26	2100
    test2	24	2100
    test4	27	2200

实现了先按照工资升序，工资相同的，再按照年龄降序。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20210724/1b8a2e011d774f43819d43d6d444afcc.png