// HashMap: 最常用，基于哈希表，無序
Map<String, Integer> hashMap = new HashMap<>();

// TreeMap: 基于紅黑樹，按鍵的自然順序或Comparator排序
Map<String, Integer> treeMap = new TreeMap<>();

// LinkedHashMap: 保持插入順序
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();

// ConcurrentHashMap: 線程安全，用于并發(fā)環(huán)境
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

public class MapTraversalDemo {
    public static void main(String[] args) {
        // 創(chuàng)建并初始化Map
        Map<String, Integer> studentScores = new HashMap<>();
        studentScores.put("張三", 85);
        studentScores.put("李四", 92);
        studentScores.put("王五", 78);
        studentScores.put("趙六", 95);
        
        System.out.println("=== 使用keySet()遍歷 ===");
        
        // 遍歷方式1：增強(qiáng)for循環(huán)
        for (String name : studentScores.keySet()) {
            Integer score = studentScores.get(name);
            System.out.println("學(xué)生：" + name + "，成績(jī)：" + score);
        }
        
        System.out.println("\n=== 使用keySet()結(jié)合迭代器 ===");
        
        // 遍歷方式2：使用迭代器
        Iterator<String> iterator = studentScores.keySet().iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            Integer score = studentScores.get(name);
            System.out.println("學(xué)生：" + name + "，成績(jī)：" + score);
        }
    }
}

public class MapTraversalDemo {
    public static void main(String[] args) {
        Map<String, Integer> productPrices = new LinkedHashMap<>();
        productPrices.put("手機(jī)", 2999);
        productPrices.put("筆記本電腦", 6999);
        productPrices.put("耳機(jī)", 399);
        productPrices.put("智能手表", 1299);
        
        System.out.println("=== 使用entrySet()遍歷 ===");
        
        // 遍歷方式1：增強(qiáng)for循環(huán)（最常用）
        for (Map.Entry<String, Integer> entry : productPrices.entrySet()) {
            String product = entry.getKey();
            Integer price = entry.getValue();
            System.out.println("商品：" + product + "，價(jià)格：" + price + "元");
            
            // 可以直接修改值（不影響鍵）
            if (product.equals("耳機(jī)")) {
                entry.setValue(350); // 降價(jià)促銷
            }
        }
        
        System.out.println("\n=== 遍歷后查看修改結(jié)果 ===");
        System.out.println("耳機(jī)新價(jià)格：" + productPrices.get("耳機(jī)") + "元");
        
        System.out.println("\n=== 使用entrySet()迭代器（可安全刪除）===");
        
        // 遍歷方式2：使用迭代器（可在遍歷時(shí)刪除元素）
        Iterator<Map.Entry<String, Integer>> it = productPrices.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            if (entry.getValue() > 5000) {
                System.out.println("移除高價(jià)商品：" + entry.getKey());
                it.remove(); // 安全刪除當(dāng)前元素
            }
        }
        
        System.out.println("\n=== 刪除高價(jià)商品后剩余商品 ===");
        for (Map.Entry<String, Integer> entry : productPrices.entrySet()) {
            System.out.println("商品：" + entry.getKey() + "，價(jià)格：" + entry.getValue() + "元");
        }
    }
}

public class MapTraversalDemo {
    public static void main(String[] args) {
        Map<Integer, String> errorCodeMap = new HashMap<>();
        errorCodeMap.put(404, "頁(yè)面未找到");
        errorCodeMap.put(500, "服務(wù)器內(nèi)部錯(cuò)誤");
        errorCodeMap.put(200, "請(qǐng)求成功");
        errorCodeMap.put(403, "禁止訪問");
        
        System.out.println("=== 使用values()遍歷（只關(guān)心值）===");
        
        // 計(jì)算平均字符串長(zhǎng)度（假設(shè)值都是字符串）
        int totalLength = 0;
        for (String message : errorCodeMap.values()) {
            System.out.println("錯(cuò)誤信息：" + message);
            totalLength += message.length();
        }
        
        double avgLength = (double) totalLength / errorCodeMap.size();
        System.out.printf("\n錯(cuò)誤信息的平均長(zhǎng)度：%.2f 字符\n", avgLength);
        
        // 使用Stream API進(jìn)行統(tǒng)計(jì)（Java 8+）
        System.out.println("\n=== 使用Stream API處理值 ===");
        errorCodeMap.values().stream()
            .filter(msg -> msg.contains("錯(cuò)誤"))
            .forEach(System.out::println);
    }
}

