java基础__comaprable和comparator的区别

短命女 2022-05-27 03:05 173阅读 0赞

## 前言 ##

在核心技术卷1中，有一部分是介绍Comparable和Comparator，一开始只知道一个是接口还有一个是啥定制的比较器，认识比较模糊，于是专门写一个博客来比较二者

## 概念 ##

Comparable就像是自然排序，在需要比较的类内部实现，重写一个compareTo方法，类上实现comparable这个接口就行了。  
Comparator为什么被称为是定制的比较器呢？是因为它在需要比较的类外面独立成立了一个自定义比较规则的实现Comparator接口的类，这个类重写了compare方法，生成实例对象，然后传递给排序的方法

## Comparable ##

Comparable是一个函数式接口，因为当中只有一个方法compareTo：

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

通过类实现这个接口，并且重写这个方法来实现比较

有三种情况

*  x1.compareTo(x2) >0 代表 x1>x2
 *  x1.compareTp(x2) <0 代表 x1

### 实例 ###

比如说ArraryList进行sort排序的时候，需要提供一个Comparator对象如果是null的话，则要求所有内部对象都实现Comparable这个接口

> If the specified comparator is null then all elements in this list must implement the Comparable interface and the elements’ natural ordering should be used.

package compare;
    
    import java.util.Objects;
    
    
    public class Employee implements Comparable<Employee> { 
        private String name;
        private double salary;
    
        public Employee(String name, double salary)
        {
            this.name = name;
            this.salary = salary;
        }
    
        public String getName()
        {
            return this.name;
        }
    
        public double getSalary()
        {
            return this.salary;
        }
    
        @Override
        public boolean equals(Object otherObject)
        {
            if (otherObject == null) 
            {
                return false;
            }
    
            if (this == otherObject) 
            {
                return true;
            }
    
            if (this.getClass() != otherObject.getClass()) 
            {
                return false;
            }
    
            Employee other= (Employee) otherObject;
    
            return this.getSalary() == other.getSalary()
                    && Objects.equals(getName(), getName());
        }
    
        @Override
        public int hashCode()
        {
            return Objects.hash(this.name,this.salary);
        }
    
        @Override
        public String toString()
        {
            return getClass().getName() + "[ name: "+this.getName() + ", salary: " + this.getSalary() + " ]"; 
        }
    
        @Override
        public int compareTo(Employee other) 
        {
            int result = this.name.compareTo(other.getName());
    
            if (result == 0) 
            {
                result = Double.compare(this.getSalary(), other.getSalary());
            }
    
            return result;
        }
    
    }

**讲解：**  
这个Employee类实现了comparable接口，并且重写了compareTo这个方法，里面写了一个小小的策略。并且重写了object的equals、tostring、hashcode方法，这是一个好习惯，当做对比的时候，要重写这些方法从而保证一致性。我们可以看到compareTo方法是在Employee内部实现的。这个就是comparable的实现方式，下面来看看Comparator的实现

## Comparator ##

Comparator叫做定制比较器，为啥呢？因为它不是类内部实现，而是专门另外找一个实现Comparator接口的类，在这个类里面重写compare方法，将这个类的对象传递。ArrayList.sort方法就需要这样的一个定制比较器.

### 实例 ###

定制比较器的类

package compare;
    
    import java.util.Comparator;
    
    public class MyComparator implements Comparator<Employee> { 
    
        @Override
        public int compare(Employee first, Employee second) 
        {
            int result = Double.compare(first.getSalary(), second.getSalary());
    
            if (result == 0) 
            {
                result = first.getName().compareTo(second.getName());
            }
    
            return result;
        }
    
    }

测试两种实现的代码

package compare;
    
    import java.util.ArrayList;
    
    public class ComparableTest 
    {
        public static void main(String[] args)
        {
            ArrayList<Employee> staff = new ArrayList<>();
            Employee ex1 = new Employee("xiaoxin", 5000);
            Employee ex2 = new Employee("Bob", 5000);
            Employee ex3 = new Employee("Max", 4000);
    
    
            staff.add(ex1);
            staff.add(ex2);
            staff.add(ex3);
    
            // 以null作为参数（用comparable）
            staff.sort(null);
    
    
            for (Employee employee : staff) 
            {
                System.out.println(employee.toString());
            }
    
            System.out.println();
    
            // 使用定制类(comparator)
            staff.sort(new MyComparator());
    
            for (Employee employee : staff) 
            {
                System.out.println(employee.toString());
            }
        }
    }
    
    --------
    输出结果:
    compare.Employee[ name: Bob, salary: 5000.0 ]
    compare.Employee[ name: Max, salary: 4000.0 ]
    compare.Employee[ name: xiaoxin, salary: 5000.0 ]
    
    compare.Employee[ name: Max, salary: 4000.0 ]
    compare.Employee[ name: Bob, salary: 5000.0 ]
    compare.Employee[ name: xiaoxin, salary: 5000.0 ]

我们可以看到结果。因为我在comparable里面设置的是先比较String，在比较salary；在Comparator里面先比较salary。

## 总结 ##

两种方法，一个在实例类中实现，一个在类外实现，不用修改实体类。  
个人感觉，在自定义类中做比较还是实现Comparator更好一些，基本数据类型现成的comparable。