Java Map 計算方法完整指南：高效能數據操作與最佳實踐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.example.mapcompute;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class MapComputeExample {
    
    public static void main(String[] args) {
        // 初始化測試資料
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 10);
        map.put("cherry", 3);
        
        System.out.println("初始 Map: " + map);
        
        demonstratePutIfAbsent(new HashMap<>(map));
        demonstrateCompute(new HashMap<>(map));
        demonstrateComputeIfAbsent(new HashMap<>(map));
        demonstrateComputeIfPresent(new HashMap<>(map));
        demonstrateMerge(new HashMap<>(map));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * putIfAbsent: 僅在 Key 不存在時插入值
 * 返回值：Key 存在時返回現有值，不存在時返回 null（插入後）
 */
public static void demonstratePutIfAbsent(Map<String, Integer> map) {
    System.out.println("\n=== putIfAbsent 示範 ===");
    
    // Case 1: Key 已存在 - 不插入，返回現有值
    Integer result1 = map.putIfAbsent("apple", 99);
    System.out.println("putIfAbsent('apple', 99) 返回: " + result1); // 5
    System.out.println("map 內容: " + map); // apple 仍為 5
    
    // Case 2: Key 不存在 - 插入新值，返回 null
    Integer result2 = map.putIfAbsent("orange", 8);
    System.out.println("putIfAbsent('orange', 8) 返回: " + result2); // null
    System.out.println("map 內容: " + map); // 新增了 orange=8
    
    // Case 3: Value 為 null 的情況
    map.put("grape", null);
    Integer result3 = map.putIfAbsent("grape", 15);
    System.out.println("putIfAbsent('grape', 15) 返回: " + result3); // null
    System.out.println("map 內容: " + map); // grape 被設為 15
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * 快取初始化模式：確保每個 Key 只初始化一次
 */
public class CacheInitializationExample {
    
    private final Map<String, ExpensiveObject> cache = new ConcurrentHashMap<>();
    
    /**
     * 使用 putIfAbsent 實現執行緒安全的快取初始化
     */
    public ExpensiveObject getOrCreateObject(String key) {
        ExpensiveObject existing = cache.get(key);
        if (existing != null) {
            return existing;
        }
        
        // 創建昂貴對象
        ExpensiveObject newObject = new ExpensiveObject(key);
        
        // 原子性插入，避免重複創建
        ExpensiveObject result = cache.putIfAbsent(key, newObject);
        return result != null ? result : newObject;
    }
    
    /**
     * 更簡潔的寫法（但可能創建多餘物件）
     */
    public ExpensiveObject getOrCreateObjectSimple(String key) {
        return cache.putIfAbsent(key, new ExpensiveObject(key));
    }
    
    public static class ExpensiveObject {
        private final String id;
        private final long creationTime;
        
        public ExpensiveObject(String id) {
            this.id = id;
            this.creationTime = System.currentTimeMillis();
            // 模擬昂貴的初始化過程
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        @Override
        public String toString() {
            return String.format("ExpensiveObject{id='%s', created=%d}", id, creationTime);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * compute: 無條件執行計算，可處理 Key 存在或不存在的情況
 * 計算函數接收 (key, value) 參數，value 可能為 null
 */
public static void demonstrateCompute(Map<String, Integer> map) {
    System.out.println("\n=== compute 示範 ===");
    
    // Case 1: Key 存在 - 基於現有值計算
    Integer result1 = map.compute("apple", (key, value) -> value + 10);
    System.out.println("compute('apple', v -> v + 10) 返回: " + result1); // 15
    System.out.println("map 內容: " + map);
    
    // Case 2: Key 不存在 - value 為 null
    Integer result2 = map.compute("orange", (key, value) -> {
        System.out.println("計算 " + key + ", 當前值: " + value);
        return value == null ? 1 : value + 1;
    });
    System.out.println("compute('orange', ...) 返回: " + result2); // 1
    
    // Case 3: 計算結果為 null - 移除該 Key
    Integer result3 = map.compute("cherry", (key, value) -> {
        return value < 5 ? null : value; // cherry=3 < 5，返回 null
    });
    System.out.println("compute('cherry', ...) 返回: " + result3); // null
    System.out.println("map 內容: " + map); // cherry 被移除
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

/**
 * 複雜計算應用：統計和聚合操作
 */
public class ComputeAdvancedExample {
    
    /**
     * 實現計數器功能
     */
    public static Map<String, Integer> updateCounters(Map<String, Integer> counters, 
                                                     List<String> events) {
        for (String event : events) {
            counters.compute(event, (key, count) -> count == null ? 1 : count + 1);
        }
        return counters;
    }
    
    /**
     * 實現累加器功能
     */
    public static Map<String, Double> updateAccumulators(Map<String, Double> accumulators,
                                                        Map<String, Double> newValues) {
        for (Map.Entry<String, Double> entry : newValues.entrySet()) {
            accumulators.compute(entry.getKey(), (key, current) -> {
                double newValue = entry.getValue();
                return current == null ? newValue : current + newValue;
            });
        }
        return accumulators;
    }
    
    /**
     * 條件式更新：基於複雜邏輯的值計算
     */
    public static Map<String, String> updateStatus(Map<String, String> statusMap,
                                                  String key, String newStatus) {
        return Map.of(key, statusMap.compute(key, (k, currentStatus) -> {
            if (currentStatus == null) {
                return newStatus;
            }
            
            // 狀態轉換邏輯
            switch (currentStatus) {
                case "PENDING":
                    return List.of("PROCESSING", "CANCELLED").contains(newStatus) 
                           ? newStatus : currentStatus;
                case "PROCESSING":
                    return List.of("COMPLETED", "FAILED").contains(newStatus) 
                           ? newStatus : currentStatus;
                default:
                    return currentStatus; // 不允許從終態轉換
            }
        }));
    }
    
    public static void main(String[] args) {
        // 測試計數器
        Map<String, Integer> counters = new HashMap<>();
        List<String> events = Arrays.asList("login", "logout", "login", "error", "login");
        updateCounters(counters, events);
        System.out.println("事件計數: " + counters);
        
        // 測試累加器
        Map<String, Double> accumulators = new HashMap<>();
        Map<String, Double> newValues = Map.of("sales", 100.5, "costs", 75.2);
        updateAccumulators(accumulators, newValues);
        System.out.println("累加結果: " + accumulators);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * computeIfAbsent: 僅在 Key 不存在時執行計算
 * 是 putIfAbsent 的計算版本，支援 Lambda 表達式
 */
public static void demonstrateComputeIfAbsent(Map<String, Integer> map) {
    System.out.println("\n=== computeIfAbsent 示範 ===");
    
    // Case 1: Key 存在 - 不執行計算，返回現有值
    Integer result1 = map.computeIfAbsent("apple", key -> {
        System.out.println("為 " + key + " 執行計算"); // 不會列印
        return 999;
    });
    System.out.println("computeIfAbsent('apple', ...) 返回: " + result1); // 5
    
    // Case 2: Key 不存在 - 執行計算並插入
    Integer result2 = map.computeIfAbsent("orange", key -> {
        System.out.println("為 " + key + " 執行計算"); // 會列印
        return key.length() * 10; // 基於 key 計算值
    });
    System.out.println("computeIfAbsent('orange', ...) 返回: " + result2); // 60
    
    // Case 3: 計算結果為 null - 不插入
    Integer result3 = map.computeIfAbsent("grape", key -> null);
    System.out.println("computeIfAbsent('grape', -> null) 返回: " + result3); // null
    System.out.println("map 內容: " + map); // grape 不會被插入
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/**
 * 延遲初始化應用：動態創建集合和複雜對象
 */
public class LazyInitializationExample {
    
    private final Map<String, List<String>> groupMap = new ConcurrentHashMap<>();
    private final Map<String, Set<Integer>> categoryMap = new ConcurrentHashMap<>();
    private final Map<String, Map<String, Object>> configMap = new ConcurrentHashMap<>();
    
    /**
     * 延遲初始化 List 集合
     */
    public void addToGroup(String groupName, String item) {
        groupMap.computeIfAbsent(groupName, k -> new ArrayList<>()).add(item);
    }
    
    /**
     * 延遲初始化 Set 集合
     */
    public void addToCategory(String category, Integer value) {
        categoryMap.computeIfAbsent(category, k -> new HashSet<>()).add(value);
    }
    
    /**
     * 延遲初始化巢狀 Map
     */
    public void setConfig(String module, String key, Object value) {
        configMap.computeIfAbsent(module, k -> new ConcurrentHashMap<>()).put(key, value);
    }
    
    /**
     * 複雜對象的延遲初始化
     */
    private final Map<String, DatabaseConnection> connectionPool = new ConcurrentHashMap<>();
    
    public DatabaseConnection getConnection(String database) {
        return connectionPool.computeIfAbsent(database, dbName -> {
            System.out.println("創建新的資料庫連接: " + dbName);
            return new DatabaseConnection(dbName);
        });
    }
    
    /**
     * 基於外部資源的延遲載入
     */
    private final Map<String, UserProfile> userCache = new ConcurrentHashMap<>();
    
    public UserProfile getUserProfile(String userId) {
        return userCache.computeIfAbsent(userId, id -> {
            // 模擬從資料庫載入用戶資料
            System.out.println("從資料庫載入用戶: " + id);
            return loadUserFromDatabase(id);
        });
    }
    
    // 輔助類別和方法
    public static class DatabaseConnection {
        private final String database;
        private final long createdAt;
        
        public DatabaseConnection(String database) {
            this.database = database;
            this.createdAt = System.currentTimeMillis();
        }
        
        @Override
        public String toString() {
            return String.format("Connection{db='%s', created=%d}", database, createdAt);
        }
    }
    
    public static class UserProfile {
        private final String userId;
        private final String name;
        
        public UserProfile(String userId, String name) {
            this.userId = userId;
            this.name = name;
        }
        
        @Override
        public String toString() {
            return String.format("UserProfile{id='%s', name='%s'}", userId, name);
        }
    }
    
    private UserProfile loadUserFromDatabase(String userId) {
        // 模擬資料庫查詢延遲
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new UserProfile(userId, "User-" + userId);
    }
    
    public static void main(String[] args) {
        LazyInitializationExample example = new LazyInitializationExample();
        
        // 測試群組管理
        example.addToGroup("admins", "alice");
        example.addToGroup("admins", "bob");
        example.addToGroup("users", "charlie");
        System.out.println("群組: " + example.groupMap);
        
        // 測試連接池
        DatabaseConnection conn1 = example.getConnection("user_db");
        DatabaseConnection conn2 = example.getConnection("user_db"); // 同一個實例
        System.out.println("連接1: " + conn1);
        System.out.println("連接2: " + conn2);
        System.out.println("是否為同一個連接: " + (conn1 == conn2));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

/**
 * computeIfPresent: 僅在 Key 存在且值不為 null 時執行計算
 */
public static void demonstrateComputeIfPresent(Map<String, Integer> map) {
    System.out.println("\n=== computeIfPresent 示範 ===");
    
    // Case 1: Key 存在且值不為 null - 執行計算
    Integer result1 = map.computeIfPresent("apple", (key, value) -> {
        System.out.println("為 " + key + " 執行計算，當前值: " + value);
        return value * 2;
    });
    System.out.println("computeIfPresent('apple', v -> v * 2) 返回: " + result1); // 10
    
    // Case 2: Key 不存在 - 不執行計算
    Integer result2 = map.computeIfPresent("orange", (key, value) -> {
        System.out.println("這行不會執行");
        return 999;
    });
    System.out.println("computeIfPresent('orange', ...) 返回: " + result2); // null
    
    // Case 3: Key 存在但值為 null - 不執行計算
    map.put("grape", null);
    Integer result3 = map.computeIfPresent("grape", (key, value) -> {
        System.out.println("這行也不會執行");
        return 123;
    });
    System.out.println("computeIfPresent('grape', ...) 返回: " + result3); // null
    
    // Case 4: 計算結果為 null - 移除該 Key
    Integer result4 = map.computeIfPresent("banana", (key, value) -> {
        return value > 15 ? null : value + 5; // banana=10 <= 15，返回 15
    });
    System.out.println("computeIfPresent('banana', ...) 返回: " + result4); // 15
    System.out.println("map 內容: " + map);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

/**
 * 條件式更新應用：基於現有值的智能更新
 */
public class ConditionalUpdateExample {
    
    /**
     * 分數系統：只更新有效分數
     */
    public static Map<String, Integer> updateScores(Map<String, Integer> scores,
                                                   Map<String, Integer> scoreChanges) {
        for (Map.Entry<String, Integer> change : scoreChanges.entrySet()) {
            scores.computeIfPresent(change.getKey(), (player, currentScore) -> {
                int newScore = currentScore + change.getValue();
                // 分數不能低於 0
                return Math.max(0, newScore);
            });
        }
        return scores;
    }
    
    /**
     * 庫存管理：只減少現有庫存
     */
    public static Map<String, Integer> reduceInventory(Map<String, Integer> inventory,
                                                      Map<String, Integer> orders) {
        Map<String, Integer> processed = new HashMap<>();
        
        for (Map.Entry<String, Integer> order : orders.entrySet()) {
            Integer newStock = inventory.computeIfPresent(order.getKey(), (item, stock) -> {
                int orderQuantity = order.getValue();
                if (stock >= orderQuantity) {
                    return stock - orderQuantity;
                } else {
                    // 庫存不足，不處理訂單
                    return stock;
                }
            });
            
            if (newStock != null) {
                int originalStock = newStock + order.getValue();
                if (originalStock >= order.getValue()) {
                    processed.put(order.getKey(), order.getValue());
                }
            }
        }
        
        return processed;
    }
    
    /**
     * 過期資料清理：基於時間戳的條件更新
     */
    public static class TimestampCache {
        private final Map<String, Long> timestampMap = new ConcurrentHashMap<>();
        private final long TTL_MILLIS = 300_000; // 5 分鐘
        
        public void touch(String key) {
            timestampMap.put(key, System.currentTimeMillis());
        }
        
        public boolean isValid(String key) {
            return timestampMap.computeIfPresent(key, (k, timestamp) -> {
                long now = System.currentTimeMillis();
                if (now - timestamp > TTL_MILLIS) {
                    return null; // 過期，移除
                }
                return timestamp; // 仍有效
            }) != null;
        }
        
        public int cleanupExpired() {
            int removed = 0;
            long now = System.currentTimeMillis();
            
            Iterator<Map.Entry<String, Long>> iterator = timestampMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Long> entry = iterator.next();
                if (now - entry.getValue() > TTL_MILLIS) {
                    iterator.remove();
                    removed++;
                }
            }
            
            return removed;
        }
    }
    
    public static void main(String[] args) {
        // 測試分數更新
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 100);
        scores.put("Bob", 150);
        
        Map<String, Integer> changes = new HashMap<>();
        changes.put("Alice", 50);   // 有效玩家
        changes.put("Charlie", 25); // 不存在的玩家
        changes.put("Bob", -200);   // 會觸發最小值限制
        
        updateScores(scores, changes);
        System.out.println("更新後分數: " + scores);
        
        // 測試時間戳快取
        TimestampCache cache = new TimestampCache();
        cache.touch("session1");
        System.out.println("session1 是否有效: " + cache.isValid("session1"));
        
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("session1 是否仍有效: " + cache.isValid("session1"));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

/**
 * merge: 合併現有值與新值
 * 如果 Key 不存在或值為 null，直接使用新值
 * 如果 Key 存在且值不為 null，使用合併函數計算結果
 */
public static void demonstrateMerge(Map<String, Integer> map) {
    System.out.println("\n=== merge 示範 ===");
    
    // Case 1: Key 存在 - 執行合併操作
    Integer result1 = map.merge("apple", 20, (oldValue, newValue) -> {
        System.out.println("合併 apple: " + oldValue + " + " + newValue);
        return oldValue + newValue;
    });
    System.out.println("merge('apple', 20, sum) 返回: " + result1); // 25
    
    // Case 2: Key 不存在 - 直接使用新值
    Integer result2 = map.merge("orange", 15, (oldValue, newValue) -> {
        System.out.println("這行不會執行，因為 orange 不存在");
        return oldValue + newValue;
    });
    System.out.println("merge('orange', 15, sum) 返回: " + result2); // 15
    
    // Case 3: 合併結果為 null - 移除該 Key
    Integer result3 = map.merge("banana", 5, (oldValue, newValue) -> {
        return oldValue == newValue ? null : oldValue + newValue;
    });
    System.out.println("merge('banana', 5, ...) 返回: " + result3); // null（banana=10 != 5）
    System.out.println("map 內容: " + map);
    
    // Case 4: 值為 null 的情況
    map.put("grape", null);
    Integer result4 = map.merge("grape", 30, Integer::sum);
    System.out.println("merge('grape', 30, sum) 返回: " + result4); // 30
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

/**
 * 高級合併應用：資料聚合和統計分析
 */
public class AdvancedMergeExample {
    
    /**
     * 統計資料合併：累加計數器
     */
    public static Map<String, Integer> mergeCounters(List<Map<String, Integer>> counterMaps) {
        Map<String, Integer> result = new HashMap<>();
        
        for (Map<String, Integer> counterMap : counterMaps) {
            for (Map.Entry<String, Integer> entry : counterMap.entrySet()) {
                result.merge(entry.getKey(), entry.getValue(), Integer::sum);
            }
        }
        
        return result;
    }
    
    /**
     * 字串合併：拼接文字
     */
    public static Map<String, String> mergeMessages(Map<String, String> base,
                                                   Map<String, String> additional) {
        Map<String, String> result = new HashMap<>(base);
        
        for (Map.Entry<String, String> entry : additional.entrySet()) {
            result.merge(entry.getKey(), entry.getValue(), (old, new_) -> old + "; " + new_);
        }
        
        return result;
    }
    
    /**
     * 複雜對象合併：銷售資料聚合
     */
    public static class SalesData {
        private double revenue;
        private int quantity;
        
        public SalesData(double revenue, int quantity) {
            this.revenue = revenue;
            this.quantity = quantity;
        }
        
        public SalesData merge(SalesData other) {
            return new SalesData(this.revenue + other.revenue, this.quantity + other.quantity);
        }
        
        public double getAveragePrice() {
            return quantity > 0 ? revenue / quantity : 0;
        }
        
        @Override
        public String toString() {
            return String.format("SalesData{revenue=%.2f, quantity=%d, avgPrice=%.2f}",
                               revenue, quantity, getAveragePrice());
        }
        
        // getter 和 setter
        public double getRevenue() { return revenue; }
        public int getQuantity() { return quantity; }
    }
    
    public static Map<String, SalesData> mergeSalesData(List<Map<String, SalesData>> salesMaps) {
        Map<String, SalesData> result = new HashMap<>();
        
        for (Map<String, SalesData> salesMap : salesMaps) {
            for (Map.Entry<String, SalesData> entry : salesMap.entrySet()) {
                result.merge(entry.getKey(), entry.getValue(), SalesData::merge);
            }
        }
        
        return result;
    }
    
    /**
     * 集合合併：Set 和 List 的合併操作
     */
    public static Map<String, Set<String>> mergeSets(Map<String, Set<String>> map1,
                                                    Map<String, Set<String>> map2) {
        Map<String, Set<String>> result = new HashMap<>();
        
        // 複製第一個 map
        for (Map.Entry<String, Set<String>> entry : map1.entrySet()) {
            result.put(entry.getKey(), new HashSet<>(entry.getValue()));
        }
        
        // 合併第二個 map
        for (Map.Entry<String, Set<String>> entry : map2.entrySet()) {
            result.merge(entry.getKey(), entry.getValue(), (set1, set2) -> {
                Set<String> merged = new HashSet<>(set1);
                merged.addAll(set2);
                return merged;
            });
        }
        
        return result;
    }
    
    public static void main(String[] args) {
        // 測試計數器合併
        List<Map<String, Integer>> counters = Arrays.asList(
            Map.of("A", 10, "B", 20),
            Map.of("A", 5, "C", 15),
            Map.of("B", 8, "C", 12)
        );
        
        Map<String, Integer> mergedCounters = mergeCounters(counters);
        System.out.println("合併後計數器: " + mergedCounters);
        
        // 測試銷售資料合併
        List<Map<String, SalesData>> salesList = Arrays.asList(
            Map.of("Product1", new SalesData(1000.0, 10)),
            Map.of("Product1", new SalesData(500.0, 5), "Product2", new SalesData(800.0, 8))
        );
        
        Map<String, SalesData> mergedSales = mergeSalesData(salesList);
        System.out.println("合併後銷售資料:");
        mergedSales.forEach((product, data) -> 
            System.out.println("  " + product + ": " + data));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

/**
 * 執行緒安全的計算操作
 */
public class ThreadSafeComputeExample {
    
    private final ConcurrentHashMap<String, Integer> concurrentCounters = new ConcurrentHashMap<>();
    private final Map<String, Integer> unsafeCounters = new HashMap<>();
    
    /**
     * 執行緒安全的計數器增量
     */
    public void incrementCounterSafe(String key) {
        concurrentCounters.compute(key, (k, v) -> v == null ? 1 : v + 1);
    }
    
    /**
     * 非執行緒安全的計數器增量（可能導致資料競爭）
     */
    public synchronized void incrementCounterUnsafe(String key) {
        Integer current = unsafeCounters.get(key);
        unsafeCounters.put(key, current == null ? 1 : current + 1);
    }
    
    /**
     * 並發測試
     */
    public static void testConcurrency() throws InterruptedException {
        ThreadSafeComputeExample example = new ThreadSafeComputeExample();
        int threadCount = 10;
        int incrementsPerThread = 1000;
        String testKey = "counter";
        
        // 測試執行緒安全版本
        Thread[] safeThreads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            safeThreads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPerThread; j++) {
                    example.incrementCounterSafe(testKey);
                }
            });
        }
        
        long startTime = System.currentTimeMillis();
        for (Thread thread : safeThreads) {
            thread.start();
        }
        for (Thread thread : safeThreads) {
            thread.join();
        }
        long safeTime = System.currentTimeMillis() - startTime;
        
        Integer safeResult = example.concurrentCounters.get(testKey);
        System.out.printf("執行緒安全版本: 期望=%d, 實際=%d, 耗時=%dms\n",
                         threadCount * incrementsPerThread, safeResult, safeTime);
        
        // 測試非執行緒安全版本
        Thread[] unsafeThreads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            unsafeThreads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPerThread; j++) {
                    example.incrementCounterUnsafe(testKey);
                }
            });
        }
        
        startTime = System.currentTimeMillis();
        for (Thread thread : unsafeThreads) {
            thread.start();
        }
        for (Thread thread : unsafeThreads) {
            thread.join();
        }
        long unsafeTime = System.currentTimeMillis() - startTime;
        
        Integer unsafeResult = example.unsafeCounters.get(testKey);
        System.out.printf("非執行緒安全版本: 期望=%d, 實際=%d, 耗時=%dms\n",
                         threadCount * incrementsPerThread, unsafeResult, unsafeTime);
    }
    
    public static void main(String[] args) throws InterruptedException {
        testConcurrency();
    }
}