自然排序与比较器排序的使用

怼烎@ 2023-09-30 17:08 13阅读 0赞

## 1、自然排序：java.lang.Comparable ##

Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int 。如果返回值为正数，则表示当前对象(调用该方法的对象)比 obj 对象“大”；反之“小”；如果为零的话，则表示两对象相等。

总结为一句话：实现Comparable，重写 compareTo方法

案列：以TreeMap为例，默认的升序，可以重写自然排序的方法改变原有排序

public static void testComparable(){
        
            TreeMap<Car,Object> tmp = new TreeMap<Car,Object>();
            tmp.put(new Car(4), "肆");
            tmp.put(new Car(1), "壹");
            tmp.put(new Car(5), "伍");
            tmp.put(new Car(3), "三");
            tmp.put(new Car(2), "贰");
            System.out.println(tmp);
            //结果：//{Car [price=5.0]=伍, Car [price=4.0]=肆, Car [price=3.0]=三, Car [price=2.0]=贰, Car [price=1.0]=壹}
        }

//自定义TreeMap排序方法 自然排序

class Car implements Comparable<Car>{
        
        private double price;
     
        @Override
        public int compareTo(Car o) {
        
            // TODO Auto-generated method stub
            if(this.price>o.getPrice()){
        
                return -1;//大的往前排
            }else if(this.price<o.getPrice()){
        
                return 1;//小的往后排
            }else{
        
                return 0;
            }
        }
     
        @Override
        public String toString() {
        
            return "Car [price=" + price + "]";
        }

## 2、比较器排序：java.util.Comparator ##

总结为一句话：实现Comparator 接口，重写compare方法

public static void testComparator(){
        
            //HashMap<Integer,Object> hm = new HashMap<Integer,Object>();
            TreeMap<Integer,Object> tmp = new TreeMap<Integer,Object>(new MyComparatorBigtoSmall());
            tmp.put(4, "肆");
            tmp.put(1, "壹");
            tmp.put(5, "伍");
            tmp.put(3, "三");
            tmp.put(2, "贰");
            //System.out.println(tmp);//默认排序结果：{1=壹, 2=贰, 3=三, 4=肆, 5=伍}
            System.out.println(tmp);//修改为比较器排序(升序){5=伍, 4=肆, 3=三, 2=贰, 1=壹}
        }
     
    //自定义TreeMap排序方法    比较器排序    
        class MyComparatorBigtoSmall implements Comparator<Integer>{
        
     
            @Override
            public int compare(Integer o1, Integer o2) {
        
                // TODO Auto-generated method stub
                return o2-o1;
            }
        }

## 自然排序的使用 ##

第一步：使用空参构造创建一个TreeSet集合对象。

第二步：在自定义类中实现一个Comparable接口（注意，**接口里要写泛型，而泛型的类型要与集合里的数据类型一致**）

第三步：重写里面的compareTo()抽象方法。抽象方法里要写排序规则，排序规则如下。

![img][]

/*
     * TreeSet集合来存储Student类型
     * */
    public class MyTreeSet2 {
        
        public static void main(String[] args) {
        
            TreeSet<Student> ts = new TreeSet<>();
    
            Student s1 = new Student("xuyimiao",28);
            Student s2 = new Student("chenxuyuan",27);
            Student s3 = new Student("xiaoyufeng",29);
            Student s4 = new Student("caofengze",28);
            Student s5 = new Student("caofengze",30);
    
    
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            System.out.println(ts);
        }
    }

public class Student implements  Comparable<Student>{
        
        private String name;
        private int age;
        public Student() {
        
        }
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student o) {
        
            //按照对象的年龄进行排序
            //主要判断条件
            int result = this.age - o.age;
            //次要判断条件
            result = result == 0 ? this.name.compareTo(o.getName()) : result;
            return result;
        }
    }

## 比较器排序的使用 ##

![img][img 1]

public class MyTreeSet4 {
        
        public static void main(String[] args) {
        
            TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
        
                @Override
                public int compare(Teacher o1, Teacher o2) {
        
                    //o1表示现在要存入的那个元素
                    //o2表示已经存入到集合中的元素
                    //主要条件
                    int result = o1.getAge() - o2.getAge();
                    //次要条件
                    result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                    return result;
                }
            });
            Teacher t1 = new Teacher("zhangsan",23);
            Teacher t2 = new Teacher("lisi",22);
            Teacher t3 = new Teacher("wangwu",24);
            Teacher t4 = new Teacher("zhaoliu",24);
            ts.add(t1);
            ts.add(t2);
            ts.add(t3);
            ts.add(t4);
            System.out.println(ts);
        }
    }

public class Teacher {
        
        private String name;
        private int age;
    
        @Override
        public String toString() {
        
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

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

该使用哪一种方式？

![img][img 2]

如何理解？

//按长度进行排序
    public class MyTreeSet5 {
        
        public static void main(String[] args) {
        
            TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
        
                @Override
                public int compare(String o1, String o2) {
        
                    //首先比较字符串长度是否相等，短的字符串放左边，长的字符串放右边
                    int result = o1.length() - o2.length();
                    //如果字符串长度相等，再来比里面的字母。ASCII码小的在左边，ASCII码大的在右边
                    result = result == 0 ? o1.compareTo(o2) : result;
                    return result;
                }
            });
            //Lambda表达式方法
            /*TreeSet<String> ts = new TreeSet<>((String o1, String o2) -> {
                int result = o1.length() - o2.length();
                result = result == 0 ? o1.compareTo(o2) : result;
                return result;
            });*/
            ts.add("c");
            ts.add("ab");
            ts.add("df");
            ts.add("qwer");
    
            System.out.println(ts);
        }
    }

上面这串代码中，由于Java自带的String类中已经重写了Comparable接口，我们没法再修改。所以只能使用比较排序。

[img]: https://img-blog.csdnimg.cn/img_convert/0f2c860d449816a99b40bc1ea900a68f.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/fda5a51f7fc3e7fc3ee1a85483547a0f.webp?x-oss-process=image/format,png
[img 2]: https://img-blog.csdnimg.cn/img_convert/dae370741b335150907d59a36df97209.webp?x-oss-process=image/format,png