import java.util.*;

public class MapTraversalDemo {
    public static void main(String[] args) {
        Map<String, Double> temperatureData = new TreeMap<>();
        temperatureData.put("北京", 22.5);
        temperatureData.put("上海", 25.3);
        temperatureData.put("廣州", 28.7);
        temperatureData.put("深圳", 29.1);
        temperatureData.put("哈爾濱", 15.8);
        
        System.out.println("=== 使用迭代器遍歷entrySet() ===");
        
        // 獲取entrySet的迭代器
        Iterator<Map.Entry<String, Double>> entryIterator = 
            temperatureData.entrySet().iterator();
        
        while (entryIterator.hasNext()) {
            Map.Entry<String, Double> entry = entryIterator.next();
            String city = entry.getKey();
            Double temp = entry.getValue();
            
            System.out.printf("城市：%s，溫度：%.1f℃\n", city, temp);
            
            // 刪除溫度低于20℃的記錄
            if (temp < 20.0) {
                entryIterator.remove();
                System.out.println("   -> 已刪除低溫記錄");
            }
        }
        
        System.out.println("\n=== 刪除低溫城市后 ===");
        for (Map.Entry<String, Double> entry : temperatureData.entrySet()) {
            System.out.printf("城市：%s，溫度：%.1f℃\n", 
                entry.getKey(), entry.getValue());
        }
        
        System.out.println("\n=== 使用迭代器遍歷keySet() ===");
        
        // 獲取keySet的迭代器
        Iterator<String> keyIterator = temperatureData.keySet().iterator();
        while (keyIterator.hasNext()) {
            String city = keyIterator.next();
            // 注意：這里仍然需要get()來獲取值
            System.out.println("城市：" + city);
        }
    }
}

import java.util.*;

public class MapTraversalDemo {
    public static void main(String[] args) {
        Map<String, List<String>> classStudents = new HashMap<>();
        classStudents.put("一班", Arrays.asList("張三", "李四", "王五"));
        classStudents.put("二班", Arrays.asList("趙六", "錢七", "孫八"));
        classStudents.put("三班", Arrays.asList("周九", "吳十", "鄭十一"));
        
        System.out.println("=== 使用forEach() + Lambda表達(dá)式 ===");
        
        // 基礎(chǔ)用法
        classStudents.forEach((className, students) -> {
            System.out.println("班級(jí)：" + className + "，學(xué)生人數(shù)：" + students.size());
        });
        
        System.out.println("\n=== 使用Lambda進(jìn)行復(fù)雜操作 ===");
        
        // 復(fù)雜操作：篩選并處理
        Map<String, Integer> result = new HashMap<>();
        
        classStudents.forEach((className, students) -> {
            // 篩選學(xué)生人數(shù)大于2的班級(jí)
            if (students.size() > 2) {
                // 計(jì)算名字長(zhǎng)度總和
                int totalNameLength = students.stream()
                    .mapToInt(String::length)
                    .sum();
                result.put(className, totalNameLength);
            }
        });
        
        System.out.println("篩選結(jié)果：" + result);
        
        System.out.println("\n=== 結(jié)合Stream API進(jìn)行過濾和映射 ===");
        
        // 使用entrySet()結(jié)合Stream API
        classStudents.entrySet().stream()
            .filter(entry -> entry.getKey().contains("一")) // 過濾鍵
            .sorted(Map.Entry.comparingByKey()) // 按鍵排序
            .forEach(entry -> {
                System.out.println("班級(jí)：" + entry.getKey());
                System.out.println("  學(xué)生：" + String.join(", ", entry.getValue()));
            });
        
        System.out.println("\n=== 并行流處理（大數(shù)據(jù)量?jī)?yōu)化）===");
        
        // 對(duì)于大數(shù)據(jù)量，可以使用并行流
        Map<String, Integer> studentCountMap = new ConcurrentHashMap<>();
        
        classStudents.entrySet().parallelStream()
            .forEach(entry -> {
                String className = entry.getKey();
                int count = entry.getValue().size();
                studentCountMap.put(className, count);
                System.out.println(Thread.currentThread().getName() + 
                    " 處理: " + className + " -> " + count);
            });
        
        System.out.println("各班級(jí)人數(shù)統(tǒng)計(jì)：" + studentCountMap);
    }
}

