import java.util.*;

public class MapDefaultMethodsDemo {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apple", 10);
        stock.put("banana", 3);

        // 1. getOrDefault：取不到就返回默认值，不改变 Map 本身
        int pear = stock.getOrDefault("pear", 0);
        System.out.println("pear = " + pear);                 // 0
        System.out.println("map 未被修改: " + stock);          // {banana=3, apple=10}

        // 2. putIfAbsent：仅当 key 不存在（或映射为 null）时才写入
        stock.putIfAbsent("apple", 99);    // 已存在，不生效
        stock.putIfAbsent("orange", 7);    // 不存在，写入
        System.out.println(stock);         // {banana=3, orange=7, apple=10}

        // 3. computeIfAbsent：key 不存在时，用函数计算 value 并写入；返回当前 value
        //    经典用法：Map<String, List<T>> 的自动初始化，替代三层 if
        Map<String, List<String>> index = new HashMap<>();
        index.computeIfAbsent("java", k -> new ArrayList<>()).add("HashMap");
        index.computeIfAbsent("java", k -> new ArrayList<>()).add("TreeMap");
        index.computeIfAbsent("go",   k -> new ArrayList<>()).add("goroutine");
        System.out.println(index);         // {java=[HashMap, TreeMap], go=[goroutine]}

        // 4. compute：无论 key 是否存在，都用函数重算 value；返回 null 则删除该映射
        stock.compute("banana", (k, v) -> v == null ? 1 : v * 2);   // 3 -> 6
        stock.compute("pear",   (k, v) -> null);                    // 返回 null，不插入
        System.out.println(stock.containsKey("pear"));              // false

        // 5. merge：把新值与旧值按函数合并；key 不存在则直接放入新值
        stock.merge("apple", 5, Integer::sum);   // 10 + 5 = 15
        stock.merge("grape", 5, Integer::sum);   // 不存在，直接放 5

        // 6. forEach：BiConsumer 遍历，比 entrySet + for 更简洁，且局部变量更少
        stock.forEach((k, v) -> System.out.println(k + " -> " + v));

        // 7. replace 系列：仅在 key 已存在时才替换
        stock.replace("apple", 20);
        stock.replace("apple", 20, 30);   // 旧值必须是 20 才替换为 30
    }
}

import java.util.*;
import java.util.stream.*;

public class WordCounter {
    public static void main(String[] args) {
        String text = "java java hashmap tree hashmap java map tree";

        // 写法一：merge，最简洁，无装箱拆箱之外的额外开销
        Map<String, Integer> freq = new HashMap<>();
        for (String w : text.split(" ")) {
            freq.merge(w, 1, Integer::sum);
        }
        System.out.println(freq);   // {java=3, hashmap=2, tree=2, map=1}

        // 写法二：Stream API 的 groupingBy，内部同样依赖 merge
        Map<String, Long> freq2 = Arrays.stream(text.split(" "))
                .collect(Collectors.groupingBy(s -> s, Collectors.counting()));
        System.out.println(freq2);

        // 写法三：找出频次最高的词
        freq.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .ifPresent(e -> System.out.println("TOP: " + e.getKey() + " x " + e.getValue()));
    }
}

