Bir akışı ters sırada sıralamak için Java8 lambda nasıl kullanılır?

Question

Bir listeyi sıralamak için java lambda kullanıyorum.

Tersine nasıl sıralayabilirim?

Bu post'u gördüm, ancak java 8 lambda kullanmak istiyorum. İşte

benim kodudur olarak kesmek (kullandığım * -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()); 

Answer 1

Bir lambda sararak size How to sort ArrayList<Long> in Java in decreasing order? bağlantılı çözüm uyarlayabilir:

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

f2'un Long.compare ilk argümanı olduğunu unutmayın, ikinci değil, sonuç tersine çevrilir.

Answer 2

Kullanım

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

Sonra

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

Answer 3

Bir yöntem başvuru kullanabilirsiniz:

Bir lambda ifade kullanabilirsiniz yöntem referans alternatif

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

, bu nedenle argüman arasında Karşılaştırma

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

Answer 4

BTW: Akışınızın elemanları daha sonra Comparable uygulaması halinde basit hale geldi:

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

Answer 5

Bu kolayca Java 8 ve ters Comparator kullanımını kullanılarak yapılabilir.

Sıralama için basit bir Karşılaştırıcı kullanarak sıralanmış, sıralı olarak sıralanmış ve tersine çevirilmiş bir dizinin bir listesini oluşturdum.

aşağıda

bakınız kodu:

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

Answer 6

Alternatif yolu paylaşımı:

ASC

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

DESC

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