import java.util.*;

public class MapPerformanceTest {
    public static void main(String[] args) {
        // 準(zhǔn)備測(cè)試數(shù)據(jù)
        int size = 1000000;
        Map<Integer, String> testMap = new HashMap<>();
        
        for (int i = 0; i < size; i++) {
            testMap.put(i, "Value" + i);
        }
        
        System.out.println("測(cè)試Map大小: " + size + " 個(gè)元素\n");
        
        // 測(cè)試1: keySet()遍歷
        long startTime = System.nanoTime();
        for (Integer key : testMap.keySet()) {
            String value = testMap.get(key);
            // 模擬處理
            value.length();
        }
        long endTime = System.nanoTime();
        System.out.printf("keySet() 遍歷時(shí)間: %,d ns (%.2f ms)\n", 
            endTime - startTime, (endTime - startTime) / 1000000.0);
        
        // 測(cè)試2: entrySet()遍歷
        startTime = System.nanoTime();
        for (Map.Entry<Integer, String> entry : testMap.entrySet()) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            value.length();
        }
        endTime = System.nanoTime();
        System.out.printf("entrySet() 遍歷時(shí)間: %,d ns (%.2f ms)\n", 
            endTime - startTime, (endTime - startTime) / 1000000.0);
        
        // 測(cè)試3: values()遍歷
        startTime = System.nanoTime();
        for (String value : testMap.values()) {
            value.length();
        }
        endTime = System.nanoTime();
        System.out.printf("values() 遍歷時(shí)間: %,d ns (%.2f ms)\n", 
            endTime - startTime, (endTime - startTime) / 1000000.0);
        
        // 測(cè)試4: forEach + Lambda
        startTime = System.nanoTime();
        testMap.forEach((key, value) -> {
            value.length();
        });
        endTime = System.nanoTime();
        System.out.printf("forEach(Lambda) 時(shí)間: %,d ns (%.2f ms)\n", 
            endTime - startTime, (endTime - startTime) / 1000000.0);
        
        // 測(cè)試5: 并行流遍歷
        startTime = System.nanoTime();
        testMap.entrySet().parallelStream().forEach(entry -> {
            entry.getValue().length();
        });
        endTime = System.nanoTime();
        System.out.printf("并行流遍歷時(shí)間: %,d ns (%.2f ms)\n", 
            endTime - startTime, (endTime - startTime) / 1000000.0);
    }
}

// 推薦：entrySet() 或 forEach(Lambda)
for (Map.Entry<K, V> entry : map.entrySet()) {
    // 處理鍵值對(duì)
}

// 或（Java 8+）
map.forEach((key, value) -> {
    // 處理鍵值對(duì)
});

// 必須使用：entrySet()
for (Map.Entry<K, V> entry : map.entrySet()) {
    if (condition) {
        entry.setValue(newValue); // 直接修改值
    }
}

// 必須使用：迭代器
Iterator<Map.Entry<K, V>> it = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<K, V> entry = it.next();
    if (shouldRemove(entry)) {
        it.remove(); // 安全刪除
    }
}

// 推薦：values()
for (V value : map.values()) {
    // 只處理值
}

// 或結(jié)合Stream API
map.values().stream()
    .filter(value -> condition)
    .forEach(value -> process(value));

