java8中的map怎么根據value值進行排序

本篇文章給大家分享的是有關java8中的map怎么根據value值進行排序，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

實現代碼如下：

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.LinkedHashMap;
 
public class MapSorted{
 
  public static void main(String[] args) {
    
    Map<String, Integer> map = new HashMap<>();
    map.put("A", 3);
    map.put("B", 5);
    map.put("C", 1);
    map.put("D", 1);
    map.put("E", 9);
    
    System.out.println(map);
 
    //如果value為java對象，則需要實現Comparable接口，重寫compareTo方法
 
    Map<String, Integer> sortedMap = new LinkedHashMap<>();
    Map<String, Integer> sortedMap2 = new LinkedHashMap<>();
 
    //ASC
    map.entrySet().stream()
      .sorted(Map.Entry.<String, Integer>comparingByValue())
      .forEachOrdered(x -> sortedMap.put(x.getKey(), x.getValue()));
 
    System.out.println(sortedMap);
 
    //DESC Collections.reverseOrder || reversed()
    map.entrySet().stream()
    .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
    .forEachOrdered(x -> sortedMap2.put(x.getKey(), x.getValue()));
 
    // map.entrySet().stream()
    // .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    // .forEachOrdered(x -> sortedMap2.put(x.getKey(), x.getValue()));
 
    System.out.println(sortedMap2);
 
    //Collectors.toMap 直接返回排好序的map
    map =  map.entrySet().stream()
          .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
          .collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue(), (x1, x2) -> x2, LinkedHashMap::new));
    
    // map =  map.entrySet().stream()
    // .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
    // .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x1, x2) -> x2, LinkedHashMap::new));
    System.out.println(map);
  }
}

{A=3, B=5, C=1, D=1, E=9}
{C=1, D=1, A=3, B=5, E=9}
{E=9, B=5, A=3, C=1, D=1}
{E=9, B=5, A=3, C=1, D=1}

補充知識：對BeanCopier拷貝對象中List類型屬性的思考

背景

最近開發接口過程中,使用BeanCopier拷貝對象,當對象中嵌套自定義對象類型屬性的時候,

如果對象名稱一致，但是對象類型不一致，拷貝的時候，該屬性是會被忽略的，但是當對象中嵌套List集合類型屬性(集合中是不同的對象類型)時，使用BeanCopier拷貝之后，返回給前臺的數據是正確的，感覺不太懂其中的原理，就測試了下。

測試過程

新建幾個對象

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ClassA {
  private String id;
  private String name;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ClassB {
  private String id;
  private String name;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BeanA {
  private String name;
  private List<ClassA> aList;
}F
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BeanA1 {
  private String name;
  private ClassA className;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BeanB {
  private String name;
  private List<ClassB> aList;
}
Data
@NoArgsConstructor
@AllArgsConstructor
public class BeanB1 {
  private String name;
  private ClassB className;
}

拷貝BeanA1到BeanB1

public static void main(String[] args) {
  /**
   * 將cglib生成的代理類的class文件打印到指定目錄
   */
  System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/haiyoung/logs");
  BeanA1 beanA1 = new BeanA1();
  beanA1.setName("aaa");
  beanA1.setClassName(new ClassA("001", "001"));
  BeanB1 beanB1 = new BeanB1();
  BeanCopier beanCopier = BeanCopier.create(BeanA1.class, BeanB1.class,false);
  beanCopier.copy(beanA1, beanB1,null);
  System.out.println(beanB1);
}

轉換結果如下圖所示：對象類型被忽略

cglib生成的代理類如下所示

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.cglib.empty;
import com.haiyoung.hyweb.beanCopier.BeanA1;
import com.haiyoung.hyweb.beanCopier.BeanB1;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;
public class Object$$BeanCopierByCGLIB$$c00337e1 extends BeanCopier {
  public Object$$BeanCopierByCGLIB$$c00337e1() {
  }
  public void copy(Object var1, Object var2, Converter var3) {
    ((BeanB1)var2).setName(((BeanA1)var1).getName());
  }
}

從copy實現代碼中可以看到，不同對象類型屬性間的拷貝被忽略

拷貝BeanA到BeanB

public static void main(String[] args) {
    /**
     * 將cglib生成的代理類的class文件打印到指定目錄
     */
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/haiyoung/logs");
    BeanA beanA = new BeanA();
    beanA.setName("aaa");
    List<ClassA> list = new ArrayList<>();
    list.add(new ClassA("001", "001"));
    beanA.setAList(list);
    BeanB beanB = new BeanB();
    BeanCopier beanCopier = BeanCopier.create(BeanA.class, BeanB.class,false);
    beanCopier.copy(beanA, beanB,null);
    System.out.println(beanB);
    List<ClassB> list1 = beanB.getAList();
    System.out.println(list1);
//    ClassB classB = list1.get(0);
//
//    System.out.println(classB);
  }

轉換結果如下圖所示,list對象類型屬性被成功賦值

但是對象beanA和benaB中的List屬性，指向相同的引用，當用ClassB接收beanB中的List屬性中的對象時，

會報對象強轉失敗

Exception in thread "main" [ClassA(id=001, name=001)]
java.lang.ClassCastException: com.haiyoung.hyweb.beanCopier.ClassA cannot be cast to com.haiyoung.hyweb.beanCopier.ClassB
 at com.haiyoung.hyweb.beanCopier.CopyTest.main(CopyTest.java:44)

cglib生成的代理類如下所示

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.cglib.empty;
import com.haiyoung.hyweb.beanCopier.BeanA;
import com.haiyoung.hyweb.beanCopier.BeanB;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;
public class Object$$BeanCopierByCGLIB$$27129331 extends BeanCopier {
  public Object$$BeanCopierByCGLIB$$27129331() {
  }
  public void copy(Object var1, Object var2, Converter var3) {
    BeanB var10000 = (BeanB)var2;
    BeanA var10001 = (BeanA)var1;
    var10000.setAList(((BeanA)var1).getAList());
    var10000.setName(var10001.getName());
  }
}

從copy的實現代碼中可以看到，兩個對象中的List類型的對象集合屬性被成功賦值，但是是引用賦值

結論

BeanCopier對不同對象中的List對象集合類型的屬性的拷貝是弱拷貝，而不是深拷貝，如果只是做對象拷貝，然后直接拋出這個對象給前臺使用是沒有問題的，但是如果這個通過拷貝得到的對象要在代碼中進行業務流轉，則會報java.lang.ClassCastException 類強轉異常

以上就是java8中的map怎么根據value值進行排序，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。