Java比较器

逃离我推掉我的手 2021-09-29 00:58 320阅读 0赞

### 文章目录 ###

*  Comparable
 *   *  Comparable接口简介
     *  Comparabel接口使用
 *  Comparator
 *   *  Comparator接口简介
     *  Comparator接口使用

# Comparable #

## Comparable接口简介 ##

*  `Comparable`译为可比较的，是一个接口（`interface`）。

## Comparabel接口使用 ##

*  通常如果一个类需要排序的话，就需要继承此Comparable接口，并覆盖其`compareTo(T o)`方法；
 *  `Comparable接口`的JDK1.8源码：

package java.lang;
    import java.util.*;
    
    public interface Comparable<T> 
    { 
        public int compareTo(T o);  
    }

*  T表示可以与此对象进行比较的对象的类型。
 *  约定`public int compareTo(T o)`方法，如果大于就`return 1`,如果等于就返回`return 0`,如果小于就`return -1`。
 *  可以对集合或数组进行排序，调用`Collections.sort(<T extends Comparable<? super T>>)`或者`Arrays.sort(<T extends Comparable<? super T>>)`即可。

# Comparator #

## Comparator接口简介 ##

*  `Comparator`译为比较，比较器等；是一个接口（`interface`）；

## Comparator接口使用 ##

*  `Comparator接口`的JDK1.8源码：

/* * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */
    
    package java.util;
    
    import java.io.Serializable;
    import java.util.function.Function;
    import java.util.function.ToIntFunction;
    import java.util.function.ToLongFunction;
    import java.util.function.ToDoubleFunction;
    import java.util.Comparators;
    
    
    @FunctionalInterface
    public interface Comparator<T> { 
       
        int compare(T o1, T o2);
    
        boolean equals(Object obj);
        
        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));
        }
    }