// 推薦：并行流
map.entrySet().parallelStream()
    .forEach(entry -> {
        // 并行處理每個(gè)鍵值對(duì)
    });

// 使用：keySet() 或 entrySet() + 迭代器
for (Map.Entry<K, V> entry : map.entrySet()) {
    // 兼容所有Java版本
}

// 或
Iterator<K> it = map.keySet().iterator();
while (it.hasNext()) {
    K key = it.next();
    V value = map.get(key);
}

// 錯(cuò)誤示例：在增強(qiáng)for循環(huán)中刪除元素
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    if (entry.getValue() < 0) {
        map.remove(entry.getKey()); // 拋出ConcurrentModificationException
    }
}

// 正確示例1：使用迭代器刪除
Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, Integer> entry = it.next();
    if (entry.getValue() < 0) {
        it.remove(); // 安全刪除
    }
}

// 正確示例2：Java 8+ 使用removeIf
map.entrySet().removeIf(entry -> entry.getValue() < 0);

// LinkedHashMap會(huì)保持插入順序
Map<String, Integer> orderedMap = new LinkedHashMap<>();
orderedMap.put("第一", 1);
orderedMap.put("第二", 2);
orderedMap.put("第三", 3);

// 遍歷時(shí)會(huì)按插入順序輸出
for (Map.Entry<String, Integer> entry : orderedMap.entrySet()) {
    System.out.println(entry.getKey()); // 輸出：第一、第二、第三
}

// TreeMap會(huì)按鍵的自然順序排序
Map<String, Integer> sortedMap = new TreeMap<>();
sortedMap.put("Banana", 3);
sortedMap.put("Apple", 5);
sortedMap.put("Cherry", 2);

// 遍歷時(shí)會(huì)按鍵排序輸出
for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
    System.out.println(entry.getKey()); // 輸出：Apple、Banana、Cherry
}

// 自定義排序
Map<String, Integer> customSortedMap = new TreeMap<>(
    Comparator.comparing(String::length).thenComparing(String::toString)
);

// 使用泛型確保類型安全
Map<String, List<Integer>> complexMap = new HashMap<>();

// 正確的類型聲明
for (Map.Entry<String, List<Integer>> entry : complexMap.entrySet()) {
    String key = entry.getKey();
    List<Integer> values = entry.getValue(); // 不需要強(qiáng)制轉(zhuǎn)換
    
    for (Integer num : values) {
        // 安全操作
    }
}

// 使用var（Java 10+）
for (var entry : complexMap.entrySet()) {
    var key = entry.getKey();
    var values = entry.getValue();
    // 編譯器推斷類型
}

// 1. 預(yù)分配容量（減少擴(kuò)容）
Map<String, Integer> map = new HashMap<>(1024); // 預(yù)分配容量

// 2. 避免在循環(huán)中調(diào)用size()
int size = map.size(); // 預(yù)先獲取
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    // 使用預(yù)先獲取的size
}

// 3. 使用局部變量
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    final String key = entry.getKey(); // 使用final提高可讀性
    final Integer value = entry.getValue();
    
    // 處理邏輯
}

// 4. 考慮使用并行流的閾值
if (map.size() > 10000) {
    // 大數(shù)據(jù)量使用并行流
    map.entrySet().parallelStream().forEach(entry -> {
        process(entry);
    });
} else {
    // 小數(shù)據(jù)量使用普通遍歷
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        process(entry);
    }
}

public class WordFrequencyCounter {
    public static void main(String[] args) {
        String text = "java is fun and java is powerful and java is popular";
        
        // 分割單詞并統(tǒng)計(jì)頻率
        Map<String, Integer> frequencyMap = new HashMap<>();
        String[] words = text.split("\\s+");
        
        for (String word : words) {
            frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);
        }
        
        System.out.println("=== 單詞頻率統(tǒng)計(jì) ===");
        
        // 按頻率排序并輸出
        frequencyMap.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .forEach(entry -> {
                System.out.printf("%-10s: %d次\n", entry.getKey(), entry.getValue());
            });
        
