Java比较器-Comparable

快来打我* 2023-01-20 10:59 153阅读 0赞

在Java中经常会涉及到对象数组的排序问题，就会涉及到**对象之间的比较**问题。

Java实现**对象排序**的方式有**两种**：

*  **自然排序**：Comparable
 *  **定制排序**：Comparator

## 1、Comparable 自然排序 ##

**Comparable接口**强行**对实现它的每个类的对象**进行**整体排序**，实现Comparable的类必须**实现compareTo(Object obj)方法****，**返回**int类型**，如果**当前对象this大于形参obj对象**，返回正整数，如果**当前对象this小于形参obj对象**，返回负整数，**等于**就返回0.

public interface Comparable<T> {
        public int compareTo(T o);
    }

在实现Comparable接口的对象列表（数组）可以通过**Collections.sort** 或者（**Arrays.sort**）进行**自动排序**。在String、包装类等都实现了Comparable接口。

代码演示：根据**对象的年龄来排序**

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    /**
     * Comparable 接口的使用比较对象的具体属性
     */
    public class ComparableTest {
        public static void main(String[] args) {
            Student s1 = new Student("李四", 12);
            Student s2 = new Student("张三", 10);
            Student s3 = new Student("李富贵", 40);
            Student s4 = new Student("李文", 30);
            List<Student> list =  new ArrayList<>();
            list.add(s1);
            list.add(s2);
            list.add(s3);
            list.add(s4);
            Collections.sort(list);
            for (Student student : list) {
                System.out.println(student);
            }
        }
    
    }
    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 String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student o) {
            return getAge()-o.getAge();
        }
    }

**运行截图**： **默认是从小到大排序**

![20210512204154112.png][]

对于String、包装类的自然排序：

import java.util.Arrays;
    
    public class Test {
        public static void main(String[] args) {
            String []str = new String[]{"AA","D","TT","FF"};
            Arrays.sort(str);
            for (String s : str) {
                System.out.print(s+"  ");
            }
            System.out.println();
            Integer []integers = new Integer[]{1,2,3,10,1,23};
            Arrays.sort(integers);
            for (Integer integer : integers) {
                System.out.print(integer+"  ");
            }
        }
    }

运行截图：String、Integer包装类都**实现了Comparable接口**。

![20210512204752649.png][]

## 2、 Comparator  定制排序 ##

当**元素的类型没有实现Comparable接口**，不好修改代码时或者**Comparable接口比较的规则不适合当前的操作**，强行对两个对象进行排序。可以考虑**Comparator接口**。

**重写**compare（Object o1，Object o2）方法，如果返回**正整数**，表示o1大于o2，如果返回负整数，表示o1**小于**o2；返回0则表示o1等于o2.

public interface Comparator<T> {
        //还有其他静态方法
        int compare(T o1, T o2);
    }

在实现Comparator接口的对象列表（数组）可以通过**Collections.sort** 或者（**Arrays.sort**）进行**自动排序**。在String、包装类等都实现了**Comparator**接口。

代码演示：

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class TestComareT {
        public static void main(String[] args) {
            Teacher t1 = new Teacher(10000, "lisi", "男");
            Teacher t2 = new Teacher(12000, "zs", "女");
            Teacher t3 = new Teacher(10300, "ww", "男");
    
            List<Teacher> teachers = new ArrayList<>();
            teachers.add(t1);
            teachers.add(t2);
            teachers.add(t3);
    
            Collections.sort(teachers, new Comparator<Teacher>() {
                @Override
                public int compare(Teacher o1, Teacher o2) {
                    if (o1.getWages() - o2.getWages() > 0) {
                        return -1;
                    }
                    if (o1.getWages() - o2.getWages() < 0) {
                        return 1;
                    }
                    return 0;
                }
            });
            for (Teacher teacher : teachers) {
                System.out.println(teacher);
            }
    
        }
    }
    class Teacher {
        private double wages;
        private String name;
        private String sex;
    
        public Teacher() {
        }
    
        public Teacher(double wages, String name, String sex) {
            this.wages = wages;
            this.name = name;
            this.sex = sex;
        }
    
        public double getWages() {
            return wages;
        }
    
        public void setWages(double wages) {
            this.wages = wages;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "wages=" + wages +
                    ", name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }

运行截图：按照工资从小到大排序

![20210512212411106.png][]

对于String、包装类的排序：

import java.util.Arrays;
    import java.util.Comparator;
    
    public class TestComparator {
        public static void main(String[] args) {
            String []str = new String[]{"AA","D","TT","FF"};
            Arrays.sort(str, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return - o1.compareTo(o2);//从大到小排序
                }
            });
            for (String s : str) {
                System.out.print(s+" ");
            }
            System.out.println();
            Integer []integers = new Integer[]{1,2,3,10,1,23};
            Arrays.sort(integers, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return  - o1.compareTo(o2);//从大到小排序
                }
            });
            for (Integer integer : integers) {
                System.out.print(integer+" ");
            }
        }
    }

运行截图：

![20210512212512767.png][]

[20210512204154112.png]: /images/20221021/01da8edb68484d01b8a196eff331f8ce.png
[20210512204752649.png]: /images/20221021/dd52b0fd99b443e398eca027229c239e.png
[20210512212411106.png]: /images/20221021/80cd1c58748843cf9a32159c75565b72.png
[20210512212512767.png]: /images/20221021/6ad75ed10ed44ff4badc773f793579a8.png