// java.util.HashMap#hash，JDK 8 / JDK 17 完全一致
static final int hash(Object key) {
    int h;
    // key 为 null 时 hash 固定为 0，这就是为什么 HashMap 允许一个 null key
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public class HashDisturbDemo {
    public static void main(String[] args) {
        // 构造一批"只有高位不同"的 hashCode：低 16 位全是 0
        int[] codes = new int[8];
        for (int i = 0; i < codes.length; i++) {
            codes[i] = (i << 28);   // 高 4 位变化，低 28 位为 0
        }

        int n = 16;                 // 初始容量
        System.out.println("== 无扰动：直接 (n-1) & hashCode ==");
        for (int c : codes) {
            System.out.printf("hashCode=%08x  index=%d%n", c, (n - 1) & c);
        }
        // 输出全部是 index=0 → 8 个元素全挤在一个槽，退化成链表

        System.out.println("== 有扰动：(n-1) & (h ^ (h>>>16)) ==");
        for (int c : codes) {
            int h = c ^ (c >>> 16);
            System.out.printf("hashCode=%08x  hash=%08x  index=%d%n", c, h, (n - 1) & h);
        }
        // 分布到 0,1,2,3... 不同槽位，冲突消失
    }
}

h & (2^k - 1) = (q·2^k + r) & (2^k - 1) = r = h mod 2^k

// java.util.HashMap 静态常量与实例字段（节选，JDK 8）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;      // 默认初始容量 16
static final int MAXIMUM_CAPACITY = 1 << 30;             // 最大容量 2^30
static final float DEFAULT_LOAD_FACTOR = 0.75f;          // 默认装载因子

static final int TREEIFY_THRESHOLD = 8;                  // 链表长度 >= 8 时考虑树化
static final int UNTREEIFY_THRESHOLD = 6;                // 树中节点 <= 6 时退化为链表
static final int MIN_TREEIFY_CAPACITY = 64;              // 树化的最小表容量，否则优先扩容

transient Node<K,V>[] table;        // 哈希桶数组，长度恒为 2 的幂
transient Set<Map.Entry<K,V>> entrySet;
transient int size;                 // 实际键值对个数
transient int modCount;             // 结构化修改次数，用于 fail-fast
int threshold;                      // 扩容阈值 = capacity * loadFactor
final float loadFactor;             // 装载因子，final 一经构造不可变

static final int tableSizeFor(int cap) {
    int n = cap - 1;          // 先减 1：保证 cap 本身是 2 的幂时结果仍是 cap，而不是翻倍
    n |= n >>> 1;             // 最高位 1 向右扩散 1 位 → 连续 2 个 1
    n |= n >>> 2;             // 再扩散 2 位               → 连续 4 个 1
    n |= n >>> 4;             // 再扩散 4 位               → 连续 8 个 1
    n |= n >>> 8;             //                          → 连续 16 个 1
    n |= n >>> 16;            //                          → 连续 32 个 1
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

public class TableSizeForDemo {
    static int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16;
        return (n < 0) ? 1 : (n >= (1 << 30)) ? (1 << 30) : n + 1;
    }
    public static void main(String[] args) {
        int[] inputs = {0, 1, 3, 7, 8, 9, 12, 16, 17, 1000, 1 << 30};
        for (int c : inputs) {
            System.out.printf("cap=%-10d -> tableSizeFor=%-10d %s%n",
                    c, tableSizeFor(c), Integer.toBinaryString(tableSizeFor(c)));
        }
        // cap=9 -> 16(10000)；cap=16 -> 16(10000)；cap=17 -> 32(100000)
    }
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;

    // 【步骤 1】表为空或长度为 0 → 先扩容（懒初始化就发生在这里）
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    // 【步骤 2】目标槽位为空 → 直接新建节点放进去，无冲突，最快路径
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);

    else {   // 【步骤 3】槽位非空，发生冲突
        Node<K,V> e; K k;

        // 3.1 先看桶中第一个节点是不是就是要找的 key
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;

        // 3.2 若是红黑树节点，走树的插入逻辑
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>) p).putTreeVal(this, tab, hash, key, value);

        // 3.3 否则是链表：从第二个节点开始逐个遍历
        else {
            for (int binCount = 0; ; ++binCount) {
                // 遍历到尾部仍没找到 → 尾插法插入新节点（JDK 8 改为尾插）
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // binCount 从 0 起，插入后链表长度为 binCount+2；
                    // 当 binCount >= 7 即链表长度达到 9 时触发 treeifyBin（内部还会判断 64）
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                // 找到相同 key，跳出循环，交给下面的覆盖逻辑
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }

        // 【步骤 4】e != null 说明是"覆盖"而非"新增"
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);      // LinkedHashMap 的钩子：访问序维护
            return oldValue;         // 返回旧值，这是 put 返回值的来源
        }
    }

    // 【步骤 5】新增节点，结构化修改 + 判断是否需要扩容
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);       // LinkedHashMap 的钩子：淘汰最老节点
    return null;                     // 新增返回 null
}

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 表容量还不到 64：优先扩容而不是树化
    // 因为小表上链表长多半是"容量太小"造成的，扩容能直接把链拆开，代价更低
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {   // 第一步：把普通 Node 逐个替换为 TreeNode，仍保持链表形态（prev/next）
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null) hd = p;
            else { p.prev = tl; tl.next = p; }
            tl = p;
        } while ((e = e.next) != null);
        // 第二步：真正把这条双向链表转换成红黑树
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

