Java Map排序如何按照值按照键排序

import java.util.TreeMap;
public class MapSortByKey {
    public static void main(String[] args) {
        // 1. TreeMap 默认按键自然升序排序（键是 Integer 类型，可比较）
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(3, "苹果");
        treeMap.put(1, "香蕉");
        treeMap.put(2, "橘子");
        System.out.println("TreeMap 默认按键升序：" + treeMap);
        // 输出：{1=香蕉, 2=橘子, 3=苹果}（按键 1→2→3 排序）
    }
}

import java.util.Comparator;
import java.util.TreeMap;
public class MapSortByKeyDesc {
    public static void main(String[] args) {
        // 传入 Comparator.reverseOrder() 实现键降序
        TreeMap<Integer, String> treeMapDesc = new TreeMap<>(Comparator.reverseOrder());
        treeMapDesc.put(3, "苹果");
        treeMapDesc.put(1, "香蕉");
        treeMapDesc.put(2, "橘子");
        System.out.println("TreeMap 按键降序：" + treeMapDesc);
        // 输出：{3=苹果, 2=橘子, 1=香蕉}（按键 3→2→1 排序）
    }
}

import java.util.Comparator;
import java.util.TreeMap;
// 自定义 User 类（作为键）
class User {
    private int userId;
    private String name;
    // 构造方法、getter、toString（必须重写，否则打印乱码）
    public User(int userId, String name) {
        this.userId = userId;
        this.name = name;
    }
    public int getUserId() { return userId; }
    @Override
    public String toString() { return "User{userId=" + userId + ", name='" + name + "'}"; }
}
public class TreeMapCustomKey {
    public static void main(String[] args) {
        // 传入 Comparator，指定按 User 的 userId 升序排序
        TreeMap<User, String> userMap = new TreeMap<>(Comparator.comparingInt(User::getUserId));
        userMap.put(new User(2, "李四"), "部门A");
        userMap.put(new User(1, "张三"), "部门B");
        userMap.put(new User(3, "王五"), "部门C");
        System.out.println("TreeMap 按自定义键（userId）升序：" + userMap);
        // 输出：{User{userId=1, name='张三'}=部门B, User{userId=2, name='李四'}=部门A, User{userId=3, name='王五'}=部门C}
    }
}

import java.util.*;
public class HashMapSortByKey {
    public static void main(String[] args) {
        // 1. 初始化 HashMap（无序）
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(3, "苹果");
        hashMap.put(1, "香蕉");
        hashMap.put(2, "橘子");
        // 2. 按键排序：步骤
        // ① 取出所有键，转成 List
        List<Integer> keyList = new ArrayList<>(hashMap.keySet());
        // ② 对键 List 排序（升序，默认）
        Collections.sort(keyList);
        // ③ （可选）降序排序：Collections.sort(keyList, Comparator.reverseOrder());
        // 3. 遍历排序后的键，输出结果（保持排序后的顺序）
        System.out.println("HashMap 按键升序：");
        for (Integer key : keyList) {
            System.out.println(key + " → " + hashMap.get(key));
        }
        // 输出：
        // 1 → 香蕉
        // 2 → 橘子
        // 3 → 苹果
    }
}

import java.util.*;
public class MapSortByValue {
    public static void main(String[] args) {
        // 1. 初始化 HashMap（键：水果，值：销量）
        HashMap<String, Integer> fruitSales = new HashMap<>();
        fruitSales.put("苹果", 100);
        fruitSales.put("香蕉", 200);
        fruitSales.put("橘子", 150);
        // 2. 按值排序：步骤
        // ① 取出所有键值对，转成 List
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(fruitSales.entrySet());
        // ② 按值升序排序（销量从小到大）
        entryList.sort(Comparator.comparingInt(Map.Entry::getValue));
        System.out.println("按值（销量）升序：");
        entryList.forEach(entry -> System.out.println(entry.getKey() + " → " + entry.getValue()));
        // 输出：苹果→100，橘子→150，香蕉→200
        // ③ 按值降序排序（销量从大到小）
        entryList.sort((e1, e2) -> Integer.compare(e2.getValue(), e1.getValue()));
        // 简化写法：entryList.sort(Comparator.comparingInt(Map.Entry::getValue).reversed());
        System.out.println("\n按值（销量）降序：");
        entryList.forEach(entry -> System.out.println(entry.getKey() + " → " + entry.getValue()));
        // 输出：香蕉→200，橘子→150，苹果→100
        // 3. （可选）转成 LinkedHashMap 保留排序顺序（方便后续使用）
        LinkedHashMap<String, Integer> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<String, Integer> entry : entryList) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        System.out.println("\n排序后的 LinkedHashMap：" + sortedMap);
        // 输出：{香蕉=200, 橘子=150, 苹果=100}
    }
}

import java.util.*;
// 自定义 User 类（作为值）
class User {
    private String name;
    private int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public int getAge() { return age; }
    @Override
    public String toString() { return "User{name='" + name + "', age=" + age + "}"; }
}
public class MapSortByCustomValue {
    public static void main(String[] args) {
        // 1. 初始化 Map（键：编号，值：User 对象）
        HashMap<String, User> userMap = new HashMap<>();
        userMap.put("001", new User("张三", 25));
        userMap.put("002", new User("李四", 20));
        userMap.put("003", new User("王五", 30));
        // 2. 按 User 的 age 升序排序
        List<Map.Entry<String, User>> entryList = new ArrayList<>(userMap.entrySet());
        entryList.sort(Comparator.comparingInt(e -> e.getValue().getAge()));
        // 3. 输出结果
        System.out.println("按值（User.age）升序：");
        entryList.forEach(entry -> System.out.println(entry.getKey() + " → " + entry.getValue()));
        // 输出：
        // 002 → User{name='李四', age=20}
        // 001 → User{name='张三', age=25}
        // 003 → User{name='王五', age=30}
    }
}