int     compare(T o1, T o2)

Compares its two arguments for order.

static <T,U extends Comparable<? super U>>

Comparator<T>     comparing(Function<? super T,? extends U> keyExtractor)

Accepts a function that extracts a Comparable sort key from a type T, and returns a Comparator<T> that compares by that sort key.

static <T,U> Comparator<T>     comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)

Accepts a function that extracts a sort key from a type T, and returns a Comparator<T> that compares by that sort key using the specified Comparator.

static <T> Comparator<T>     comparingDouble(ToDoubleFunction<? super T> keyExtractor)

Accepts a function that extracts a double sort key from a type T, and returns a Comparator<T> that compares by that sort key.

static <T> Comparator<T>     comparingInt(ToIntFunction<? super T> keyExtractor)

Accepts a function that extracts an int sort key from a type T, and returns a Comparator<T> that compares by that sort key.

static <T> Comparator<T>     comparingLong(ToLongFunction<? super T> keyExtractor)

Accepts a function that extracts a long sort key from a type T, and returns a Comparator<T> that compares by that sort key.

boolean     equals(Object obj)

Indicates whether some other object is "equal to" this comparator.

static <T extends Comparable<? super T>>

Comparator<T>     naturalOrder()

Returns a comparator that compares Comparable objects in natural order.

static <T> Comparator<T>     nullsFirst(Comparator<? super T> comparator)

Returns a null-friendly comparator that considers null to be less than non-null.

static <T> Comparator<T>     nullsLast(Comparator<? super T> comparator)

Returns a null-friendly comparator that considers null to be greater than non-null.

default Comparator<T>     reversed()

Returns a comparator that imposes the reverse ordering of this comparator.

static <T extends Comparable<? super T>>

Comparator<T>     reverseOrder()

Returns a comparator that imposes the reverse of the natural ordering.

default Comparator<T>     thenComparing(Comparator<? super T> other)

Returns a lexicographic-order comparator with another comparator.

default <U extends Comparable<? super U>>

Comparator<T>     thenComparing(Function<? super T,? extends U> keyExtractor)

Returns a lexicographic-order comparator with a function that extracts a Comparable sort key.

default <U> Comparator<T>     thenComparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)

Returns a lexicographic-order comparator with a function that extracts a key to be compared with the given Comparator.

default Comparator<T>     thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)

Returns a lexicographic-order comparator with a function that extracts a double sort key.

default Comparator<T>     thenComparingInt(ToIntFunction<? super T> keyExtractor)

Returns a lexicographic-order comparator with a function that extracts a int sort key.

default Comparator<T>     thenComparingLong(ToLongFunction<? super T> keyExtractor)

Returns a lexicographic-order comparator with a function that extracts a long sort key.

Collections.sort(rateInfolist, Comparator.comparing(RateInfo::getRateCode));

Collections.sort(rateInfolist, new Comparator<RateInfo>(){

                    /*

                     * int compare(RateInfo R1, RateInfo R2) 返回一个基本类型的整型，

                     * 返回负数表示：R1 小于R2，

                     * 返回0 表示：R1和R2相等，

                     * 返回正数表示：R1大于R2

                     */

                    public int compare(RateInfo R1, RateInfo R2) {

                        Integer rateCode1 = Integer.parseInt(R1.getRateCode());

                        Integer rateCode2 = Integer.parseInt(R2.getRateCode());

                        //按照RateCode的年龄进行升序排列

                        if(rateCode1 > rateCode2){

                            return 1;

                        }

                        if(rateCode1 == rateCode2){

                            return 0;

                        }

                        return -1;

                    }

                });