// java.util.HashMap#resize（链表拆分部分，节选）
else { // preserve order —— 保持链表原有相对顺序
    Node<K,V> loHead = null, loTail = null;   // 低位链：留在原下标 j
    Node<K,V> hiHead = null, hiTail = null;   // 高位链：迁到新下标 j + oldCap
    Node<K,V> next;
    do {
        next = e.next;
        // 关键判断：hash 在 oldCap 那一位上是 0 还是 1
        if ((e.hash & oldCap) == 0) {
            if (loTail == null) loHead = e; else loTail.next = e;
            loTail = e;
        } else {
            if (hiTail == null) hiHead = e; else hiTail.next = e;
            hiTail = e;
        }
    } while ((e = next) != null);

    if (loTail != null) { loTail.next = null; newTab[j] = loHead; }
    if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; }
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {

        // 1. 先检查桶头，命中率最高（多数桶只有 1 个元素）
        if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            return first;

        if ((e = first.next) != null) {
            // 2. 红黑树走 O(log n) 查找
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>) first).getTreeNode(hash, key);
            // 3. 链表线性遍历
            do {
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

// JDK 7 java.util.HashMap#transfer（已废弃，仅用于说明问题）
void transfer(Entry<K,V>[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {          // 遍历旧表每个桶
        while (null != e) {
            Entry<K,V> next = e.next;      // ① 记住下一个
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];          // ② 头插：新节点指向桶中原头节点
            newTable[i] = e;               // ③ 新节点成为桶头
            e = next;                      // ④ 处理下一个
        }
    }
}

import java.util.*;

public class MutableKeyDisaster {
    static class User {
        int id;
        String name;
        User(int id, String name) { this.id = id; this.name = name; }
        @Override public int hashCode() { return Objects.hash(id, name); }
        @Override public boolean equals(Object o) {
            if (!(o instanceof User)) return false;
            User u = (User) o;
            return u.id == this.id && Objects.equals(u.name, this.name);
        }
        @Override public String toString() { return "User{id=" + id + ", name='" + name + "'}"; }
    }

    public static void main(String[] args) {
        Map<User, String> map = new HashMap<>();
        User u = new User(1, "Tom");
        map.put(u, "VIP");

        System.out.println("修改前 get: " + map.get(u));   // VIP
        System.out.println("修改前 containsKey: " + map.containsKey(u)); // true

        u.id = 2;   // 修改了参与 hashCode 计算的字段！

        System.out.println("修改后 get: " + map.get(u));   // null —— 找不到了
        System.out.println("修改后 containsKey: " + map.containsKey(u)); // false
        System.out.println("size 仍是: " + map.size());    // 1 —— 元素还在，但永远访问不到
        System.out.println("map.remove(u) 返回: " + map.remove(u)); // null，删不掉 → 内存泄漏
        System.out.println("remove 后 size: " + map.size());        // 仍然是 1
    }
}

import java.util.*;

public class EqualsHashCodeContract {
    /** 只重写 equals 的错误示范 */
    static class BadKey {
        int id;
        BadKey(int id) { this.id = id; }
        @Override public boolean equals(Object o) {
            return o instanceof BadKey && ((BadKey) o).id == this.id;
        }
    }

    /** 正确示范：equals 与 hashCode 使用同一组字段 */
    static class GoodKey {
        private final int id;
        private final String name;
        GoodKey(int id, String name) { this.id = id; this.name = name; }
        @Override public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof GoodKey)) return false;
            GoodKey g = (GoodKey) o;
            return id == g.id && Objects.equals(name, g.name);
        }
        // 用 31 作为乘子：31 是奇素数，且 31*i 可被 JVM 优化为 (i<<5)-i
        @Override public int hashCode() {
            int result = Integer.hashCode(id);
            result = 31 * result + (name != null ? name.hashCode() : 0);
            return result;
        }
    }

    public static void main(String[] args) {
        Map<BadKey, String> bad = new HashMap<>();
        bad.put(new BadKey(1), "A");
        System.out.println("只重写 equals: " + bad.get(new BadKey(1)));   // null，错误！

        Map<GoodKey, String> good = new HashMap<>();
        good.put(new GoodKey(1, "Tom"), "A");
        System.out.println("equals+hashCode 全重写: " + good.get(new GoodKey(1, "Tom"))); // A
    }
}

