java compareTo 方法 和 Comparator 接口

compareTo 方法是接口 Comparable 的实现

返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的长度差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于 0 的值；如果此字符串大于字符串参数，则返回一个大于 0 的值。

说明：

如果第一个字符和参数的第一个字符不等，结束比较，返回第一个字符的ASCII码差值。

如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至不等为止，返回该字符的ASCII码差值。 如果两个字符串不一样长，可对应字符又完全一样，则返回两个字符串的长度差值。

Integer 和 String 实现了compareTo 方法

实体对象实现方法

package com.study.stream;

import java.util.Objects;

public class Person implements Comparable{
    private String name;
    private Integer age;
    private Integer height;

    public Person(String name, Integer age, Integer height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return name.equals(person.name) &&
                age.equals(person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return String.format("姓名:%s;年龄:%s;身高:%s;",this.name,this.age,this.height);
    }


    
    @Override
    public int compareTo(Person o) {
        return this.getAge().compareTo(o.getAge());
    }
}

实体对象排序:

2.Comparator 接口

Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外，还提供了一个接口，该接口也是具有比较的功能，但该接口注重的却是比较容器，然后对其排序，这就是Comparator

源码：

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 {
 
    int compare(T o1, T o2);
 
    boolean equals(Object obj);
 
 
    default Comparator reversed() {
        return Collections.reverseOrder(this);
    }
 
    default Comparator thenComparing(Comparator other) {
        Objects.requireNonNull(other);
        return (Comparator & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
 
    default  Comparator thenComparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }
 
    default > Comparator thenComparing(
            Function keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }
 
    default Comparator thenComparingInt(ToIntFunction keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }
 
    default Comparator thenComparingLong(ToLongFunction keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }
 
    default Comparator thenComparingDouble(ToDoubleFunction keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }
    public static > Comparator reverseOrder() {
        return Collections.reverseOrder();
    }
 
    @SuppressWarnings("unchecked")
    public static > Comparator naturalOrder() {
        return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;
    }
 
    public static  Comparator nullsFirst(Comparator comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }
 
    public static  Comparator nullsLast(Comparator comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }
 
    public static  Comparator comparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }
 
    public static > Comparator comparing(
            Function keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
 
 
    public static  Comparator comparingInt(ToIntFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }
 
    public static  Comparator comparingLong(ToLongFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }
 
 
    public static Comparator comparingDouble(ToDoubleFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}

System.out.println("***************--sorted 定义排序规则 身高,年龄排序--***************************");
personList.stream().sorted(Comparator.comparing(Person::getHeight,Comparator.naturalOrder()).thenComparing(Person::getAge,Comparator.naturalOrder())).forEach(System.out::println);