Java의 Comparable 및 Comparator에 대한 비교 소개(코드 예)

이 기사는 Java의 Comparable과 Comparator 간의 비교 소개(코드 예제)를 제공합니다. 필요한 친구가 참고할 수 있기를 바랍니다.

1. 개요

Java에서의 정렬은 Comparable과 Comparator라는 두 가지 인터페이스를 통해 제공됩니다.

비교 가능이란 정렬이 가능하다는 의미이며, 이 인터페이스를 구현하는 클래스의 객체는 자동으로 정렬 기능을 갖습니다.

Comparator는 비교기를 나타냅니다. 이 인터페이스를 구현하는 클래스의 객체는 대상 클래스의 객체에 대해 정의된 비교기입니다. 일반적으로 이 비교기는 매개변수로 전달됩니다.

2. Comparable

Comparable의 중국어 뜻은 정렬이 가능하다는 뜻으로 정렬 기능을 지원한다는 의미입니다. 우리 클래스가 이 인터페이스를 구현하는 한, 이 클래스의 객체는 자동으로 정렬되는 기능을 갖게 됩니다. 그리고 이 순서를 클래스의 자연스러운 순서라고 합니다. 이 클래스의 개체 목록은 Collections.sort 및 Arrays.sort를 기준으로 정렬할 수 있습니다. 동시에 이 클래스의 인스턴스는 정렬된 맵의 키와 정렬된 세트의 요소로 자격이 부여됩니다.

a와 b가 모두 Comparable 인터페이스를 구현하는 클래스 C의 인스턴스인 경우 a.compareTo(b)의 결과가 a.equals(b)의 결과와 일치하는 경우에만 클래스 C의 자연스러운 순서가 가능합니다. 일관되게 호출됩니다. 클래스의 자연 순서를 같음 결과와 일관되게 유지하는 것이 좋습니다. 왜냐하면 일관되지 않은 경우 이 클래스의 개체를 키로 사용하고 이 클래스의 개체를 요소로 사용하는 정렬된 집합의 동작은 다음과 같기 때문입니다. 이상하게 행동해.

예를 들어 Comparable 인터페이스를 구현하는 정렬된 집합의 경우 a.equals(b)의 결과가 false이고 a.compareTo(b)==0이면 두 번째 요소의 추가 작업이 실패합니다. 정렬된 집합의 관점에서 볼 때 두 가지 정렬은 일관되며 중복된 요소를 저장하지 않습니다.

실제로 Java에서 클래스의 자연 순서는 BigDecimal을 제외하고 기본적으로 같음과 일치합니다. 왜냐하면 BigDecimal의 자연 순서는 값은 동일하지만 정밀도가 다른(예: 4 및 4.00) 요소의 같음과 일치하기 때문입니다.

소스 코드 분석

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

소스 코드에서 인터페이스에는 CompareTo라는 추상 메서드가 하나만 있는 것을 볼 수 있습니다. 이 메서드는 주로 클래스 정렬 방식을 정의하는 데 사용됩니다. CompareTo 메서드는 현재 요소 a를 지정된 요소 b와 비교하는 데 사용됩니다. a = b이면 int = 0입니다. 정수

3. Comparator

Comparator는 중국어로 비교기로 번역됩니다. 이는 특정 클래스 개체의 정렬 방법을 지정하기 위해 Collections.sort 및 Arrays.sort 메서드에 매개 변수로 전달될 수 있습니다. 동시에 정렬된 세트 및 정렬된 지도에 대한 정렬 방법을 지정할 수도 있습니다.

Comparable과 유사하게 비교기를 지정할 때 일반적으로 비교 결과가 같음 결과와 일치하는지 확인해야 합니다. 일치하지 않으면 해당 정렬 집합 및 정렬 맵의 동작도 이상해집니다.

구현된 비교기 클래스는 직렬화된 데이터 구조(TreeSet, TreeMap)의 정렬 방법으로 사용될 수 있으므로 직렬화 기능을 갖도록 java.io.Serialized 인터페이스도 구현하는 것이 좋습니다.

소스 코드 분석