import java.util.*;

public class TraversalBenchmark {
    public static void main(String[] args) {
        Map<Integer, Integer> map = new HashMap<>();
        int n = 2_000_000;
        for (int i = 0; i < n; i++) map.put(i, i);

        long sum = 0, t;

        // 方式一：keySet + get —— 最慢，多 N 次哈希查找
        t = System.currentTimeMillis(); sum = 0;
        for (Integer k : map.keySet()) sum += map.get(k);
        System.out.println("keySet+get:      " + (System.currentTimeMillis() - t) + "ms, sum=" + sum);

        // 方式二：entrySet + for-each —— 经典写法，推荐
        t = System.currentTimeMillis(); sum = 0;
        for (Map.Entry<Integer, Integer> e : map.entrySet()) sum += e.getKey() + e.getValue();
        System.out.println("entrySet:        " + (System.currentTimeMillis() - t) + "ms, sum=" + sum);

        // 方式三：forEach(BiConsumer) —— JDK 8，最快，无迭代器对象开销
        long[] box = {0};
        t = System.currentTimeMillis();
        map.forEach((k, v) -> box[0] += k + v);
        System.out.println("forEach:         " + (System.currentTimeMillis() - t) + "ms, sum=" + box[0]);

        // 方式四：Iterator 显式迭代 —— 与方式二等价，唯一支持安全 remove
        t = System.currentTimeMillis(); sum = 0;
        for (Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<Integer, Integer> e = it.next();
            sum += e.getValue();
            // it.remove();   // 只有迭代器的 remove 不会触发 ConcurrentModificationException
        }
        System.out.println("Iterator:        " + (System.currentTimeMillis() - t) + "ms, sum=" + sum);
    }
}

public class InitialCapacity {
    /**
     * 计算避免扩容的初始容量：使 capacity * 0.75 >= expectedSize
     * 即 capacity >= expectedSize / 0.75 = expectedSize * 4 / 3
     * HashMap 内部还会 tableSizeFor 向上取整到 2 的幂，所以这里直接给期望值即可
     */
    static int capacityFor(int expectedSize) {
        return (int) ((float) expectedSize / 0.75f + 1.0f);
    }

    public static void main(String[] args) {
        for (int n : new int[]{3, 12, 100, 1000, 10_000, 1_000_000}) {
            int cap = capacityFor(n);
            System.out.printf("expected=%-9d 建议 initialCapacity=%-9d 实际 table 长度=%d%n",
                    n, cap, Integer.highestOneBit(Math.max(1, cap - 1)) << 1);
        }
        // 注意：new HashMap<>(capacityFor(n)) 是"容量"，不是"元素个数"
        Map<String, String> m = new HashMap<>(capacityFor(1000));
    }
}

import java.util.*;

/**
 * 基于 LinkedHashMap 的固定容量 LRU 缓存
 * accessOrder=true：按访问顺序排序，get/put 都会把元素移到尾部
 */
