Java 中的比较器

所谓的比较器指的就是进行大小关系的确定判断，下面首先来分析一下比较器存在的意义

比较器问题的引出

如果要进行数组操作，首先会使用的是 java.util.Arrays 的操作类完成，这个类里面提供有绝大部分的数组操作支持，同时在这个类里面还提供有一种对象数组的排序支持：

public static void sort(Object[] a)

举例：（实现对象数组的排序）

package com.java.springtest.test;

import java.util.Arrays;

/**
 * @author Woo_home
 * @create by 2020/1/22
 */
public class JavaDemo {
    public static void main(String[] args) {
        Integer[] data = new Integer[]{10,9,5,2,20}; // 对象数组
        Arrays.sort(data);                           // 进行对象数组的排序
        System.out.println(Arrays.toString(data));
    }
}

输出：

同样地，如果说现在给定的是一个 String 类型的对象数组，那么也是可以进行排序处理的

举例：（String 对象数组的排序）

package com.java.springtest.test;

import java.util.Arrays;

/**
 * @author Woo_home
 * @create by 2020/1/22
 */
public class JavaDemo {
    public static void main(String[] args) {
        String[] data = new String[]{"X","B","A","E","G"};
        Arrays.sort(data);                           // 进行对象数组的排序
        System.out.println(Arrays.toString(data));
    }
}

输出：

java.lang.Integer 与 java.lang.String 两个类都是由系统提供的程序类，那么如果说现在有一个自定义的类需要实现排序处理呢？

举例：（采用自定义类型进行排序）

package com.java.springtest.test;

import java.util.Arrays;

/**
 * @author Woo_home
 * @create by 2020/1/22
 */

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    // 省略 setter 与 getter

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class JavaDemo {
    public static void main(String[] args) {
        Person[] person = new Person[] {
                new Person("A",2),
                new Person("B",3),
                new Person("C",1)
        };
        Arrays.sort(person);                           // 进行对象数组的排序
        System.out.println(Arrays.toString(person));
    }
}

输出：报错了（运行时异常）

任意的一个类默认情况下是无法使用系统内部的类实现数组排序或者比较需求的，是因为没有明确的指定出到底该如何进行比较的定义（没有比较规则），那么这个时候在 Java 里面为了统一比较规则的定义，所以提供了比较器的接口：Comparable

Comparable 比较器

通过分析可以发现如果要实现对象的比较肯定需要有比较器来制定比较规则，而比较的规则就通过 Comparable 来实现。就 Comparable 而言，需要清楚其基本的定义结构：

public interface Comparable<T> {
    /**
     * 实现对象的比较处理操作
     * @param o 要比较的对象
     * @return  当前数据比传入的对象小，则返回负数
     * 如果大于，则返回整数
     * 如果等于，则返回 0
     */
    public int compareTo(T o);
}

举例：（实现自定义对象数组排序）

package com.java.springtest.test;

import java.util.Arrays;

/**
 * @author Woo_home
 * @create by 2020/1/22
 */

class Person implements Comparable<Person> {
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    // 省略 setter 与 getter

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person person) {
        return this.age - person.age;
    }
}



public class JavaDemo {
    public static void main(String[] args) {
        Person[] person = new Person[] {
                new Person("A",2),
                new Person("B",3),
                new Person("C",1)
        };
        Arrays.sort(person);                           // 进行对象数组的排序
        System.out.println(Arrays.toString(person));
    }
}

输出：

排序里面只需要有一个 compareTo() 方法进行排序规则的定义，而后整个 Java 系统里面就可以为其实现排序处理了

Comparator 比较器

Comparator 属于一种挽救的比较器支持，其主要的目的是解决一些没有使用 Comparable 排序的类的对象数组排序。在 Arrays 类里面排序有另外一种方法处理：

• 基于 Comparator 的排序处理：public static void sort(T[] a,Comparator<? super T> c)

在 java.util.Comparator 里面最初只定义有一个排序的 compare() 方法 public int compare(T o1,T o2)，但是后来持续发展又出现了许多的 static 方法

举例：（定义排序规则类）

class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getAge() - person2.getAge();
    }
}

在测试类中进行排序处理的时候就可以利用排序规则实现操作

举例：（实现排序）

package com.java.springtest.test;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author Woo_home
 * @create by 2020/1/22
 */

class Person implements Comparable<Person> {
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        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 compareTo(Person person) {
        return this.age - person.age;
    }
}

class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getAge() - person2.getAge();
    }
}

public class JavaDemo {
    public static void main(String[] args) {
        Person[] person = new Person[] {
                new Person("A",2),
                new Person("B",3),
                new Person("C",1)
        };
        Arrays.sort(person,new PersonComparator());                           // 进行对象数组的排序
        System.out.println(Arrays.toString(person));
    }
}

输出：

对于这种排序的操作，如果不是必须的情况下强烈不建议使用 Comparator ，最好是使用 Comparable

面试题

请解释一下 Comparable 与 Comparator 的区别？

• java.lang.Comparable 是在类定义的时候实现的父接口，主要用于定义排序规则，里面只有一个 compareTo(Object o) 方法
• java.util.Comparator 是挽救的比较器操作，需要设置单独的比较器规则实现排序，里面有一个 compare() 方法

转载：https://blog.csdn.net/Woo_home/article/details/104070506