import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTraversalDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "張三");
        map.put("age", "20");
        map.put("gender", "男");
        // 方式1：遍歷所有Key，通過(guò)Key獲取Value
        System.out.println("方式1：遍歷Key獲取Value");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }
        // 方式2：遍歷所有鍵值對(duì)（Map.Entry）
        System.out.println("\n方式2：遍歷Map.Entry");
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        // 方式3：JDK8+ Lambda表達(dá)式遍歷
        System.out.println("\n方式3：Lambda表達(dá)式遍歷");
        map.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.HashMap;
import java.util.Map;
public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        // 1. 添加鍵值對(duì)
        hashMap.put("語(yǔ)文", 90);
        hashMap.put("數(shù)學(xué)", 95);
        hashMap.put("英語(yǔ)", 92);
        hashMap.put("數(shù)學(xué)", 100); // Key重復(fù)，覆蓋原有Value
        System.out.println("HashMap內(nèi)容：" + hashMap);
        // 2. 根據(jù)Key獲取Value
        Integer mathScore = hashMap.get("數(shù)學(xué)");
        System.out.println("數(shù)學(xué)成績(jī)：" + mathScore);
        // 3. 判斷是否包含指定Key或Value
        boolean hasEnglish = hashMap.containsKey("英語(yǔ)");
        boolean has90 = hashMap.containsValue(90);
        System.out.println("包含英語(yǔ)Key：" + hasEnglish);
        System.out.println("包含90分Value：" + has90);
        // 4. 刪除鍵值對(duì)
        hashMap.remove("語(yǔ)文");
        System.out.println("刪除語(yǔ)文后的HashMap：" + hashMap);
        // 5. 獲取集合大小
        int size = hashMap.size();
        System.out.println("HashMap大小：" + size);
        // 6. 清空集合
        hashMap.clear();
        System.out.println("清空后是否為空：" + hashMap.isEmpty());
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
class Student {
    private String id;
    private String name;
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
    // 重寫(xiě)equals方法：根據(jù)學(xué)號(hào)判斷Key是否相同
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }
    // 重寫(xiě)hashCode方法：根據(jù)學(xué)號(hào)計(jì)算哈希值
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
    @Override
    public String toString() {
        return "Student{id='" + id + "', name='" + name + "'}";
    }
}
public class HashMapCustomKeyDemo {
    public static void main(String[] args) {
        Map<Student, String> studentMap = new HashMap<>();
        Student s1 = new Student("001", "張三");
        Student s2 = new Student("002", "李四");
        Student s3 = new Student("001", "張三"); // 與s1學(xué)號(hào)相同
        studentMap.put(s1, "一班");
        studentMap.put(s2, "二班");
        studentMap.put(s3, "三班"); // Key重復(fù)，覆蓋s1的Value
        // 遍歷輸出
        studentMap.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapInsertOrderDemo {
    public static void main(String[] args) {
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("b", "B");
        linkedHashMap.put("a", "A");
        linkedHashMap.put("c", "C");
        // 遍歷順序與插入順序一致
        linkedHashMap.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapAccessOrderDemo {
    public static void main(String[] args) {
        // 開(kāi)啟訪問(wèn)順序模式：accessOrder = true
        Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
        linkedHashMap.put("a", "A");
        linkedHashMap.put("b", "B");
        linkedHashMap.put("c", "C");
        System.out.println("初始順序：");
        linkedHashMap.forEach((key, value) -> System.out.println(key + "=" + value));
        // 訪問(wèn)元素a，觸發(fā)訪問(wèn)順序調(diào)整
        linkedHashMap.get("a");
        System.out.println("\n訪問(wèn)元素a后的順序：");
        linkedHashMap.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.Map;
import java.util.TreeMap;
public class TreeMapNaturalSortDemo {
    public static void main(String[] args) {
        Map<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(3, "C");
        treeMap.put(1, "A");
        treeMap.put(2, "B");
        // 自動(dòng)按Key升序排列
        treeMap.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapCustomSortDemo {
    public static void main(String[] args) {
        // 傳入比較器，實(shí)現(xiàn)Key降序排列
        Map<String, Integer> treeMap = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1); // 降序排列
            }
        });
        treeMap.put("Java", 10);
        treeMap.put("Python", 8);
        treeMap.put("Go", 9);
        treeMap.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        // 多線程環(huán)境下安全操作
        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                concurrentMap.put("thread1_" + i, i);
            }
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                concurrentMap.put("thread2_" + i, i);
            }
        }).start();
        // 等待線程執(zhí)行完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ConcurrentHashMap大小：" + concurrentMap.size());
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
/**
 * 基于LinkedHashMap實(shí)現(xiàn)的LRU緩存
 */
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    // 緩存最大容量
    private final int maxCapacity;
    // 構(gòu)造方法：開(kāi)啟訪問(wèn)順序模式
    public LRUCache(int maxCapacity) {
        super(16, 0.75f, true);
        this.maxCapacity = maxCapacity;
    }
    /**
     * 重寫(xiě)該方法，自定義淘汰規(guī)則
     * @param eldest 最久未使用的元素
     * @return true表示淘汰該元素，false表示不淘汰
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 當(dāng)元素個(gè)數(shù)超過(guò)最大容量時(shí)，淘汰最久未使用的元素
        return size() > maxCapacity;
    }
    // 測(cè)試方法
    public static void main(String[] args) {
        LRUCache<String, Integer> cache = new LRUCache<>(3);
        // 添加緩存元素
        cache.put("A", 1);
        cache.put("B", 2);
        cache.put("C", 3);
        System.out.println("初始緩存：" + cache);
        // 訪問(wèn)元素A，調(diào)整訪問(wèn)順序
        cache.get("A");
        System.out.println("訪問(wèn)A后的緩存：" + cache);
        // 添加元素D，超出容量，淘汰最久未使用的B
        cache.put("D", 4);
        System.out.println("添加D后的緩存：" + cache);
    }
}