Làm cách nào để sử dụng lambda Java8 để sắp xếp luồng theo thứ tự ngược lại?

Tôi đang sử dụng java lambda để sắp xếp một danh sách.

Làm thế nào tôi có thể sắp xếp nó theo một cách ngược lại?

Tôi đã thấy bài đăng này , nhưng tôi muốn sử dụng java 8 lambda.

Đây là mã của tôi (tôi đã sử dụng * -1) như một bản hack

Arrays.asList(files).stream()
    .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
    .sorted(new Comparator<File>() {
        public int compare(File o1, File o2) {
            int answer;
            if (o1.lastModified() == o2.lastModified()) {
                answer = 0;
            } else if (o1.lastModified() > o2.lastModified()) {
                answer = 1;
            } else {
                answer = -1;
            }
            return -1 * answer;
        }
    })
    .skip(numOfNewestToLeave)
    .forEach(item -> item.delete());

Bạn có thể điều chỉnh giải pháp bạn đã liên kết trong Cách sắp xếp ArrayList <Long> theo Java theo thứ tự giảm dần? bằng cách gói nó trong lambda:

.sorted((f1, f2) -> Long.compare(f2.lastModified(), f1.lastModified())

lưu ý rằng f2 là đối số đầu tiên Long.compare, không phải là đối số thứ hai, do đó kết quả sẽ bị đảo ngược.

Nếu các phần tử luồng của bạn thực hiện Comparablethì giải pháp sẽ trở nên đơn giản hơn:

 ...stream()
 .sorted(Comparator.reverseOrder())

Sử dụng

Comparator<File> comparator = Comparator.comparing(File::lastModified); 
Collections.sort(list, comparator.reversed());

Sau đó

.forEach(item -> item.delete());

Bạn có thể sử dụng một tham chiếu phương thức:

import static java.util.Comparator.*;
import static java.util.stream.Collectors.*;

Arrays.asList(files).stream()
    .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
    .sorted(comparing(File::lastModified).reversed())
    .skip(numOfNewestToLeave)
    .forEach(item -> item.delete());

Thay thế cho tham chiếu phương thức, bạn có thể sử dụng biểu thức lambda, do đó, đối số so sánh trở thành:

.sorted(comparing(file -> file.lastModified()).reversed());

Cách chia sẻ khác:

TĂNG DẦN

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName)).collect(Collectors.toList());

MÔ TẢ

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName).reversed()).collect(Collectors.toList());

Điều này có thể dễ dàng được thực hiện bằng cách sử dụng Java 8 và việc sử dụng Trình so sánh đảo ngược .

Tôi đã tạo một danh sách các tệp từ một thư mục mà tôi hiển thị chưa sắp xếp, sắp xếp và sắp xếp ngược lại bằng cách sử dụng Bộ so sánh đơn giản để sắp xếp và sau đó gọi đảo ngược () trên đó để lấy phiên bản đảo ngược của Bộ so sánh đó.

Xem mã dưới đây:

package test;

import java.io.File;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

public class SortTest {
    public static void main(String... args) {
        File directory = new File("C:/Media");
        File[] files = directory.listFiles();
        List<File> filesList = Arrays.asList(files);

        Comparator<File> comparator = Comparator.comparingLong(File::lastModified);
        Comparator<File> reverseComparator = comparator.reversed();

        List<File> forwardOrder = filesList.stream().sorted(comparator).collect(Collectors.toList());
        List<File> reverseOrder = filesList.stream().sorted(reverseComparator).collect(Collectors.toList());

        System.out.println("*** Unsorted ***");
        filesList.forEach(SortTest::processFile);

        System.out.println("*** Sort ***");
        forwardOrder.forEach(SortTest::processFile);

        System.out.println("*** Reverse Sort ***");
        reverseOrder.forEach(SortTest::processFile);
    }

    private static void processFile(File file) {
        try {
            if (file.isFile()) {
                System.out.println(file.getCanonicalPath() + " - " + new Date(file.lastModified()));
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Sắp xếp danh sách tệp với Bộ sưu tập java 8

Ví dụ về cách sử dụng Bộ sưu tập và Bộ so sánh Java 8 để sắp xếp danh sách Tệp.

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ShortFile {

    public static void main(String[] args) {
        List<File> fileList = new ArrayList<>();
        fileList.add(new File("infoSE-201904270100.txt"));
        fileList.add(new File("infoSE-201904280301.txt"));
        fileList.add(new File("infoSE-201904280101.txt"));
        fileList.add(new File("infoSE-201904270101.txt"));

        fileList.forEach(x -> System.out.println(x.getName()));
        Collections.sort(fileList, Comparator.comparing(File::getName).reversed());
        System.out.println("===========================================");
        fileList.forEach(x -> System.out.println(x.getName()));
    }
}

Nói một cách đơn giản, sử dụng Trình so sánh và Bộ sưu tập, bạn có thể sắp xếp như bên dưới theo thứ tự đảo ngược bằng JAVA 8

import java.util.Comparator;;
import java.util.stream.Collectors;

Arrays.asList(files).stream()
    .sorted(Comparator.comparing(File::getLastModified).reversed())
    .collect(Collectors.toList());

Để sắp xếp ngược lại, chỉ cần thay đổi thứ tự của x1, x2 để gọi phương thức x1.compareTo (x2), kết quả sẽ ngược lại với nhau

Thứ tự mặc định

List<String> sortedByName = citiesName.stream().sorted((s1,s2)->s1.compareTo(s2)).collect(Collectors.toList());
System.out.println("Sorted by Name : "+ sortedByName);

Đặt hàng ngược

List<String> reverseSortedByName = citiesName.stream().sorted((s1,s2)->s2.compareTo(s1)).collect(Collectors.toList());
System.out.println("Reverse Sorted by Name : "+ reverseSortedByName );