Comparable接口和Comparator接口的使用和区别

川长思鸟来 2023-07-12 14:29 1阅读 0赞

## Comparable ##

Comparable接口在JDK8中的源码：

package java.lang;
    import java.util.*;
    
    package java.lang;
    public interface Comparable<T> { 
        public int compareTo(T o);
    }

用法：

public class User implements Comparable<User>{ 
        private Integer id;
        private Integer age;
    
        public User() { 
        }
    
        public User(Integer id, Integer age) { 
            this.id = id;
            this.age = age;
        }
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", age=" + age +
                    '}';
        }
    
        public int compareTo(User o) { 
            if(this.age > o.getAge()) { 
                return 1;
            }else if(this.age < o.getAge()) { 
                return -1;
            }else{ 
                return 0;
            }
        }
    }

public class Test { 
        public static void main(String[] args) { 
            User user1 = new User(1, 14);
            User user2 = new User(2, 12);
            User user3 = new User(3, 10);
            User[] users = { user1, user2, user3};
            Arrays.sort(users);
            Arrays.stream(users).forEach(System.out::println);
        }
    }

**int compareTo(T o)**

比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

参数： o - 要比较的对象。

返回：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

抛出：ClassCastException - 如果指定对象的类型不允许它与此对象进行比较

## Comparator ##

Comparator接口在JDK8中的源码：

package java.util;
    
    import java.io.Serializable;
    import java.util.function.Function;
    import java.util.function.ToIntFunction;
    import java.util.function.ToLongFunction;
    import java.util.function.ToDoubleFunction;
    import java.util.Comparators;
    
    public interface Comparator<T> { 
    	int compare(T o1, T o2);
    	//还有很多其他方法...
    }

使用：

public class Child { 
        private Integer id;
        private Integer age;
    
        public Child() { 
        }
    
        public Child(Integer id, Integer age) { 
            this.id = id;
            this.age = age;
        }
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "Child{" +
                    "id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

public class Test { 
        public static void main(String[] args) { 
            Child child1 = new Child(1, 14);
            Child child2 = new Child(2, 12);
            Child child3 = new Child(3, 10);
    
            List<Child> list = new ArrayList<>();
            list.add(child1);
            list.add(child2);
            list.add(child3);
    
            Collections.sort(list, new Comparator<Child>() { 
                @Override
                public int compare(Child o1, Child o2) { 
                    return  o1.getAge() > o2.getAge() ? 1 : (o1.getAge() == o2.getAge() ? 0 : -1);
                }
            });
    
            // 或者使用JDK8中的Lambda表达式
            //Collections.sort(list, (o1, o2) -> (o1.getAge()-o2.getAge()));
    
            list.stream().forEach(System.out::println);
        }
    }

或者也可以通过实现的方式使用Comparator接口：

import java.util.Comparator;
    
    public class Child implements Comparator<Child> { 
        private Integer id;
        private Integer age;
    
        public Child() { 
        }
    
        public Child(Integer id, Integer age) { 
            this.id = id;
            this.age = age;
        }
    
        @Override
        public int compare(Child o1, Child o2) { 
            return o1.getAge() > o2.getAge() ? 1 : (o1.getAge() == o2.getAge() ? 0 : -1);
        }
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "Child{" +
                    "id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

#### Comparator接口其他默认方法的用法 ####

**reversed方法**

default Comparator<T> reversed() { 
            return Collections.reverseOrder(this);
        }

这个方法是用来生成一个逆序器,比如我们开始需要得到一个正序的排序序列,然后又想得到一个反转的排序序列,就可以使用该方法。比如：

public class Test { 
        public static void main(String[] args) { 
            Child child1 = new Child(1, 14);
            Child child2 = new Child(2, 12);
            Child child3 = new Child(5, 10);
            Child child4 = new Child(4, 10);
    
            List<Child> list = new ArrayList<>();
            list.add(child1);
            list.add(child2);
            list.add(child3);
            list.add(child4);
    
            Comparator<Child> comparator = Comparator.comparingInt(x -> x.getAge());
            Collections.sort(list, comparator);
            list.stream().forEach(System.out::println);
            Collections.sort(list, comparator.reversed());
            list.stream().forEach(System.out::println);
        }
    }

**thenComparing**

default <U extends Comparable<? super U>> Comparator<T> thenComparing(
                Function<? super T, ? extends U> keyExtractor)
        { 
            return thenComparing(comparing(keyExtractor));
        }

该方法是在原有的比较器上再加入一个比较器，比如先按照年龄排序，年龄相同的在按照id排序。比如：

public class Test { 
        public static void main(String[] args) { 
            Child child1 = new Child(1, 14);
            Child child2 = new Child(2, 12);
            Child child3 = new Child(5, 10);
            Child child4 = new Child(4, 10);
    
            List<Child> list = new ArrayList<>();
            list.add(child1);
            list.add(child2);
            list.add(child3);
            list.add(child4);
    
            Comparator<Child> comparator = Comparator.comparingInt(x -> x.getAge());
            Collections.sort(list, comparator);
            list.stream().forEach(System.out::println);
            System.out.println("-----");
            Collections.sort(list, comparator.thenComparing(x->x.getId()));
            list.stream().forEach(System.out::println);
        }
    }

## Comparable接口和Comparator接口的区别 ##

*  Comparable接口位于java.lang包下；Comparator位于java.util包下
 *  Comparable接口只提供了一个compareTo()方法；Comparator接口不仅提供了compara()方法，还提供了其他默认方法，如reversed()、thenComparing()，使我们可以按照更多的方式进行排序
 *  如果要用Comparable接口，则必须实现这个接口，并重写comparaTo()方法；但是Comparator接口可以在类外部使用，通过将该接口的一个匿名类对象当做参数传递给Collections.sort()方法或者Arrays.sort()方法实现排序。Comparator体现了一种策略模式，即可以不用要把比较方法嵌入到类中，而是可以单独在类外部使用，这样我们就可有不用改变类本身的代码而实现对类对象进行排序。