public class LruCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;

    public LruCache(int maxSize) {
        // 第三个参数 accessOrder 必须为 true，否则是插入序（FIFO）而非访问序
        super((int) (maxSize / 0.75f) + 1, 0.75f, true);
        this.maxSize = maxSize;
    }

    /** 每次 put/putAll 后由 afterNodeInsertion 回调，返回 true 则淘汰头节点（最久未访问） */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize;
    }

    public static void main(String[] args) {
        LruCache<Integer, String> cache = new LruCache<>(3);
        cache.put(1, "Java");
        cache.put(2, "Python");
        cache.put(3, "Go");
        System.out.println(cache.keySet());   // [1, 2, 3]

        cache.get(1);                          // 访问 1，把它移到最新
        System.out.println(cache.keySet());   // [2, 3, 1]

        cache.put(4, "Rust");                  // 超出容量，淘汰最久未访问的 2
        System.out.println(cache.keySet());   // [3, 1, 4]

        cache.put(3, "Golang");                // 覆盖已存在的 key，也会刷新到尾部
        System.out.println(cache.keySet());   // [1, 4, 3]
    }
}

import java.util.*;

public class TreeMapRangeDemo {
    public static void main(String[] args) {
        NavigableMap<Integer, String> scores = new TreeMap<>();
        scores.put(95, "Alice");
        scores.put(72, "Bob");
        scores.put(88, "Carol");
        scores.put(60, "Dave");
        scores.put(100, "Eve");

        System.out.println("自然升序: " + scores);           // {60=Dave, 72=Bob, 88=Carol, 95=Alice, 100=Eve}

        // 端点访问
        System.out.println("firstKey: " + scores.firstKey());   // 60
        System.out.println("lastKey:  " + scores.lastKey());    // 100

        // 就近查找：floor <= key，ceiling >= key，lower < key，higher > key
        System.out.println("floorKey(85):   " + scores.floorKey(85));    // 72  最接近且 <= 85
        System.out.println("ceilingKey(85): " + scores.ceilingKey(85));  // 88  最接近且 >= 85
        System.out.println("lowerKey(88):   " + scores.lowerKey(88));    // 72  严格小于
        System.out.println("higherKey(88):  " + scores.higherKey(88));   // 95  严格大于

        // 范围视图（左闭右开，与原 Map 联动，是视图不是拷贝！）
        SortedMap<Integer, String> sub = scores.subMap(70, 95);
        System.out.println("[70,95): " + sub);                  // {72=Bob, 88=Carol}
        System.out.println("headMap(88): " + scores.headMap(88));   // 严格小于 88
        System.out.println("tailMap(88): " + scores.tailMap(88));   // 大于等于 88

        // 降序遍历与端点弹出
        System.out.println("降序: " + scores.descendingMap());
        System.out.println("pollFirstEntry: " + ((TreeMap<Integer, String>) scores).pollFirstEntry());

        // sub 是视图：修改视图会反映到原 Map，反之亦然；对视图越界写入会抛 IllegalArgumentException
        // sub.put(99, "Frank");  // IllegalArgumentException: key out of range
    }
}

import java.util.*;

public class TreeMapComparatorDemo {
    static class Student {
        String name; int score; int age;
        Student(String name, int score, int age) { this.name = name; this.score = score; this.age = age; }
        int getScore() { return score; }      // Comparator 的方法引用需要实例 getter
        int getAge()   { return age; }
        @Override public String toString() { return name + "(" + score + ")"; }
    }

    public static void main(String[] args) {
        // 定制排序：分数降序，分数相同按年龄升序
        Comparator<Student> cmp = Comparator
                .comparingInt(Student::getScore).reversed()
                .thenComparingInt(Student::getAge);

        NavigableMap<Student, Integer> rank = new TreeMap<>(cmp);
        rank.put(new Student("Alice", 95, 20), 1);
        rank.put(new Student("Bob", 95, 18), 2);
        rank.put(new Student("Carol", 88, 22), 3);

        rank.forEach((s, i) -> System.out.println(s + " -> rank " + i));
        // Alice(95) rank1, Bob(95) rank2, Carol(88) rank3 —— Bob 年龄小排在 Alice 之后？
        // 注意 reversed() 只作用于第一个比较器，thenComparing 的年龄仍是升序，
        // 所以同为 95 分时年龄小的 Bob 排在前面

        // 陷阱示范：Comparator 必须与 equals 保持一致
        // 若 cmp 认为 a == b（返回 0），TreeMap 会把它们视为同一个 key，
        // 即使 a.equals(b) 为 false，后 put 的会覆盖前者
        Map<Student, Integer> byNameOnly = new TreeMap<>(Comparator.comparing((Student s) -> s.name));
        byNameOnly.put(new Student("Alice", 95, 20), 1);
        byNameOnly.put(new Student("Alice", 60, 30), 2);   // 覆盖了上面那条
        System.out.println("size = " + byNameOnly.size());   // 1，而不是 2
    }
}

