import java.util.TreeMap;
public class MapSortByKey {
    public static void main(String[] args) {
        // 1. TreeMap 默認(rèn)按鍵自然升序排序（鍵是 Integer 類型，可比較）
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(3, "蘋果");
        treeMap.put(1, "香蕉");
        treeMap.put(2, "橘子");
        System.out.println("TreeMap 默認(rèn)按鍵升序：" + 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() 實(shí)現(xiàn)鍵降序
        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;
    // 構(gòu)造方法、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. 按鍵排序：步驟
        // ① 取出所有鍵，轉(zhuǎn)成 List
        List<Integer> keyList = new ArrayList<>(hashMap.keySet());
        // ② 對(duì)鍵 List 排序（升序，默認(rèn)）
        Collections.sort(keyList);
        // ③ （可選）降序排序：Collections.sort(keyList, Comparator.reverseOrder());
        // 3. 遍歷排序后的鍵，輸出結(jié)果（保持排序后的順序）
        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. 按值排序：步驟
        // ① 取出所有鍵值對(duì)，轉(zhuǎn)成 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. （可選）轉(zhuǎn)成 LinkedHashMap 保留排序順序（方便后續(xù)使用）
        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（鍵：編號(hào)，值：User 對(duì)象）
        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. 輸出結(jié)果
        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}
    }
}