Java8 lamda를 사용하여 스트림을 역순으로 정렬하려면 어떻게 해야 합니까?

Java8 lamda를 사용하여 스트림을 역순으로 정렬하려면 어떻게 해야 합니까?

자바 람다로 목록을 정리하고 있어요

어떻게 역순으로 분류할 수 있을까요?

이 글을 봤는데 java 8 lambda를 쓰고 싶어요.

여기 내 코드(* -1)가 해킹으로 사용되었습니다.

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());

Java에서 How to sort Array List <Long>에서 링크한 솔루션을 내림차순으로 적용할 수 있습니까?람다에 싸서:

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

f2가 첫 번째 인수라는 점에 주의해 주십시오.Long.compare두 번째가 아니기 때문에 결과는 반전됩니다.

스트림 요소가 구현된 경우Comparable솔루션이 심플해집니다.

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

사용하다

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

그리고나서

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

메서드 참조를 사용할 수 있습니다.

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());

방법 참조 대신 람다 식을 사용할 수 있으므로 비교 인수는 다음과 같습니다.

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

대체 방법 공유:

ASC

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

설명

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

간단히 말하면, 비교기와 수집을 사용하면 JAVA 8을 사용하여 다음과 같이 역순으로 정렬할 수 있습니다.

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

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

이는 Java 8과 역비교기를 사용하여 쉽게 수행할 수 있습니다.

디렉토리에서 파일 목록을 작성했습니다.이 목록은 정렬되지 않은 상태로 정렬되어 있고 정렬된 상태로 역순으로 정렬된 상태로 표시됩니다.이것에 대해서는, 심플한 컴퍼레이터를 사용하고, 그 컴퍼레이터의 역버전을 취득하기 위해서 reverse()를 호출합니다.

아래 코드 참조:

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());
        }
    }
}

Java 8 컬렉션을 사용하여 파일 목록 정렬

Collections and Comparator Java 8을 사용하여 파일 목록을 정렬하는 예.

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()));
    }
}

이 모든 복잡한 절차 대신 이 간단한 절차에서는 Lambda.sorted(Comparator.reverse Order)를 사용하여 역순으로 정렬할 수 있습니다.

Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(Comparator.reverseOrder()).skip(numOfNewestToLeave)
.forEach(item -> item.delete());

역순서의 경우 x1.compareTo(x2) 메서드를 호출하기 위한 x1, x2의 순서를 변경하기만 하면 결과는 서로 반대입니다.

디폴트 순서

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

역순서

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

다음과 같은 독자적인 논리로 Comparator를 정의할 수 있습니다.

private static final Comparator<UserResource> sortByLastLogin = (c1, c2) -> {
    if (Objects.isNull(c1.getLastLoggedin())) {
        return -1;
    } else if (Objects.isNull(c2.getLastLoggedin())) {
        return 1;
    }
    return c1.getLastLoggedin().compareTo(c2.getLastLoggedin());
};   

포어치 안에서 사용하는 방법은 다음과 같습니다.

list.stream()
     .sorted(sortCredentialsByLastLogin.reversed())
     .collect(Collectors.toList());

    //sort Stream in reverse oreder with using Lambda Expressrion.

    List<String> list = Arrays.asList("Ram","Rahul","Ravi","Vishal","Vaibhav","Rohit","Harit","Raghav","Shubhan");
    List<String> sortedListLambda = list.stream().sorted((x,y)->y.compareTo(x)).collect(Collectors.toList());
    System.out.println(sortedListLambda);

개체의 날짜 유형 속성을 기준으로 정렬하려면

public class Visit implements Serializable, Comparable<Visit>{
private static final long serialVersionUID = 4976278839883192037L;

private Date dos;

public Date getDos() {
    return dos;
}

public void setDos(Date dos) {
    this.dos = dos;
}

@Override
public int compareTo(Visit visit) {
    return this.getDos().compareTo(visit.getDos());
}

}

List<Visit> visits = getResults();//Method making the list
Collections.sort(visits, Collections.reverseOrder());//Reverser order

언급URL : https://stackoverflow.com/questions/28607191/how-to-use-a-java8-lambda-to-sort-a-stream-in-reverse-order