Cách sắp xếp LinkedHashMap theo giá trị theo thứ tự giảm trong luồng java?

Question

Để sắp xếp nó int thứ tự tăng dần tôi có thể sử dụng:

myMap.entrySet().stream() 
    .sorted(Map.Entry.comparingByValue()) 
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); 

Làm thế nào tôi có thể làm điều đó trong thứ tự giảm dần?

Answer 1

Kể từ Java 1,8 java.util.Comparator.reversed()

myMap.entrySet().stream() 
.sorted(Map.Entry.comparingByValue().reversed()) 
.collect(Collectors.toMap(Entry::getKey, Entry::getValue)); 

Answer 2

Bạn có thể chuyển bất kỳ Bộ so sánh nào bạn muốn comparingByValue.

Ví dụ (Tôi hy vọng tôi có đúng cú pháp, vì tôi không thể kiểm tra nó):

myMap.entrySet().stream() 
    .sorted(Map.Entry.comparingByValue((v1,v2)->v2.compareTo(v1))) 
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); 

Bằng cách so sánh giá trị của hai mục theo thứ tự ngược lại, sử dụng thứ tự tự nhiên (Comparable 's compareTo), bạn nhận được một đơn đặt hàng đảo ngược so với những gì comparingByValue() (tương đương với comparingByValue((v1,v2)->v1.compareTo(v2))) sẽ cung cấp cho bạn.

BTW, tôi không chắc chắn rằng Collectors.toMap trả về phiên bản LinkedHashMap và ngay cả khi hiện tại, nó có thể thay đổi trong tương lai, vì Javadoc không đề cập đến nó, vì vậy bạn không thể dựa vào nó.

Để chắc chắn rằng bản đồ kết quả sẽ là một LinkedHashMap, bạn nên sử dụng một biến thể khác nhau của toMap:

myMap.entrySet().stream() 
    .sorted(Map.Entry.comparingByValue((v1,v2)->v2.compareTo(v1))) 
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (v1,v2)->v1, LinkedHashMap::new)); 

Answer 3

Để sắp xếp theo thứ tự đảo ngược, vượt qua Comparator.reverseOrder() như tham số để comparingByValue.

Để nhận được LinkedHashMap, bạn phải yêu cầu cụ thể một đối số có 4 đối số toMap(). Nếu bạn không chỉ định loại bản đồ bạn muốn, bạn sẽ nhận được bất kỳ giá trị mặc định nào, hiện đang xảy ra là HashMap. Vì HashMap không giữ nguyên thứ tự của các phần tử, nó chắc chắn sẽ không làm cho bạn.

myMap.entrySet().stream() 
     .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())) 
     .collect(Collectors.toMap(
       Map.Entry::getKey, 
       Map.Entry::getValue, 
       (x,y)-> {throw new AssertionError();}, 
       LinkedHashMap::new 
     )); 

Với nhập khẩu tĩnh, nó trở nên dễ chịu hơn một chút:

myMap.entrySet().stream() 
     .sorted(comparingByValue(reverseOrder())) 
     .collect(toMap(
       Map.Entry::getKey, 
       Map.Entry::getValue, 
       (x,y)-> {throw new AssertionError();}, 
       LinkedHashMap::new 
     )); 

Answer 4

Stream có như sorted phương pháp mà chấp nhận một so sánh do đó bạn có thể trực tiếp sử dụng so sánh như (x,y)->y.getKey().compareTo(x.getKey()) cho giảm dần phân loại. Để sắp xếp các đồ tăng dần chúng ta có thể đảo ngược thứ tự như (x,y)->x.getKey().compareTo(y.getKey())

cho việc củng cố kết quả trở lại vào LinkedHashMap chúng ta có thể sử dụng thu gom toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) mà Trả về một Collector mà tích tụ các yếu tố vào một bản đồ có khóa và giá trị là kết quả của việc áp dụng cung cấp chức năng lập bản đồ cho các yếu tố đầu vào.

đang làm việc

import java.io.*; 
import java.util.*; 
import java.util.function.*; 
import java.util.stream.Collectors; 
import java.util.stream.*; 
public class HelloWorld{ 

    public static void main(String []args){ 
     LinkedHashMap<Integer,Integer> hashMap = new LinkedHashMap<Integer,Integer>(); 
      hashMap.put(1,5); 
      hashMap.put(7,9); 
      hashMap.put(3,8); 
      hashMap.put(10,5); 

      Function<Map.Entry<Integer,Integer>,Integer> keyMapper = x->x.getKey(); 
      Function<Map.Entry<Integer,Integer>,Integer> valueMapper = x->x.getValue(); 
      BinaryOperator< Integer> mergeFunction = (x,y)->x;// we do not want any merging here 
      Supplier<LinkedHashMap<Integer,Integer>> mapRequired =()-> {return new LinkedHashMap<Integer,Integer>();};// to maintain order we must use LinkedHashMap 
      Comparator<Map.Entry<Integer,Integer>> descendingComparator = (x,y)->y.getKey().compareTo(x.getKey()); 
      // we can write it as 

     System.out.println(
        hashMap.entrySet().stream() 
          .sorted (descendingComparator) 
          .collect(Collectors.toMap(
                 keyMapper, 
                 valueMapper, 
                 mergeFunction, 
                 mapRequired) 
              ) 
       );   

// or even by writing below will also work 

     System.out.println(
        hashMap.entrySet().stream() 
          .sorted ((x,y)->y.getKey().compareTo(x.getKey())) 
          .collect(Collectors.toMap(
                 x->x.getKey(), 
                 x->x.getValue(), 
                 (x,y)->x, 
                 LinkedHashMap::new) 
              ) 
       );   
    } 


}