ホームページ  >  記事  >  Java  >  JavaのComparatorとComparableの紹介と違いの例

JavaのComparatorとComparableの紹介と違いの例

零下一度
零下一度オリジナル
2017-07-17 15:30:221869ブラウズ

この記事では、まず Comparable と Comparator の 2 つのインターフェイスとその違いを紹介し、次に例を通してその使用法を説明します。

Comparable の概要

Comparable は並べ替えインターフェイスです。

クラスが Comparable インターフェースを実装している場合、それは「このクラスは並べ替えをサポートしている」ことを意味します。 Comparable インターフェイスを実装するクラスは並べ替えをサポートしているため、「Comparable インターフェイスを実装するクラスのオブジェクトのリスト (または配列)」があると仮定すると、そのリスト (または配列) は Collections.sort (またはArrays.sort) 並べ替えます。

また、「Comparableインターフェースを実装したクラスのオブジェクト」は、コンパレータを指定せずに「順序付きマップ(TreeMapなど)」のキーや「順序付きセット(TreeSet)」の要素として使用できます。

1. Comparableのコードは次のとおりです:

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

2. Comparableのコードは次のとおりです

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 の内部です comparator インターフェイスはカスタム クラスの並べ替えを実装するために使用されます

(2) 違いは、Comparable インターフェイスの実装がクラス内で定義され、比較コードが必要なことです。クラスの内部構造に埋め込まれています

(3). コンパレータはクラスの外に実装されており、最初のコンパレータは元のクラスに構造的な変更を加える必要はなく、非実装です。 -侵入的。

たとえば、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 を呼び出します:

りー

以上がJavaのComparatorとComparableの紹介と違いの例の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

声明:
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。