【Java 8 新特性】Java Comparator.reverseOrder | 倒序排序-静态方法

ゞ浴缸里的玫瑰 2023-09-30 17:00 5阅读 0赞

#### 文章目录 ####

*  在 Stream.sorted 中使用
 *  在 Collections.sort 中使用
 *  在 List.sort 中使用
 *  在 Arrays.sort 中使用
 *  参考文献

`Comparator.reverseOrder`是`Java 8`中引入的一个静态方法，它返回比较器，对对象集合进行反向自然排序。

对于自然排序，一个类需要实现`Comparable`并定义`compareTo`方法。

一个对象集合根据自然排序中的`compareTo`进行排序。

`Comparator.reverseOrder`反转了自然排序。

它在内部调用`Collections.reverseOrder()`并返回比较器实例。

查找`Comparator.reverseOrder`的`Java`源代码。

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        
         return Collections.reverseOrder();
    }

`Comparator`还提供了`Comparator.naturalOrder`方法，该方法对对象集合施加自然顺序。

数字的自然顺序是数字顺序，字符串按字母顺序排序，日期按时间顺序排序。

`Integer`、`String`和`Date`等`Java`类实现`Comparable`并重写其`compareTo`方法以实现自然排序。

为了促进类中的自然排序，我们需要实现`Comparable`接口并定义`compareTo`方法。

`Comparator.reverseOrder`返回比较器以逆转自然排序。

我们可以将`Comparator.reverseOrder`与`Stream.sorted`、`List.sort`、`Collections.sort`和`Arrays.sort`一起使用，对对象的集合进行反向自然排序。

## 在 Stream.sorted 中使用 ##

`Stream.sorted`返回一个由这个流的元素组成的流，根据提供的比较器进行排序。

**StreamSortedDemo.java**

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    public class StreamSortedDemo {
        
      public static void main(String[] args) {
        
    	List<Integer> numList = Arrays.asList(12, 10, 15, 8, 11);
    	numList.stream().sorted(Comparator.reverseOrder()).forEach(n -> System.out.print(n + " "));
    	System.out.println("\n-----------");
    	
    	List<String> strList = Arrays.asList("Varanasi", "Allahabad", "Kanpur", "Noida");
    	strList.stream().sorted(Comparator.reverseOrder()).forEach(s -> System.out.print(s + " "));
    	System.out.println("\n-----------");	
    	
    	List<Student> stdList = Student.getStudentList();
    	stdList.stream().sorted(Comparator.reverseOrder()).forEach(s -> System.out.print(s.getName() + " "));
      }
    }

**Student.java**

import java.util.Arrays;
    import java.util.List;
    
    public class Student implements Comparable<Student> {
        
      private String name;
      private int age;
      public Student(String name, int age) {
        
    	this.name = name;
    	this.age = age;
      }
      public String getName() {
        
    	return name;
      }
      public int getAge() {
        
    	return age;
      }
      @Override
      public int compareTo(Student s) {
        
    	return name.compareTo(s.getName());
      }
      public static List<Student> getStudentList() {
        
    	Student s1 = new Student("Ram", 18);
    	Student s2 = new Student("Shyam", 22);
    	Student s3 = new Student("Mohan", 19);
    	Student s4 = new Student("Mahesh", 20);
    	Student s5 = new Student("Krishna", 21);
    	List<Student> list = Arrays.asList(s1, s2, s3, s4, s5);
    	return list;
      }
    }

输出

15 12 11 10 8 
    -----------
    Varanasi Noida Kanpur Allahabad 
    -----------
    Shyam Ram Mohan Mahesh Krishna

## 在 Collections.sort 中使用 ##

`Collections.sort`根据给定的比较器实例对指定的列表进行排序。

**CollectionsSortDemo.java**

import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    public class CollectionsSortDemo {
        
      public static void main(String[] args) {
        
    	List<Integer> numList = Arrays.asList(12, 10, 15, 8, 11);
    	Collections.sort(numList, Comparator.reverseOrder());
    	numList.forEach(n -> System.out.print(n + " "));
    	System.out.println("\n-----------");
    	
    	List<String> strList = Arrays.asList("Varanasi", "Allahabad", "Kanpur", "Noida");
    	Collections.sort(strList, Comparator.reverseOrder());
    	strList.forEach(s -> System.out.print(s + " "));
    	System.out.println("\n-----------");	
    	
    	List<Student> stdList = Student.getStudentList();
    	Collections.sort(stdList, Comparator.reverseOrder());
    	stdList.forEach(s -> System.out.print(s.getName() + " "));	
      }
    }

## 在 List.sort 中使用 ##

`List.sort`根据给定的比较器实例对这个列表进行排序。

**ListSortDemo.java**

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    public class ListSortDemo {
        
      public static void main(String[] args) {
        
    	List<Integer> numList = Arrays.asList(12, 10, 15, 8, 11);
    	numList.sort(Comparator.reverseOrder());
    	numList.forEach(n -> System.out.print(n + " "));
    	System.out.println("\n-----------");
    	
    	List<String> strList = Arrays.asList("Varanasi", "Allahabad", "Kanpur", "Noida");
    	strList.sort(Comparator.reverseOrder());
    	strList.forEach(s -> System.out.print(s + " "));
    	System.out.println("\n-----------");	
    	
    	List<Student> stdList = Student.getStudentList();
    	stdList.sort(Comparator.reverseOrder());
    	stdList.forEach(s -> System.out.print(s.getName() + " "));
      }
    }

## 在 Arrays.sort 中使用 ##

`Arrays.sort`根据指定比较器产生的顺序对指定的对象数组进行排序。

**ArraysSortDemo.java**

import java.util.Arrays;
    import java.util.Comparator;
    public class ArraysSortDemo {
        
      public static void main(String[] args) {
        
    	Student s1 = new Student("Ram", 18);
    	Student s2 = new Student("Shyam", 22);
    	Student s3 = new Student("Mohan", 19);
    
    	Student[] stdArray = {
         s1, s2, s3 };
    	Arrays.sort(stdArray, Comparator.reverseOrder());
    	for (Student s : stdArray) {
        
    	  System.out.print(s.getName() + " ");
    	}
      }
    }

## 参考文献 ##

[【1】Interface Comparator][1_Interface Comparator]  
[【2】Java 8 Stream sorted() Example][2_Java 8 Stream sorted_ Example]  
[【3】Java Comparator.reverseOrder][3_Java Comparator.reverseOrder]

[1_Interface Comparator]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Comparator.html
[2_Java 8 Stream sorted_ Example]: https://blog.csdn.net/qq_31635851/article/details/111352643
[3_Java Comparator.reverseOrder]: https://www.concretepage.com/java/java-8/java-comparator-reverseorder