import java.util.*;

public class SynchronizedMapTrap {
    public static void main(String[] args) throws InterruptedException {
        Map<String, Integer> raw = new HashMap<>();
        Map<String, Integer> sync = Collections.synchronizedMap(raw);

        // 正确：单个操作是线程安全的（内部 synchronized(mutex)）
        sync.put("a", 1);

        // 陷阱一：复合操作（check-then-act）不是原子的，即使每个方法都加锁
        // 下面这段在并发下会覆盖：两个线程同时判断为 null，然后都 put
        if (sync.get("b") == null) {
            sync.put("b", 2);   // 非原子！
        }
        // 正确写法必须手动在 mutex 上加锁
        synchronized (sync) {
            if (sync.get("b") == null) {
                sync.put("b", 2);
            }
        }
        // 更简洁的正确写法：用并发容器
        ConcurrentHashMap<String, Integer> chm = new ConcurrentHashMap<>();
        chm.putIfAbsent("b", 2);
        chm.computeIfAbsent("c", k -> 3);

        // 陷阱二：迭代时仍必须手动同步，否则 ConcurrentModificationException
        // 官方 Javadoc 明确要求：
        synchronized (sync) {
            for (Map.Entry<String, Integer> e : sync.entrySet()) {
                System.out.println(e.getKey() + "=" + e.getValue());
            }
        }

        // 陷阱三：sync 与 raw 共享同一份数据，绕过 sync 直接操作 raw 就失去了保护
        raw.put("unsafe", 0);   // 危险！
    }
}

import java.util.concurrent.*;

public class ConcurrentMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Long> counter = new ConcurrentHashMap<>();

        // 单 key 计数：用 LongAdder / AtomicLong 避免 CAS 反复失败
        int threads = 8, loops = 100_000;
        CountDownLatch latch = new CountDownLatch(threads);
        for (int t = 0; t < threads; t++) {
            new Thread(() -> {
                for (int i = 0; i < loops; i++) {
                    // 推荐：LongAdder 分段累加，高并发下比 AtomicLong 快一个量级
                    counter.computeIfAbsent("pv", k -> 0L);
                    counter.merge("pv", 1L, Long::sum);
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("pv = " + counter.get("pv"));   // 800000，精确

        // 注意：ConcurrentHashMap 不允许 null key / null value
        // counter.put("x", null);   // NullPointerException
        // 原因：get 返回 null 必须能无歧义地表示"不存在"，这在并发下是必需的语义保证

        // 弱一致性迭代器：遍历期间允许并发修改，不会抛 CME，但可能看不到最新写入
        counter.forEach((k, v) -> System.out.println(k + "=" + v));
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Properties;

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Properties props = new Properties();
        props.setProperty("db.url", "jdbc:mysql://localhost:3306/test");
        props.setProperty("db.user", "root");
        props.setProperty("db.poolSize", "20");

        // 写出到文件（JDK 9+ 支持指定字符集，避免默认 ISO-8859-1 导致中文乱码）
        try (Writer w = new OutputStreamWriter(
                new FileOutputStream("app.properties"), StandardCharsets.UTF_8)) {
            props.store(w, "demo config");
        }

        // 从 classpath 读取
        try (InputStream in = PropertiesDemo.class.getClassLoader()
                .getResourceAsStream("app.properties")) {
            if (in != null) {
                props.load(new InputStreamReader(in, StandardCharsets.UTF_8));
                System.out.println(props.getProperty("db.url"));
                System.out.println(props.getProperty("db.poolSize", "10"));  // 带默认值
            }
        }
    }
}