        // 找出最常出現(xiàn)的單詞
        Map.Entry<String, Integer> mostFrequent = frequencyMap.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .orElse(null);
            
        if (mostFrequent != null) {
            System.out.println("\n最常出現(xiàn)的單詞: " + 
                mostFrequent.getKey() + " (" + mostFrequent.getValue() + "次)");
        }
    }
}

import java.util.*;

public class SimpleLRUCache<K, V> {
    private final int capacity;
    private final LinkedHashMap<K, V> cache;
    
    public SimpleLRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new LinkedHashMap<K, V>(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        };
    }
    
    public V get(K key) {
        return cache.get(key);
    }
    
    public void put(K key, V value) {
        cache.put(key, value);
    }
    
    public void displayCache() {
        System.out.println("當(dāng)前緩存內(nèi)容（按訪問順序）：");
        
        // 使用entrySet遍歷，保持訪問順序
        int index = 1;
        for (Map.Entry<K, V> entry : cache.entrySet()) {
            System.out.printf("%d. Key: %s, Value: %s\n", 
                index++, entry.getKey(), entry.getValue());
        }
    }
    
    public static void main(String[] args) {
        SimpleLRUCache<String, String> cache = new SimpleLRUCache<>(3);
        
        cache.put("A", "數(shù)據(jù)A");
        cache.put("B", "數(shù)據(jù)B");
        cache.put("C", "數(shù)據(jù)C");
        
        cache.displayCache();
        
        // 訪問A，使其成為最近使用的
        cache.get("A");
        
        // 添加新數(shù)據(jù)，會(huì)淘汰最久未使用的B
        cache.put("D", "數(shù)據(jù)D");
        
        System.out.println("\n訪問A后添加D：");
        cache.displayCache();
    }
}

import java.util.*;

public class ConfigurationManager {
    private final Map<String, Object> configMap;
    
    public ConfigurationManager() {
        configMap = new TreeMap<>(); // 按鍵排序
        
        // 加載默認(rèn)配置
        loadDefaultConfig();
    }
    
    private void loadDefaultConfig() {
        configMap.put("app.name", "MyApplication");
        configMap.put("app.version", "1.0.0");
        configMap.put("database.url", "localhost:3306");
        configMap.put("database.username", "admin");
        configMap.put("cache.enabled", true);
        configMap.put("cache.size", 1024);
        configMap.put("log.level", "INFO");
    }
    
    public void displayConfigByCategory() {
        System.out.println("=== 應(yīng)用程序配置 ===");
        
        // 按配置類別分組顯示
        Map<String, List<String>> categorized = new HashMap<>();
        
        for (Map.Entry<String, Object> entry : configMap.entrySet()) {
            String key = entry.getKey();
            String category = key.split("\\.")[0]; // 獲取類別
            
            categorized.computeIfAbsent(category, k -> new ArrayList<>())
                      .add(key + " = " + entry.getValue());
        }
        
        // 按類別排序并顯示
        categorized.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .forEach(categoryEntry -> {
                System.out.println("\n[" + categoryEntry.getKey().toUpperCase() + "]");
                categoryEntry.getValue().forEach(System.out::println);
            });
    }
    
    public void updateConfig(String key, Object value) {
        if (configMap.containsKey(key)) {
            Object oldValue = configMap.get(key);
            configMap.put(key, value);
            System.out.printf("配置已更新: %s = %s (原值: %s)\n", 
                key, value, oldValue);
        } else {
            System.out.println("未知配置項(xiàng): " + key);
        }
    }
    
    public static void main(String[] args) {
        ConfigurationManager config = new ConfigurationManager();
        config.displayConfigByCategory();
        
        System.out.println("\n=== 更新配置 ===");
        config.updateConfig("log.level", "DEBUG");
        config.updateConfig("cache.size", 2048);
        
        System.out.println("\n=== 更新后的配置 ===");
        config.displayConfigByCategory();
    }
}