comparing 是 Comparator 功能接口的静态方法。 Java 8 中引入了 Comparator.comparing 方法。Comparator.comparing 接受一个 Function，该 Function 从给定类型中提取一个 Comparable 排序键，并返回一个按该排序键进行比较的 Comparator。 Comparator.comparing 有两种形式。
1.

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

我们需要传递一个 Function，它将从类型 T 中提取一个 Comparable 排序键，并返回一个通过该排序键进行比较的 Comparator。找到示例代码。

Comparator<Student> nameComparator = Comparator.comparing(Student::getName);

2.

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

我们需要传递一个 Function 和一个 Comparator。该方法将从类型 T 中提取一个排序键，并返回一个 Comparator，该 Comparator 使用指定的 Comparator 按该排序键进行比较。找到示例代码。

Comparator<Student> nameComparator = Comparator.comparing(Student::getName, (s1, s2) -> s2.compareTo(s1));

对于 int、long 和 double 数据类型排序键，Comparator 分别具有 comparingInt、comparingLong 和 comparingDouble 方法。

Comparator.comparing

在这里，我们将提供 Comparator.comparing 方法的示例。找到一个将实现 Comparable 接口的类并定义 compareTo 方法。
School.java

package com.concretepage;
public class School implements Comparable<School> {
  private int code;
  private String sname;
  public School(int code, String sname) {
	this.code = code;
	this.sname = sname;
  }
  public int getCode() {
        return code;
  }
  public String getSname() {
        return sname;
  }
  @Override
  public int compareTo(School s) {
	return s.sname.compareTo(sname);
  }
}

创建另一个类，我们将在其中创建 School 类型的类属性。
Student.java

package com.concretepage;
import java.util.Arrays;
import java.util.List;
public class Student {
  private String name;
  private int age;
  private long homeDistance;  
  private double weight;
  private School school;
  public Student(String name, int age, long homeDistance, double weight, School school) {
	this.name = name;
	this.age = age;
	this.homeDistance = homeDistance;
	this.weight = weight;
	this.school = school;
  }
  public String getName() {
        return name;
  }
  public int getAge() {
        return age;
  }
  public long getHomeDistance() {
        return homeDistance;
  }
  public double getWeight() {
        return weight;
  }
  public School getSchool() {
        return school;
  }
  public static List<Student> getStudentList() {
	Student s1 = new Student("Ram", 18, 3455, 60.75, new School(101, "PQ College"));
	Student s2 = new Student("Shyam", 22, 3252, 65.80, new School(103, "RS College"));
	Student s3 = new Student("Mohan", 19, 1459, 65.20, new School(102, "AB College"));
	Student s4 = new Student("Mahesh", 20, 4450, 70.25, new School(104, "CD College"));
	List<Student> list = Arrays.asList(s1, s2, s3, s4);
	return list;
  }
}

现在找到 Comparator.comparing 方法的例子。
ComparingDemo.java

package com.concretepage;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ComparingDemo {
  public static void main(String[] args) {
    List<Student> list = Student.getStudentList();
    
    Comparator<Student> schoolComparator1 = Comparator.comparing(Student::getSchool);
    Collections.sort(list, schoolComparator1);
    list.forEach(s->System.out.print(s.getName() + "-" + s.getSchool().getSname() + " | "));
    System.out.println("\n-------------------");    
    
    Comparator<Student> schoolComparator2 = 
    	Comparator.comparing(Student::getSchool, (sch1, sch2) -> sch1.getCode() - sch2.getCode());
    Collections.sort(list, schoolComparator2);
    list.forEach(s->System.out.print(s.getName() + "-" + s.getSchool().getCode() + " | "));
    System.out.println("\n-------------------");    
    
    Comparator<Student> nameComparator1 = Comparator.comparing(Student::getName); 
    Collections.sort(list, nameComparator1);
    list.forEach(s->System.out.print(s.getName() + " "));
    System.out.println("\n-------------------");

    Comparator<Student> nameComparator2 = Comparator.comparing(Student::getName, (s1, s2) -> s2.compareTo(s1));     
    Collections.sort(list, nameComparator2);
    list.forEach(s->System.out.print(s.getName() + " "));    
  }
}

输出

Shyam-RS College | Ram-PQ College | Mahesh-CD College | Mohan-AB College | 
-------------------
Ram-101 | Mohan-102 | Shyam-103 | Mahesh-104 | 
-------------------
Mahesh Mohan Ram Shyam 
-------------------
Shyam Ram Mohan Mahesh

在上面的示例中，我们使用 Collections.sort 对集合进行排序。我们还可以使用 Stream.sorted、List.sort 和 Arrays.sort 使用比较器对集合进行排序。

Comparator.comparingInt

找到 comparingInt 方法的声明。

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

它接受一个从类型 T 中提取 int 排序键的函数，并返回一个按该排序键进行比较的 Comparator。找到例子。
ComparingIntDemo.java

package com.concretepage;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ComparingIntDemo {
  public static void main(String[] args) {
    List<Student> list = Student.getStudentList();
    
    Collections.sort(list, Comparator.comparingInt(Student::getAge));
    list.forEach(s->System.out.print(s.getAge() + " "));    
  }
}

输出

18 19 20 22

Comparator.comparingLong

找到 comparingLong 方法的声明。

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

它接受一个从类型 T 中提取 long 排序键的函数，并返回一个按该排序键进行比较的 Comparator。找到例子。
ComparingLongDemo.java

package com.concretepage;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ComparingLongDemo {
  public static void main(String[] args) {
    List<Student> list = Student.getStudentList();
    
    Collections.sort(list, Comparator.comparingLong(Student::getHomeDistance));
    list.forEach(s->System.out.print(s.getHomeDistance() + " "));           
  }
}

输出

1459 3252 3455 4450

Comparator.comparingDouble

找到 comparingDouble 方法的声明。

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

它接受一个从类型 T 中提取 double 排序键的函数，并返回一个按该排序键进行比较的 Comparator。找到例子。
**比较DoubleDemo.java **

package com.concretepage;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ComparingDoubleDemo {
  public static void main(String[] args) {
    List<Student> list = Student.getStudentList();
    
    Collections.sort(list, Comparator.comparingDouble(Student::getWeight));
    list.forEach(s->System.out.print(s.getWeight() + " "));           
  }
}

输出

60.75 65.2 65.8 70.25