java比较器Comparable与Comparator

痛定思痛。 2021-12-01 12:00 310阅读 0赞

Java中的对象，正常情况下，只能进行比较：==或!=，不能使用>或<  
但是在开发场景中，需要对多个对象进行排序，即比较对象的大小。使用Comparator接口或Comparable接口就能实现。

##### Comparable 自然排序 #####

1.String、包装类中实现了Comparable接口，重写了compareTo()方法

String arr[] =new String[]{ "ab","abc","abd","abe","ar","abcd"};
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));

2.自定义类排序:实现Comparable接口，重写compareTo()方法  
重写compareTo()的规则：  
如果当前对象this大于形参对象obj，则返回正整数，小于返回负整数，等于返回0

import java.util.Arrays;
    
    class Person implements  Comparable{ 
        private String name;
        private int age;
    
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Object o) { 
          //指明比较方式:按照年龄从低到高排序
            if(o instanceof Person){ 
                Person person=(Person)o;
               return this.age>person.age?1:this.age==person.age?0:-1; //方式一
                // return Integer.compare(this.age,person.age); // 方式二
            }
            throw new RuntimeException("传入的数据类型不一致");
        }
    }
    
    public class Demo { 
        public static void main(String[] args) { 
        Person[] person=new Person[4];
        person[0]=new Person("laowang",34);
        person[1]=new Person("wangfei",22);
        person[2]=new Person("liudehua",15);
        person[3]=new Person("xiaomin",10);
            Arrays.sort(person);
            System.out.println(Arrays.toString(person));
        }
    }

##### Comparator 定制排序 #####

1.不想使用String内部定义的排序方式，又不能修改String类的代码，则要通过Comparator实现定制排序

String arr[] =new String[]{ "ab","abc","abd","abe","ar","abcd"};
            Arrays.sort(arr, new Comparator() { 
                @Override
                public int compare(Object o1, Object o2) { 
                    if(o1 instanceof String && o2 instanceof  String) { 
                        String s1 = (String) o1;
                        String s2 = (String) o2;
                        //按照从大到小排序
                        return -s1.compareTo(s2);
                    }
                    throw new RuntimeException("数据类型不一致");
                }
            });
            System.out.println(Arrays.toString(arr));

重写compare(Object o1,Object o2)的规则：  
如果o1>o2，返回正整数，o1与o2相等，返回0，o1<o2，返回负整数

2.自定义类排序

import java.util.Arrays;
    import java.util.Comparator;
    
    class Person implements Comparator { 
        private String name;
        private int age;
        public Person(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 "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compare(Object o1, Object o2) { 
            return 0;
        }
    }
    
    public class Demo { 
        public static void main(String[] args) { 
        Person[] person=new Person[4];
        person[0]=new Person("laowang",34);
        person[1]=new Person("wangfei",22);
        person[2]=new Person("liudehua",15);
        person[3]=new Person("xiaomin",1);
            Arrays.sort(person, new Comparator<Person>() { 
                @Override
                public int compare(Person o1, Person o2) { 
                    //按照名称从高到低排序
                    if(o1.getName().equals(o2.getName())){ 
                        return 0;
                    }
                    return o2.getName().compareTo(o1.getName());
                }
            });
            System.out.println(Arrays.toString(person));
        }
       }

总结：Comparable与Comparator的小区别  
通过类实现Comparable接口的方式，一旦指定排序方式，能够保证Comparable接口实现类的对象在任何位置都可以比较大小，反复使用  
Comparator属于临时比较，一次使用