@FunctionalInterface
public interface Comparator<T> {
    // 唯一的抽象方法，用于定义比较方式（即排序方式）
    // o1>o2，返回1；o1=o2，返回0；o1<o2，返回-1
    int compare(T o1, T o2);
    boolean equals(Object obj);
    // 1.8新增的默认方法：用于反序排列
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
    // 1.8新增的默认方法：用于构建一个次级比较器，当前比较器比较结果为0，则使用次级比较器比较
    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
    // 1.8新增默认方法：指定次级比较器的
    // keyExtractor表示键提取器，定义提取方式
    // keyComparator表示键比较器，定义比较方式
    default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }
    // 1.8新增默认方法：用于执行键的比较，采用的是由键对象内置的比较方式
    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }
    // 1.8新增默认方法：用于比较执行int类型的键的比较
    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }
    // 1.8新增默认方法：用于比较执行long类型的键的比较
    default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }
    // 1.8新增默认方法：用于比较执行double类型的键的比较
    default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }
    // 1.8新增静态方法：用于得到一个相反的排序的比较器，这里针对的是内置的排序方式（即继承Comparable）
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }
    // 1.8新增静态方法：用于得到一个实现了Comparable接口的类的比较方式的比较器
    // 简言之就是将Comparable定义的比较方式使用Comparator实现
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }
    // 1.8新增静态方法：得到一个null亲和的比较器，null小于非null，两个null相等，如果全不是null,
    // 则使用指定的比较器比较，若未指定比较器，则非null全部相等返回0
    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }
    // 1.8新增静态方法：得到一个null亲和的比较器，null大于非null，两个null相等，如果全不是null,
    // 则使用指定的比较器比较，若未指定比较器，则非null全部相等返回0
    public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }
    // 1.8新增静态方法：使用指定的键比较器用于执行键的比较
    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }
    // 1.8新增静态方法：执行键比较，采用内置比较方式，key的类必须实现Comparable
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
    // 1.8新增静态方法：用于int类型键的比较
    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }
    // 1.8新增静态方法：用于long类型键的比较
    public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }
    // 1.8新增静态方法：用于double类型键的比较
    public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}

이전 버전의 Comparator에는 처음 두 가지 방법만 있습니다. 이후의 모든 기본 방법은 1.8에 추가된 새 기능을 사용하여 1.8에 추가된 새 방법입니다. 인터페이스는 추가할 수 있습니다. 기본 방법. 메소드가 너무 많아도 인터페이스는 여전히 기능적 인터페이스이며 비교 메소드를 정의하는 데 비교가 사용됩니다.

4. 둘 사이의 비교

Comparable은 내부 비교기로 간주할 수 있고 Comparator는 외부 비교기로 간주할 수 있습니다.

클래스는 Comparable 인터페이스를 구현하여 질서를 가질 수도 있고, 추가적인 Comparator를 지정하여 질서를 더할 수도 있습니다.

둘의 기능은 실제로 동일하므로 혼합하지 마세요.

예를 살펴보겠습니다.

먼저 모델을 정의합니다: User

public class User implements Serializable, Comparable<User> {
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;
    public User (){}
    public User (int age, String name){
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int compareTo(User o) {
        return this.age - o.age;
    }
    @Override
    public String toString() {
        return "[user={age=" + age + ",name=" + name + "}]";
    }
}

그런 다음 비교기 구현 클래스를 정의합니다. MyComparator

public class MyComparator implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        return o1.getName().charAt(0)-o2.getName().charAt(0);
    }
}

마지막으로 테스트 클래스: Main

public class Main {
    public static void main(String[] args) {
        User u1 = new User(12, "xiaohua");
        User u2 = new User(10, "abc");
        User u3 = new User(15,"ccc");
        User[] users = {u1,u2,u3};
        System.out.print("数组排序前：");
        printArray(users);
        System.out.println();
        Arrays.sort(users);
        System.out.print("数组排序1后：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, new MyComparator());
        System.out.print("数组排序2后：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, Comparator.reverseOrder());// 针对内置的排序进行倒置
        System.out.print("数组排序3后：");
        printArray(users);
    }
    public static void printArray (User[] users) {
        for (User user:users) {
            System.out.print(user.toString());
        }
    }
}

실행 결과는 다음과 같습니다.

数组排序前：[user={age=12,name=xiaohua}][user={age=10,name=abc}][user={age=15,name=ccc}]
数组排序1后：[user={age=10,name=abc}][user={age=12,name=xiaohua}][user={age=15,name=ccc}]
数组排序2后：[user={age=10,name=abc}][user={age=15,name=ccc}][user={age=12,name=xiaohua}]
数组排序3后：[user={age=15,name=ccc}][user={age=12,name=xiaohua}][user={age=10,name=abc}]

위를 통해 예를 들어 결론은 정렬 우선 순위를 정의하는 두 가지 방법이 있다는 것입니다. 분명히 Comparator 비교기는 내부 정렬 Comparable보다 우선합니다.

5. 요약

Comparable은 정렬이 가능하며 이 인터페이스를 구현하는 클래스의 객체는 자동으로 정렬 기능을 갖습니다.

Comparator는 이 인터페이스를 구현하면 특정 클래스에 대한 정렬 방법을 정의할 수 있습니다.

Comparator와 Comparable이 동시에 존재할 경우 전자의 우선순위가 더 높습니다.

위 내용은 Java의 Comparable 및 Comparator에 대한 비교 소개(코드 예)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!