Java의 Comparator 및 Comparable 소개 및 차이점 예

이 기사에서는 먼저 Comparable과 Comparator의 두 가지 인터페이스를 소개하고 차이점을 설명한 다음 예제를 통해 사용법을 설명합니다.

Comparable 소개

Comparable은 정렬 인터페이스입니다.

클래스가 Comparable 인터페이스를 구현하는 경우 "이 클래스는 정렬을 지원합니다"를 의미합니다. Comparable 인터페이스를 구현하는 클래스는 정렬을 지원하므로 이제 "Comparable 인터페이스를 구현하는 클래스의 객체 목록(또는 배열)"이 있다고 가정하면 해당 목록(또는 배열)은 Collections.sort(또는 Arrays.sort) 정렬.

또한 "Comparable 인터페이스를 구현하는 클래스의 객체"는 비교기를 지정하지 않고도 "Ordered Maps(예: TreeMap)"의 키 또는 "Ordered Set(TreeSet)"의 요소로 사용할 수 있습니다.

1. Comparable의 코드는 다음과 같습니다.

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

2. Comparator의 코드는 다음과 같습니다.

public interface Comparator<T> {int compare(T o1, T o2);boolean equals(Object obj);    // jdk1.8 后的方法default Comparator<T> reversed() {return Collections.reverseOrder(this);
    }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);
        };
    }default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {return thenComparing(comparing(keyExtractor, keyComparator));
    }default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {return thenComparing(comparing(keyExtractor));
    }default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {return thenComparing(comparingInt(keyExtractor));
    }default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {return thenComparing(comparingLong(keyExtractor));
    }default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {return thenComparing(comparingDouble(keyExtractor));
    }public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {return Collections.reverseOrder();
    }

    @SuppressWarnings("unchecked")public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {return new Comparators.NullComparator<>(true, comparator);
    }public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {return new Comparators.NullComparator<>(false, comparator);
    }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));
    }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));
    }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));
    }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));
    }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));
    }
}

Comparable과 Comparator의 주요 차이점은

　　(1)입니다. Comparable은 둘 다 Java 내부에 있습니다. 비교기 인터페이스는 사용자 정의 클래스를 정렬하는 데 사용됩니다

　　　　(2). 차이점은 Comparable 인터페이스의 구현이 클래스 내부에 정의되고 비교 코드가 클래스에 포함되어야 한다는 것입니다. 클래스 내부 구조

　　(3). Comparator는 클래스 외부에서 구현되며, 첫 번째 Comparator는 별도로 구현되며, 원래 클래스에 구조적 변경을 가할 필요가 없으며 방해가 되지 않습니다. .

예를 들어 Comparable 인터페이스를 구현합니다.

    class Score implements Comparable<Score>{  
      public int score;  
      public int time;  
        public int getScore() {  return score;  
    }  
      public void setScore(int score) {  this.score = score;  
    }  
      public int getTime() {  return time;  
    }  
      public void setTime(int time) {  this.time = time;  
    }  
      
        @Override  public int compareTo(Score o) {  if(this.time>o.time) return 1;  else if(this.time==o.time) return 0;  else return -1;  
        }  
      public Score(int score, int time) {  super();  this.score = score;  this.time = time;  
        }  
    }

Comparator 인터페이스 구현 예:

    class ScoreComparator implements Comparator<Score>{  
      
        @Override  public int compare(Score o1, Score o2) {  if(o1.time>o2.time) return 1;  else if(o1.time==o2.time) return 0;  else return -1;  
        }     
    }

그런 다음 ScoreComparator를 호출합니다.

rreee

위 내용은 Java의 Comparator 및 Comparable 소개 및 차이점 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!