Collections on Bill.Lin's Notes

Java TreeSet 完整實作指南：紅黑樹有序集合與 NavigableSet 介面詳解

Sun, 02 Oct 2022 00:48:01 +0800

Java TreeSet 完整實作指南

簡介

TreeSet 是 Java 集合框架中實現有序集合的核心類別，基於 TreeMap 實現並使用紅黑樹（Red-Black Tree）數據結構。它保證元素的唯一性和有序性，提供了 O(log n) 的時間複雜度進行搜索、插入和刪除操作。本文將深入探討 TreeSet 的內部實現、各種方法使用、效能特性以及在企業級開發中的最佳實踐。

TreeSet 架構與繼承關係

類別繼承結構

Collection<E>
   ↑
Set<E>
   ↑
SortedSet<E>
   ↑
NavigableSet<E>
   ↑
TreeSet<E>

核心介面關係

// 基本集合介面
public interface Set<E> extends Collection<E> {
    boolean add(E e);
    boolean remove(Object o);
    boolean contains(Object o);
    int size();
    boolean isEmpty();
    Iterator<E> iterator();
}

// 有序集合介面
public interface SortedSet<E> extends Set<E> {
    Comparator<? super E> comparator();
    SortedSet<E> subSet(E fromElement, E toElement);
    SortedSet<E> headSet(E toElement);
    SortedSet<E> tailSet(E fromElement);
    E first();
    E last();
}

// 可導航集合介面
public interface NavigableSet<E> extends SortedSet<E> {
    E lower(E e);
    E floor(E e);
    E ceiling(E e);
    E higher(E e);
    E pollFirst();
    E pollLast();
    Iterator<E> iterator();
    NavigableSet<E> descendingSet();
    Iterator<E> descendingIterator();
    NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                          E toElement, boolean toInclusive);
    NavigableSet<E> headSet(E toElement, boolean inclusive);
    NavigableSet<E> tailSet(E fromElement, boolean inclusive);
}

TreeSet 核心特性

1. 基於 TreeMap 的實現

// TreeSet 內部實現
public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable {
    
    // 內部使用 TreeMap 存儲元素
    private transient NavigableMap<E,Object> m;
    
    // 虛擬值，用於將 Set 轉換為 Map
    private static final Object PRESENT = new Object();
    
    // 構造函數
    public TreeSet() {
        this(new TreeMap<E,Object>());
    }
    
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
    
    // 基本操作
    public boolean add(E e) {
        return m.put(e, PRESENT) == null;
    }
    
    public boolean remove(Object o) {
        return m.remove(o) == PRESENT;
    }
    
    public boolean contains(Object o) {
        return m.containsKey(o);
    }
    
    public int size() {
        return m.size();
    }
}

2. 自然排序與自定義比較器

// 自然排序 TreeSet
TreeSet<String> naturalOrder = new TreeSet<>();
naturalOrder.add("Charlie");
naturalOrder.add("Alice");
naturalOrder.add("Bob");
// 結果：[Alice, Bob, Charlie]

// 自定義比較器 - 按長度排序
TreeSet<String> lengthOrder = new TreeSet<>(
    Comparator.comparing(String::length)
        .thenComparing(String::compareTo) // 長度相同時按字典序
);
lengthOrder.add("Java");
lengthOrder.add("C++");
lengthOrder.add("Python");
lengthOrder.add("Go");
// 結果：[Go, C++, Java, Python]

// 降序排序
TreeSet<Integer> descendingOrder = new TreeSet<>(Collections.reverseOrder());
descendingOrder.add(5);
descendingOrder.add(2);
descendingOrder.add(8);
descendingOrder.add(1);
// 結果：[8, 5, 2, 1]

// 複雜對象排序
TreeSet<Person> personSet = new TreeSet<>(
    Comparator.comparing(Person::getAge)
        .thenComparing(Person::getName)
);

SortedSet 介面詳解

基本方法實現

public class TreeSetSortedExample {
    
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        
        // 添加元素
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(8);
        treeSet.add(1);
        treeSet.add(9);
        treeSet.add(3);
        
        demonstrateSortedSetMethods(treeSet);
    }
    
    private static void demonstrateSortedSetMethods(TreeSet<Integer> set) {
        System.out.println("Original set: " + set); // [1, 2, 3, 5, 8, 9]
        
        // 獲取比較器
        Comparator<? super Integer> comparator = set.comparator();
        System.out.println("Comparator: " + comparator); // null (natural ordering)
        
        // 第一個和最後一個元素
        System.out.println("First element: " + set.first()); // 1
        System.out.println("Last element: " + set.last());   // 9
        
        // 子集合（含頭不含尾）
        SortedSet<Integer> subSet = set.subSet(2, 8);
        System.out.println("SubSet [2, 8): " + subSet); // [2, 3, 5]
        
        // 頭部集合（不包含指定元素）
        SortedSet<Integer> headSet = set.headSet(5);
        System.out.println("HeadSet (< 5): " + headSet); // [1, 2, 3]
        
        // 尾部集合（包含指定元素）
        SortedSet<Integer> tailSet = set.tailSet(5);
        System.out.println("TailSet (>= 5): " + tailSet); // [5, 8, 9]
        
        // 迭代器
        System.out.print("Forward iteration: ");
        for (Integer value : set) {
            System.out.print(value + " ");
        }
        System.out.println();
        
        // 降序迭代器
        System.out.print("Descending iteration: ");
        Iterator<Integer> descendingIterator = set.descendingIterator();
        while (descendingIterator.hasNext()) {
            System.out.print(descendingIterator.next() + " ");
        }
        System.out.println();
    }
}

NavigableSet 介面詳解

導航方法實現

public class TreeSetNavigableExample {
    
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        
        // 添加測試數據
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(5);
        treeSet.add(7);
        treeSet.add(9);
        
        demonstrateNavigableMethods(treeSet);
    }
    
    private static void demonstrateNavigableMethods(TreeSet<Integer> set) {
        System.out.println("Original set: " + set); // [1, 3, 5, 7, 9]
        
        // Lower 方法：返回嚴格小於指定元素的最大元素
        Integer lower = set.lower(5);
        System.out.println("Lower (< 5): " + lower); // 3
        
        // Floor 方法：返回小於或等於指定元素的最大元素
        Integer floor1 = set.floor(4);
        Integer floor2 = set.floor(5);
        System.out.println("Floor (<= 4): " + floor1); // 3
        System.out.println("Floor (<= 5): " + floor2); // 5
        
        // Ceiling 方法：返回大於或等於指定元素的最小元素
        Integer ceiling1 = set.ceiling(4);
        Integer ceiling2 = set.ceiling(5);
        System.out.println("Ceiling (>= 4): " + ceiling1); // 5
        System.out.println("Ceiling (>= 5): " + ceiling2); // 5
        
        // Higher 方法：返回嚴格大於指定元素的最小元素
        Integer higher = set.higher(5);
        System.out.println("Higher (> 5): " + higher); // 7
        
        // 彈出首尾元素（會刪除元素）
        TreeSet<Integer> copySet = new TreeSet<>(set);
        Integer pollFirst = copySet.pollFirst();
        Integer pollLast = copySet.pollLast();
        System.out.println("Poll first: " + pollFirst); // 1
        System.out.println("Poll last: " + pollLast);   // 9
        System.out.println("After polling: " + copySet); // [3, 5, 7]
        
        // 降序視圖
        NavigableSet<Integer> descendingSet = set.descendingSet();
        System.out.println("Descending set: " + descendingSet); // [9, 7, 5, 3, 1]
        
        // 範圍視圖
        NavigableSet<Integer> rangeSet = set.subSet(3, true, 7, false);
        System.out.println("Range [3, 7): " + rangeSet); // [3, 5]
        
        NavigableSet<Integer> headSet = set.headSet(5, true);
        System.out.println("Head set (<= 5): " + headSet); // [1, 3, 5]
        
        NavigableSet<Integer> tailSet = set.tailSet(5, false);
        System.out.println("Tail set (> 5): " + tailSet); // [7, 9]
        
        // 查找操作
        demonstrateSearchOperations(set);
    }
    
    private static void demonstrateSearchOperations(TreeSet<Integer> set) {
        System.out.println("\n=== Search Operations ===");
        
        // 測試不存在的元素
        int target = 4;
        System.out.println("Searching for: " + target);
        System.out.println("Contains: " + set.contains(target)); // false
        System.out.println("Lower: " + set.lower(target));       // 3
        System.out.println("Floor: " + set.floor(target));       // 3
        System.out.println("Ceiling: " + set.ceiling(target));   // 5
        System.out.println("Higher: " + set.higher(target));     // 5
        
        // 測試邊界情況
        System.out.println("\n=== Boundary Cases ===");
        System.out.println("Lower than first: " + set.lower(1));    // null
        System.out.println("Higher than last: " + set.higher(9));   // null
        System.out.println("Floor of first: " + set.floor(1));      // 1
        System.out.println("Ceiling of last: " + set.ceiling(9));   // 9
    }
}

企業級應用實例

1. 事件調度系統

public class EventScheduler {
    
    private final TreeSet<Event> eventQueue;
    private final ScheduledExecutorService scheduler;
    private final AtomicBoolean running;
    
    public EventScheduler() {
        // 按時間排序事件
        this.eventQueue = new TreeSet<>(Comparator.comparing(Event::getScheduledTime));
        this.scheduler = Executors.newScheduledThreadPool(2);
        this.running = new AtomicBoolean(false);
    }
    
    // 調度事件
    public void scheduleEvent(Event event) {
        synchronized (eventQueue) {
            eventQueue.add(event);
            
            // 如果是最早的事件，重新調度
            if (event.equals(eventQueue.first())) {
                rescheduleNext();
            }
        }
    }
    
    // 取消事件
    public boolean cancelEvent(Event event) {
        synchronized (eventQueue) {
            boolean removed = eventQueue.remove(event);
            if (removed && !eventQueue.isEmpty()) {
                rescheduleNext();
            }
            return removed;
        }
    }
    
    // 獲取即將執行的事件
    public List<Event> getUpcomingEvents(int count) {
        synchronized (eventQueue) {
            return eventQueue.stream()
                    .limit(count)
                    .collect(Collectors.toList());
        }
    }
    
    // 獲取指定時間範圍內的事件
    public List<Event> getEventsInRange(LocalDateTime start, LocalDateTime end) {
        synchronized (eventQueue) {
            Event startEvent = new Event("", start, null);
            Event endEvent = new Event("", end, null);
            
            return eventQueue.subSet(startEvent, true, endEvent, false)
                    .stream()
                    .collect(Collectors.toList());
        }
    }
    
    // 啟動調度器
    public void start() {
        if (running.compareAndSet(false, true)) {
            rescheduleNext();
        }
    }
    
    // 停止調度器
    public void stop() {
        running.set(false);
        scheduler.shutdown();
    }
    
    // 重新調度下一個事件
    private void rescheduleNext() {
        if (!running.get()) {
            return;
        }
        
        synchronized (eventQueue) {
            if (eventQueue.isEmpty()) {
                return;
            }
            
            Event nextEvent = eventQueue.first();
            LocalDateTime now = LocalDateTime.now();
            
            if (nextEvent.getScheduledTime().isBefore(now)) {
                // 立即執行過期事件
                scheduler.submit(this::processNextEvent);
            } else {
                // 計算延遲時間
                long delay = Duration.between(now, nextEvent.getScheduledTime()).toMillis();
                scheduler.schedule(this::processNextEvent, delay, TimeUnit.MILLISECONDS);
            }
        }
    }
    
    // 處理下一個事件
    private void processNextEvent() {
        Event event = null;
        
        synchronized (eventQueue) {
            if (!eventQueue.isEmpty()) {
                event = eventQueue.pollFirst();
            }
        }
        
        if (event != null) {
            try {
                event.execute();
            } catch (Exception e) {
                System.err.println("Event execution failed: " + event.getName());
                e.printStackTrace();
            }
        }
        
        // 調度下一個事件
        rescheduleNext();
    }
    
    // 清理過期事件
    public int cleanupExpiredEvents() {
        synchronized (eventQueue) {
            LocalDateTime cutoff = LocalDateTime.now().minusHours(24);
            Event cutoffEvent = new Event("", cutoff, null);
            
            NavigableSet<Event> expiredEvents = eventQueue.headSet(cutoffEvent, true);
            int count = expiredEvents.size();
            expiredEvents.clear();
            
            return count;
        }
    }
    
    // 獲取統計信息
    public EventStatistics getStatistics() {
        synchronized (eventQueue) {
            LocalDateTime now = LocalDateTime.now();
            long pendingEvents = eventQueue.size();
            long overdueEvents = eventQueue.stream()
                    .filter(event -> event.getScheduledTime().isBefore(now))
                    .count();
            
            LocalDateTime nextEventTime = eventQueue.isEmpty() ? null : eventQueue.first().getScheduledTime();
            
            return new EventStatistics(pendingEvents, overdueEvents, nextEventTime);
        }
    }
    
    // 事件類
    public static class Event {
        private final String name;
        private final LocalDateTime scheduledTime;
        private final Runnable action;
        
        public Event(String name, LocalDateTime scheduledTime, Runnable action) {
            this.name = name;
            this.scheduledTime = scheduledTime;
            this.action = action;
        }
        
        public void execute() {
            if (action != null) {
                action.run();
            }
        }
        
        // Getters
        public String getName() { return name; }
        public LocalDateTime getScheduledTime() { return scheduledTime; }
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Event event = (Event) obj;
            return Objects.equals(name, event.name) && 
                   Objects.equals(scheduledTime, event.scheduledTime);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, scheduledTime);
        }
    }
    
    // 統計信息類
    public static class EventStatistics {
        private final long pendingEvents;
        private final long overdueEvents;
        private final LocalDateTime nextEventTime;
        
        public EventStatistics(long pendingEvents, long overdueEvents, LocalDateTime nextEventTime) {
            this.pendingEvents = pendingEvents;
            this.overdueEvents = overdueEvents;
            this.nextEventTime = nextEventTime;
        }
        
        // Getters
        public long getPendingEvents() { return pendingEvents; }
        public long getOverdueEvents() { return overdueEvents; }
        public LocalDateTime getNextEventTime() { return nextEventTime; }
    }
}

2. 範圍查詢緩存系統

public class RangeQueryCache<T extends Comparable<T>> {
    
    private final TreeSet<CacheEntry<T>> cache;
    private final int maxSize;
    private final long ttlMillis;
    
    public RangeQueryCache(int maxSize, long ttlMillis) {
        this.cache = new TreeSet<>(Comparator.comparing(CacheEntry::getKey));
        this.maxSize = maxSize;
        this.ttlMillis = ttlMillis;
    }
    
    // 添加緩存項
    public void put(T key, Object value) {
        synchronized (cache) {
            // 移除舊值
            cache.removeIf(entry -> entry.getKey().equals(key));
            
            // 添加新值
            CacheEntry<T> entry = new CacheEntry<>(key, value, System.currentTimeMillis() + ttlMillis);
            cache.add(entry);
            
            // 清理過期項
            cleanupExpired();
            
            // 如果超過容量，移除最舊的項
            if (cache.size() > maxSize) {
                cache.pollFirst();
            }
        }
    }
    
    // 獲取單個值
    public Object get(T key) {
        synchronized (cache) {
            CacheEntry<T> searchEntry = new CacheEntry<>(key, null, 0);
            CacheEntry<T> found = cache.floor(searchEntry);
            
            if (found != null && found.getKey().equals(key) && !found.isExpired()) {
                return found.getValue();
            }
            
            return null;
        }
    }
    
    // 範圍查詢
    public List<Object> getRangeValues(T fromKey, T toKey) {
        synchronized (cache) {
            CacheEntry<T> fromEntry = new CacheEntry<>(fromKey, null, 0);
            CacheEntry<T> toEntry = new CacheEntry<>(toKey, null, 0);
            
            return cache.subSet(fromEntry, true, toEntry, true)
                    .stream()
                    .filter(entry -> !entry.isExpired())
                    .map(CacheEntry::getValue)
                    .collect(Collectors.toList());
        }
    }
    
    // 獲取最接近的值
    public Object getClosest(T key) {
        synchronized (cache) {
            CacheEntry<T> searchEntry = new CacheEntry<>(key, null, 0);
            CacheEntry<T> floor = cache.floor(searchEntry);
            CacheEntry<T> ceiling = cache.ceiling(searchEntry);
            
            CacheEntry<T> closest = null;
            
            if (floor != null && !floor.isExpired()) {
                closest = floor;
            }
            
            if (ceiling != null && !ceiling.isExpired()) {
                if (closest == null || 
                    key.compareTo(ceiling.getKey()) < closest.getKey().compareTo(key)) {
                    closest = ceiling;
                }
            }
            
            return closest != null ? closest.getValue() : null;
        }
    }
    
    // 獲取前 N 個值
    public List<Object> getTopN(int n) {
        synchronized (cache) {
            return cache.stream()
                    .filter(entry -> !entry.isExpired())
                    .limit(n)
                    .map(CacheEntry::getValue)
                    .collect(Collectors.toList());
        }
    }
    
    // 清理過期項
    private void cleanupExpired() {
        long now = System.currentTimeMillis();
        cache.removeIf(entry -> entry.getExpirationTime() < now);
    }
    
    // 清空緩存
    public void clear() {
        synchronized (cache) {
            cache.clear();
        }
    }
    
    // 獲取緩存統計
    public CacheStatistics getStatistics() {
        synchronized (cache) {
            cleanupExpired();
            return new CacheStatistics(cache.size(), maxSize, getHitRatio());
        }
    }
    
    private double getHitRatio() {
        // 簡化實現，實際應用中需要跟蹤命中率
        return 0.85; // 示例值
    }
    
    // 緩存項
    private static class CacheEntry<T> {
        private final T key;
        private final Object value;
        private final long expirationTime;
        
        public CacheEntry(T key, Object value, long expirationTime) {
            this.key = key;
            this.value = value;
            this.expirationTime = expirationTime;
        }
        
        public boolean isExpired() {
            return System.currentTimeMillis() > expirationTime;
        }
        
        // Getters
        public T getKey() { return key; }
        public Object getValue() { return value; }
        public long getExpirationTime() { return expirationTime; }
    }
    
    // 統計信息
    public static class CacheStatistics {
        private final int currentSize;
        private final int maxSize;
        private final double hitRatio;
        
        public CacheStatistics(int currentSize, int maxSize, double hitRatio) {
            this.currentSize = currentSize;
            this.maxSize = maxSize;
            this.hitRatio = hitRatio;
        }
        
        // Getters
        public int getCurrentSize() { return currentSize; }
        public int getMaxSize() { return maxSize; }
        public double getHitRatio() { return hitRatio; }
    }
}

3. 分數排名系統

public class LeaderboardSystem {
    
    private final TreeSet<Player> leaderboard;
    private final Map<String, Player> playerMap;
    private final int maxSize;
    
    public LeaderboardSystem(int maxSize) {
        // 按分數降序排列，分數相同時按名稱升序
        this.leaderboard = new TreeSet<>(
            Comparator.comparing(Player::getScore, Comparator.reverseOrder())
                .thenComparing(Player::getName)
        );
        this.playerMap = new ConcurrentHashMap<>();
        this.maxSize = maxSize;
    }
    
    // 更新玩家分數
    public void updateScore(String playerName, int score) {
        synchronized (leaderboard) {
            // 移除舊記錄
            Player oldPlayer = playerMap.get(playerName);
            if (oldPlayer != null) {
                leaderboard.remove(oldPlayer);
            }
            
            // 添加新記錄
            Player newPlayer = new Player(playerName, score, System.currentTimeMillis());
            leaderboard.add(newPlayer);
            playerMap.put(playerName, newPlayer);
            
            // 保持排行榜大小
            if (leaderboard.size() > maxSize) {
                Player removed = leaderboard.pollLast();
                playerMap.remove(removed.getName());
            }
        }
    }
    
    // 獲取排行榜
    public List<Player> getLeaderboard() {
        synchronized (leaderboard) {
            return new ArrayList<>(leaderboard);
        }
    }
    
    // 獲取前 N 名
    public List<Player> getTopN(int n) {
        synchronized (leaderboard) {
            return leaderboard.stream()
                    .limit(n)
                    .collect(Collectors.toList());
        }
    }
    
    // 獲取玩家排名
    public int getPlayerRank(String playerName) {
        synchronized (leaderboard) {
            Player player = playerMap.get(playerName);
            if (player == null) {
                return -1;
            }
            
            return leaderboard.headSet(player, false).size() + 1;
        }
    }
    
    // 獲取玩家分數
    public int getPlayerScore(String playerName) {
        Player player = playerMap.get(playerName);
        return player != null ? player.getScore() : -1;
    }
    
    // 獲取分數範圍內的玩家
    public List<Player> getPlayersInScoreRange(int minScore, int maxScore) {
        synchronized (leaderboard) {
            // 創建邊界對象
            Player minPlayer = new Player("", minScore, 0);
            Player maxPlayer = new Player("", maxScore, 0);
            
            return leaderboard.subSet(maxPlayer, true, minPlayer, true)
                    .stream()
                    .filter(p -> p.getScore() >= minScore && p.getScore() <= maxScore)
                    .collect(Collectors.toList());
        }
    }
    
    // 獲取玩家周圍的排名
    public List<Player> getPlayersAround(String playerName, int radius) {
        synchronized (leaderboard) {
            Player player = playerMap.get(playerName);
            if (player == null) {
                return new ArrayList<>();
            }
            
            List<Player> result = new ArrayList<>();
            
            // 獲取前面的玩家
            NavigableSet<Player> before = leaderboard.headSet(player, false);
            before.descendingSet().stream()
                    .limit(radius)
                    .forEach(result::add);
            
            Collections.reverse(result);
            
            // 添加當前玩家
            result.add(player);
            
            // 獲取後面的玩家
            NavigableSet<Player> after = leaderboard.tailSet(player, false);
            after.stream()
                    .limit(radius)
                    .forEach(result::add);
            
            return result;
        }
    }
    
    // 移除玩家
    public boolean removePlayer(String playerName) {
        synchronized (leaderboard) {
            Player player = playerMap.remove(playerName);
            if (player != null) {
                return leaderboard.remove(player);
            }
            return false;
        }
    }
    
    // 清空排行榜
    public void clear() {
        synchronized (leaderboard) {
            leaderboard.clear();
            playerMap.clear();
        }
    }
    
    // 獲取統計信息
    public LeaderboardStatistics getStatistics() {
        synchronized (leaderboard) {
            if (leaderboard.isEmpty()) {
                return new LeaderboardStatistics(0, 0, 0, 0);
            }
            
            int totalPlayers = leaderboard.size();
            int highestScore = leaderboard.first().getScore();
            int lowestScore = leaderboard.last().getScore();
            double averageScore = leaderboard.stream()
                    .mapToInt(Player::getScore)
                    .average()
                    .orElse(0.0);
            
            return new LeaderboardStatistics(totalPlayers, highestScore, lowestScore, averageScore);
        }
    }
    
    // 玩家類
    public static class Player {
        private final String name;
        private final int score;
        private final long timestamp;
        
        public Player(String name, int score, long timestamp) {
            this.name = name;
            this.score = score;
            this.timestamp = timestamp;
        }
        
        // Getters
        public String getName() { return name; }
        public int getScore() { return score; }
        public long getTimestamp() { return timestamp; }
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Player player = (Player) obj;
            return score == player.score && 
                   Objects.equals(name, player.name);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, score);
        }
        
        @Override
        public String toString() {
            return String.format("Player{name='%s', score=%d}", name, score);
        }
    }
    
    // 統計信息
    public static class LeaderboardStatistics {
        private final int totalPlayers;
        private final int highestScore;
        private final int lowestScore;
        private final double averageScore;
        
        public LeaderboardStatistics(int totalPlayers, int highestScore, int lowestScore, double averageScore) {
            this.totalPlayers = totalPlayers;
            this.highestScore = highestScore;
            this.lowestScore = lowestScore;
            this.averageScore = averageScore;
        }
        
        // Getters
        public int getTotalPlayers() { return totalPlayers; }
        public int getHighestScore() { return highestScore; }
        public int getLowestScore() { return lowestScore; }
        public double getAverageScore() { return averageScore; }
    }
}

效能分析與優化

1. 時間複雜度分析

public class TreeSetPerformanceAnalysis {
    
    public static void main(String[] args) {
        performanceComparison();
        memoryAnalysis();
        concurrencyTest();
    }
    
    // 效能比較
    private static void performanceComparison() {
        int[] sizes = {1000, 10000, 100000, 1000000};
        
        for (int size : sizes) {
            System.out.println("Size: " + size);
            
            // TreeSet 測試
            long startTime = System.nanoTime();
            TreeSet<Integer> treeSet = new TreeSet<>();
            for (int i = 0; i < size; i++) {
                treeSet.add(i);
            }
            long treeSetInsertTime = System.nanoTime() - startTime;
            
            // 搜索測試
            startTime = System.nanoTime();
            for (int i = 0; i < 1000; i++) {
                treeSet.contains(i * size / 1000);
            }
            long treeSetSearchTime = System.nanoTime() - startTime;
            
            // HashSet 比較
            startTime = System.nanoTime();
            HashSet<Integer> hashSet = new HashSet<>();
            for (int i = 0; i < size; i++) {
                hashSet.add(i);
            }
            long hashSetInsertTime = System.nanoTime() - startTime;
            
            startTime = System.nanoTime();
            for (int i = 0; i < 1000; i++) {
                hashSet.contains(i * size / 1000);
            }
            long hashSetSearchTime = System.nanoTime() - startTime;
            
            System.out.printf("TreeSet - Insert: %d ns, Search: %d ns\n", 
                            treeSetInsertTime, treeSetSearchTime);
            System.out.printf("HashSet - Insert: %d ns, Search: %d ns\n\n", 
                            hashSetInsertTime, hashSetSearchTime);
        }
    }
    
    // 記憶體分析
    private static void memoryAnalysis() {
        Runtime runtime = Runtime.getRuntime();
        
        runtime.gc();
        long beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        
        TreeSet<Integer> treeSet = new TreeSet<>();
        for (int i = 0; i < 100000; i++) {
            treeSet.add(i);
        }
        
        long afterMemory = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("TreeSet memory usage: " + (afterMemory - beforeMemory) + " bytes");
        
        // 對比 HashSet
        runtime.gc();
        beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        
        HashSet<Integer> hashSet = new HashSet<>();
        for (int i = 0; i < 100000; i++) {
            hashSet.add(i);
        }
        
        afterMemory = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("HashSet memory usage: " + (afterMemory - beforeMemory) + " bytes");
    }
    
    // 並發測試
    private static void concurrencyTest() {
        TreeSet<Integer> treeSet = new TreeSet<>();
        ConcurrentSkipListSet<Integer> concurrentSet = new ConcurrentSkipListSet<>();
        
        // 填充初始數據
        for (int i = 0; i < 10000; i++) {
            treeSet.add(i);
            concurrentSet.add(i);
        }
        
        // 並發讀取測試
        int threadCount = 4;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        
        System.out.println("Concurrent read test:");
        
        // TreeSet 同步讀取
        long startTime = System.nanoTime();
        CountDownLatch latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < 10000; j++) {
                        synchronized (treeSet) {
                            treeSet.contains(j);
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }
        
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        long treeSetTime = System.nanoTime() - startTime;
        System.out.println("TreeSet (synchronized): " + treeSetTime + " ns");
        
        // ConcurrentSkipListSet 測試
        startTime = System.nanoTime();
        latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < 10000; j++) {
                        concurrentSet.contains(j);
                    }
                } finally {
                    latch.countDown();
                }
            });
        }
        
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        long concurrentSetTime = System.nanoTime() - startTime;
        System.out.println("ConcurrentSkipListSet: " + concurrentSetTime + " ns");
        
        executor.shutdown();
    }
}

2. 最佳化建議

public class TreeSetOptimizationTips {
    
    // 1. 使用適當的比較器
    public static void comparatorOptimization() {
        // 避免在比較器中進行複雜計算
        TreeSet<String> badExample = new TreeSet<>((s1, s2) -> {
            // 壞例子：每次比較都進行昂貴的計算
            return expensiveCalculation(s1) - expensiveCalculation(s2);
        });
        
        // 好例子：預先計算或使用緩存
        Map<String, Integer> cache = new ConcurrentHashMap<>();
        TreeSet<String> goodExample = new TreeSet<>((s1, s2) -> {
            int val1 = cache.computeIfAbsent(s1, TreeSetOptimizationTips::expensiveCalculation);
            int val2 = cache.computeIfAbsent(s2, TreeSetOptimizationTips::expensiveCalculation);
            return val1 - val2;
        });
    }
    
    // 2. 批量操作優化
    public static void batchOperationOptimization() {
        TreeSet<Integer> treeSet = new TreeSet<>();
        
        // 批量添加比單個添加效率更高
        Collection<Integer> batchData = Arrays.asList(1, 2, 3, 4, 5);
        treeSet.addAll(batchData);
        
        // 使用子集合進行批量操作
        NavigableSet<Integer> subSet = treeSet.subSet(2, true, 4, false);
        subSet.clear(); // 比逐個刪除效率更高
    }
    
    // 3. 記憶體優化
    public static void memoryOptimization() {
        // 使用原始類型包裝器時注意自動裝箱
        TreeSet<Integer> set = new TreeSet<>();
        
        // 避免不必要的對象創建
        for (int i = 0; i < 1000; i++) {
            set.add(i); // 會創建 Integer 對象
        }
        
        // 考慮使用專門的原始類型集合庫
        // 如 Eclipse Collections 的 IntSortedSet
    }
    
    // 4. 並發優化
    public static void concurrencyOptimization() {
        TreeSet<Integer> treeSet = new TreeSet<>();
        
        // 使用 ConcurrentSkipListSet 替代同步的 TreeSet
        ConcurrentSkipListSet<Integer> concurrentSet = new ConcurrentSkipListSet<>();
        
        // 或者使用讀寫鎖
        ReadWriteLock lock = new ReentrantReadWriteLock();
        ReadLock readLock = lock.readLock();
        WriteLock writeLock = lock.writeLock();
        
        // 讀操作
        readLock.lock();
        try {
            treeSet.contains(1);
        } finally {
            readLock.unlock();
        }
        
        // 寫操作
        writeLock.lock();
        try {
            treeSet.add(1);
        } finally {
            writeLock.unlock();
        }
    }
    
    private static int expensiveCalculation(String s) {
        // 模擬昂貴的計算
        return s.hashCode() * 31;
    }
}

實際應用場景

1. LeetCode 問題解決

public class TreeSetLeetCodeSolutions {
    
    // LeetCode 1845: 座位預約管理系統
    static class SeatManager {
        private TreeSet<Integer> availableSeats;
        
        public SeatManager(int n) {
            availableSeats = new TreeSet<>();
            for (int i = 1; i <= n; i++) {
                availableSeats.add(i);
            }
        }
        
        public int reserve() {
            return availableSeats.pollFirst();
        }
        
        public void unreserve(int seatNumber) {
            availableSeats.add(seatNumber);
        }
    }
    
    // LeetCode 855: 考場就座
    static class ExamRoom {
        private TreeSet<Integer> seats;
        private int n;
        
        public ExamRoom(int n) {
            this.n = n;
            this.seats = new TreeSet<>();
        }
        
        public int seat() {
            int seat = 0;
            if (!seats.isEmpty()) {
                int maxDistance = seats.first();
                
                // 檢查中間位置
                Integer prev = null;
                for (Integer s : seats) {
                    if (prev != null) {
                        int distance = (s - prev) / 2;
                        if (distance > maxDistance) {
                            maxDistance = distance;
                            seat = prev + distance;
                        }
                    }
                    prev = s;
                }
                
                // 檢查最後位置
                if (n - 1 - seats.last() > maxDistance) {
                    seat = n - 1;
                }
            }
            
            seats.add(seat);
            return seat;
        }
        
        public void leave(int p) {
            seats.remove(p);
        }
    }
    
    // LeetCode 895: 最大頻率棧
    static class FreqStack {
        private TreeSet<Element> elements;
        private Map<Integer, Integer> freq;
        private int timestamp;
        
        public FreqStack() {
            elements = new TreeSet<>((a, b) -> {
                if (a.frequency != b.frequency) {
                    return b.frequency - a.frequency; // 頻率降序
                }
                return b.timestamp - a.timestamp; // 時間降序
            });
            freq = new HashMap<>();
            timestamp = 0;
        }
        
        public void push(int x) {
            int oldFreq = freq.getOrDefault(x, 0);
            int newFreq = oldFreq + 1;
            
            if (oldFreq > 0) {
                elements.remove(new Element(x, oldFreq, -1));
            }
            
            elements.add(new Element(x, newFreq, timestamp++));
            freq.put(x, newFreq);
        }
        
        public int pop() {
            Element top = elements.pollFirst();
            int val = top.value;
            int newFreq = freq.get(val) - 1;
            
            if (newFreq > 0) {
                freq.put(val, newFreq);
                elements.add(new Element(val, newFreq, timestamp++));
            } else {
                freq.remove(val);
            }
            
            return val;
        }
        
        static class Element {
            int value;
            int frequency;
            int timestamp;
            
            Element(int value, int frequency, int timestamp) {
                this.value = value;
                this.frequency = frequency;
                this.timestamp = timestamp;
            }
            
            @Override
            public boolean equals(Object obj) {
                if (this == obj) return true;
                if (obj == null || getClass() != obj.getClass()) return false;
                Element element = (Element) obj;
                return value == element.value && frequency == element.frequency;
            }
            
            @Override
            public int hashCode() {
                return Objects.hash(value, frequency);
            }
        }
    }
    
    // LeetCode 1499: 滿足不等式的最大值
    public int findMaxValueOfEquation(int[][] points, int k) {
        // 使用 TreeSet 維護滑動窗口
        TreeSet<Point> window = new TreeSet<>((a, b) -> {
            if (a.yMinusX != b.yMinusX) {
                return b.yMinusX - a.yMinusX; // 按 y-x 降序
            }
            return a.x - b.x; // 按 x 升序
        });
        
        int maxValue = Integer.MIN_VALUE;
        
        for (int[] point : points) {
            int x = point[0];
            int y = point[1];
            
            // 移除窗口外的點
            window.removeIf(p -> x - p.x > k);
            
            // 如果窗口不為空，計算最大值
            if (!window.isEmpty()) {
                Point best = window.first();
                maxValue = Math.max(maxValue, y + x + best.yMinusX);
            }
            
            // 添加當前點
            window.add(new Point(x, y - x));
        }
        
        return maxValue;
    }
    
    static class Point {
        int x;
        int yMinusX;
        
        Point(int x, int yMinusX) {
            this.x = x;
            this.yMinusX = yMinusX;
        }
    }
}

2. 數據結構應用

public class TreeSetDataStructureApplications {
    
    // 滑動窗口最大值
    public static class SlidingWindowMaximum {
        private TreeSet<Element> window;
        private int windowSize;
        private int index;
        
        public SlidingWindowMaximum(int windowSize) {
            this.window = new TreeSet<>((a, b) -> {
                if (a.value != b.value) {
                    return b.value - a.value; // 值降序
                }
                return a.index - b.index; // 索引升序
            });
            this.windowSize = windowSize;
            this.index = 0;
        }
        
        public void addNumber(int num) {
            // 添加新元素
            window.add(new Element(num, index));
            
            // 移除窗口外的元素
            if (index >= windowSize) {
                window.removeIf(e -> e.index <= index - windowSize);
            }
            
            index++;
        }
        
        public int getMaximum() {
            return window.isEmpty() ? 0 : window.first().value;
        }
        
        static class Element {
            int value;
            int index;
            
            Element(int value, int index) {
                this.value = value;
                this.index = index;
            }
        }
    }
    
    // 動態中位數
    public static class DynamicMedian {
        private TreeSet<Element> elements;
        private int index;
        
        public DynamicMedian() {
            this.elements = new TreeSet<>((a, b) -> {
                if (a.value != b.value) {
                    return a.value - b.value; // 值升序
                }
                return a.index - b.index; // 索引升序
            });
            this.index = 0;
        }
        
        public void addNumber(int num) {
            elements.add(new Element(num, index++));
        }
        
        public double getMedian() {
            int size = elements.size();
            if (size == 0) return 0;
            
            List<Element> sortedElements = new ArrayList<>(elements);
            
            if (size % 2 == 1) {
                return sortedElements.get(size / 2).value;
            } else {
                return (sortedElements.get(size / 2 - 1).value + 
                        sortedElements.get(size / 2).value) / 2.0;
            }
        }
        
        static class Element {
            int value;
            int index;
            
            Element(int value, int index) {
                this.value = value;
                this.index = index;
            }
        }
    }
    
    // 區間調度
    public static class IntervalScheduler {
        private TreeSet<Interval> intervals;
        
        public IntervalScheduler() {
            this.intervals = new TreeSet<>(Comparator.comparing(Interval::getStart));
        }
        
        public boolean canSchedule(int start, int end) {
            Interval newInterval = new Interval(start, end);
            
            // 檢查是否與現有區間重疊
            Interval floor = intervals.floor(newInterval);
            if (floor != null && floor.getEnd() > start) {
                return false;
            }
            
            Interval ceiling = intervals.ceiling(newInterval);
            if (ceiling != null && ceiling.getStart() < end) {
                return false;
            }
            
            return true;
        }
        
        public boolean schedule(int start, int end) {
            if (canSchedule(start, end)) {
                intervals.add(new Interval(start, end));
                return true;
            }
            return false;
        }
        
        public List<Interval> getSchedule() {
            return new ArrayList<>(intervals);
        }
        
        static class Interval {
            private final int start;
            private final int end;
            
            public Interval(int start, int end) {
                this.start = start;
                this.end = end;
            }
            
            public int getStart() { return start; }
            public int getEnd() { return end; }
            
            @Override
            public boolean equals(Object obj) {
                if (this == obj) return true;
                if (obj == null || getClass() != obj.getClass()) return false;
                Interval interval = (Interval) obj;
                return start == interval.start && end == interval.end;
            }
            
            @Override
            public int hashCode() {
                return Objects.hash(start, end);
            }
        }
    }
}

最佳實踐與建議

1. 選擇適當的比較策略

public class TreeSetBestPractices {
    
    // 1. 自然排序 vs 自定義比較器
    public static void comparatorChoice() {
        // 對於實現 Comparable 的類型，使用自然排序
        TreeSet<String> naturalOrder = new TreeSet<>();
        
        // 對於需要自定義排序的情況，使用比較器
        TreeSet<String> customOrder = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
        
        // 複雜對象的多字段排序
        TreeSet<Person> personSet = new TreeSet<>(
            Comparator.comparing(Person::getAge)
                .thenComparing(Person::getName)
        );
    }
    
    // 2. 空值處理
    public static void nullHandling() {
        // TreeSet 不允許 null 元素
        TreeSet<String> set = new TreeSet<>();
        // set.add(null); // 會拋出 NullPointerException
        
        // 如果需要支持 null 值，使用自定義比較器
        TreeSet<String> nullSafeSet = new TreeSet<>((s1, s2) -> {
            if (s1 == null && s2 == null) return 0;
            if (s1 == null) return -1;
            if (s2 == null) return 1;
            return s1.compareTo(s2);
        });
    }
    
    // 3. 線程安全處理
    public static void threadSafety() {
        TreeSet<Integer> treeSet = new TreeSet<>();
        
        // 方法1：使用 Collections.synchronizedSet
        Set<Integer> syncSet = Collections.synchronizedSet(treeSet);
        
        // 方法2：使用 ConcurrentSkipListSet
        ConcurrentSkipListSet<Integer> concurrentSet = new ConcurrentSkipListSet<>();
        
        // 方法3：使用讀寫鎖
        ReadWriteLock lock = new ReentrantReadWriteLock();
        // 在讀寫操作時使用相應的鎖
    }
    
    // 4. 效能考慮
    public static void performanceConsiderations() {
        // 批量添加比單個添加效率更高
        Collection<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
        TreeSet<Integer> treeSet = new TreeSet<>(data);
        
        // 避免頻繁的範圍查詢操作
        NavigableSet<Integer> subSet = treeSet.subSet(2, true, 4, false);
        // 對 subSet 的操作會影響原始 set
    }
    
    static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String getName() { return name; }
        public int getAge() { return age; }
    }
}

2. 常見錯誤避免

public class TreeSetCommonMistakes {
    
    // 錯誤1：在迭代過程中修改 TreeSet
    public static void avoidConcurrentModification() {
        TreeSet<Integer> set = new TreeSet<>();
        for (int i = 0; i < 10; i++) {
            set.add(i);
        }
        
        // 錯誤的做法
        // for (Integer value : set) {
        //     if (value % 2 == 0) {
        //         set.remove(value); // ConcurrentModificationException
        //     }
        // }
        
        // 正確的做法1：使用迭代器
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            if (iterator.next() % 2 == 0) {
                iterator.remove();
            }
        }
        
        // 正確的做法2：收集要刪除的元素
        Set<Integer> toRemove = set.stream()
                .filter(value -> value % 2 == 0)
                .collect(Collectors.toSet());
        set.removeAll(toRemove);
    }
    
    // 錯誤2：比較器不一致
    public static void avoidInconsistentComparator() {
        // 錯誤：比較器與 equals 不一致
        TreeSet<String> badSet = new TreeSet<>((s1, s2) -> {
            return s1.length() - s2.length(); // 只比較長度
        });
        
        badSet.add("abc");
        badSet.add("def"); // 會被忽略，因為長度相同
        
        // 正確：確保比較器一致性
        TreeSet<String> goodSet = new TreeSet<>((s1, s2) -> {
            int lengthCompare = s1.length() - s2.length();
            if (lengthCompare != 0) {
                return lengthCompare;
            }
            return s1.compareTo(s2); // 長度相同時比較內容
        });
    }
    
    // 錯誤3：誤用子集合
    public static void avoidSubSetMisuse() {
        TreeSet<Integer> set = new TreeSet<>();
        for (int i = 0; i < 10; i++) {
            set.add(i);
        }
        
        // 錯誤：認為子集合是獨立的
        NavigableSet<Integer> subSet = set.subSet(2, true, 8, false);
        subSet.clear(); // 這會影響原始 set
        
        // 正確：如果需要獨立的副本
        NavigableSet<Integer> independentCopy = new TreeSet<>(subSet);
    }
}

總結

TreeSet 是 Java 集合框架中功能強大的有序集合實現，基於紅黑樹提供了 O(log n) 的高效操作。通過本文的深入分析，我們了解了：

Java TreeMap 完整實作指南：紅黑樹有序映射與 NavigableMap 介面詳解

Sun, 31 Oct 2021 19:16:31 +0800

Java TreeMap 完整實作指南

簡介

TreeMap 是 Java 集合框架中實現有序映射的核心類別，基於紅黑樹（Red-Black Tree）數據結構實現。它提供了 O(log n) 的時間複雜度進行搜索、插入和刪除操作，並保證鍵的有序性。本文將深入探討 TreeMap 的內部實現、各種方法使用、效能特性以及在企業級開發中的最佳實踐。

TreeMap 架構與繼承關係

類別繼承結構

Map<K,V>
   ↑
SortedMap<K,V> 
   ↑
NavigableMap<K,V>
   ↑
TreeMap<K,V>

核心介面關係

// 基本映射介面
public interface Map<K,V> {
    V put(K key, V value);
    V get(Object key);
    V remove(Object key);
    boolean containsKey(Object key);
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
}

// 有序映射介面
public interface SortedMap<K,V> extends Map<K,V> {
    Comparator<? super K> comparator();
    SortedMap<K,V> subMap(K fromKey, K toKey);
    SortedMap<K,V> headMap(K toKey);
    SortedMap<K,V> tailMap(K fromKey);
    K firstKey();
    K lastKey();
}

// 可導航映射介面
public interface NavigableMap<K,V> extends SortedMap<K,V> {
    Map.Entry<K,V> lowerEntry(K key);
    K lowerKey(K key);
    Map.Entry<K,V> floorEntry(K key);
    K floorKey(K key);
    Map.Entry<K,V> ceilingEntry(K key);
    K ceilingKey(K key);
    Map.Entry<K,V> higherEntry(K key);
    K higherKey(K key);
    Map.Entry<K,V> firstEntry();
    Map.Entry<K,V> lastEntry();
    Map.Entry<K,V> pollFirstEntry();
    Map.Entry<K,V> pollLastEntry();
    NavigableMap<K,V> descendingMap();
    NavigableSet<K> navigableKeySet();
    NavigableSet<K> descendingKeySet();
}

TreeMap 核心特性

1. 紅黑樹實現

// TreeMap 內部節點結構
static final class Entry<K,V> implements Map.Entry<K,V> {
    K key;
    V value;
    Entry<K,V> left;
    Entry<K,V> right;
    Entry<K,V> parent;
    boolean color = BLACK;
    
    Entry(K key, V value, Entry<K,V> parent) {
        this.key = key;
        this.value = value;
        this.parent = parent;
    }
}

// 紅黑樹顏色常量
private static final boolean RED = false;
private static final boolean BLACK = true;

// 根節點和大小
private transient Entry<K,V> root;
private transient int size = 0;
private transient int modCount = 0;

// 比較器
private final Comparator<? super K> comparator;

2. 自然排序與自定義比較器

// 自然排序 TreeMap
TreeMap<String, Integer> naturalOrder = new TreeMap<>();
naturalOrder.put("Charlie", 3);
naturalOrder.put("Alice", 1);
naturalOrder.put("Bob", 2);
// 結果：{Alice=1, Bob=2, Charlie=3}

// 自定義比較器
TreeMap<String, Integer> customOrder = new TreeMap<>(
    (s1, s2) -> s2.compareTo(s1) // 降序
);
customOrder.put("Charlie", 3);
customOrder.put("Alice", 1);
customOrder.put("Bob", 2);
// 結果：{Charlie=3, Bob=2, Alice=1}

// 複雜對象比較器
TreeMap<Student, String> studentMap = new TreeMap<>(
    Comparator.comparing(Student::getGrade)
        .thenComparing(Student::getName)
);

SortedMap 介面詳解

基本方法實現

public class TreeMapSortedExample {
    
    public static void main(String[] args) {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        
        // 添加元素
        treeMap.put(5, "Five");
        treeMap.put(2, "Two");
        treeMap.put(8, "Eight");
        treeMap.put(1, "One");
        treeMap.put(9, "Nine");
        
        // 基本排序方法
        demonstrateSortedMapMethods(treeMap);
    }
    
    private static void demonstrateSortedMapMethods(TreeMap<Integer, String> map) {
        System.out.println("Original map: " + map);
        
        // 獲取比較器
        Comparator<? super Integer> comparator = map.comparator();
        System.out.println("Comparator: " + comparator); // null (natural ordering)
        
        // 第一個和最後一個鍵
        System.out.println("First key: " + map.firstKey()); // 1
        System.out.println("Last key: " + map.lastKey());   // 9
        
        // 子映射（含頭不含尾）
        SortedMap<Integer, String> subMap = map.subMap(2, 8);
        System.out.println("SubMap [2, 8): " + subMap); // {2=Two, 5=Five}
        
        // 頭部映射（不包含指定鍵）
        SortedMap<Integer, String> headMap = map.headMap(5);
        System.out.println("HeadMap (< 5): " + headMap); // {1=One, 2=Two}
        
        // 尾部映射（包含指定鍵）
        SortedMap<Integer, String> tailMap = map.tailMap(5);
        System.out.println("TailMap (>= 5): " + tailMap); // {5=Five, 8=Eight, 9=Nine}
        
        // 鍵集合、值集合、條目集合
        System.out.println("Keys: " + map.keySet());
        System.out.println("Values: " + map.values());
        System.out.println("Entries: " + map.entrySet());
    }
}

NavigableMap 介面詳解

導航方法實現

public class TreeMapNavigableExample {
    
    public static void main(String[] args) {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        
        // 添加測試數據
        treeMap.put(1, "One");
        treeMap.put(3, "Three");
        treeMap.put(5, "Five");
        treeMap.put(7, "Seven");
        treeMap.put(9, "Nine");
        
        demonstrateNavigableMethods(treeMap);
    }
    
    private static void demonstrateNavigableMethods(TreeMap<Integer, String> map) {
        System.out.println("Original map: " + map);
        
        // Lower 方法：返回嚴格小於指定鍵的最大鍵
        Map.Entry<Integer, String> lowerEntry = map.lowerEntry(5);
        System.out.println("Lower entry (< 5): " + lowerEntry); // 3=Three
        
        Integer lowerKey = map.lowerKey(5);
        System.out.println("Lower key (< 5): " + lowerKey); // 3
        
        // Floor 方法：返回小於或等於指定鍵的最大鍵
        Map.Entry<Integer, String> floorEntry = map.floorEntry(4);
        System.out.println("Floor entry (<= 4): " + floorEntry); // 3=Three
        
        Map.Entry<Integer, String> floorEntry2 = map.floorEntry(5);
        System.out.println("Floor entry (<= 5): " + floorEntry2); // 5=Five
        
        // Ceiling 方法：返回大於或等於指定鍵的最小鍵
        Map.Entry<Integer, String> ceilingEntry = map.ceilingEntry(4);
        System.out.println("Ceiling entry (>= 4): " + ceilingEntry); // 5=Five
        
        Map.Entry<Integer, String> ceilingEntry2 = map.ceilingEntry(5);
        System.out.println("Ceiling entry (>= 5): " + ceilingEntry2); // 5=Five
        
        // Higher 方法：返回嚴格大於指定鍵的最小鍵
        Map.Entry<Integer, String> higherEntry = map.higherEntry(5);
        System.out.println("Higher entry (> 5): " + higherEntry); // 7=Seven
        
        // 首尾條目
        Map.Entry<Integer, String> firstEntry = map.firstEntry();
        Map.Entry<Integer, String> lastEntry = map.lastEntry();
        System.out.println("First entry: " + firstEntry); // 1=One
        System.out.println("Last entry: " + lastEntry);   // 9=Nine
        
        // 彈出首尾條目（會刪除元素）
        TreeMap<Integer, String> copyMap = new TreeMap<>(map);
        Map.Entry<Integer, String> pollFirst = copyMap.pollFirstEntry();
        Map.Entry<Integer, String> pollLast = copyMap.pollLastEntry();
        System.out.println("Poll first: " + pollFirst); // 1=One
        System.out.println("Poll last: " + pollLast);   // 9=Nine
        System.out.println("After polling: " + copyMap); // {3=Three, 5=Five, 7=Seven}
        
        // 降序視圖
        NavigableMap<Integer, String> descendingMap = map.descendingMap();
        System.out.println("Descending map: " + descendingMap);
        
        // 導航鍵集合
        NavigableSet<Integer> navigableKeySet = map.navigableKeySet();
        NavigableSet<Integer> descendingKeySet = map.descendingKeySet();
        System.out.println("Navigable key set: " + navigableKeySet);
        System.out.println("Descending key set: " + descendingKeySet);
        
        // 範圍視圖
        NavigableMap<Integer, String> rangeMap = map.subMap(3, true, 7, false);
        System.out.println("Range [3, 7): " + rangeMap); // {3=Three, 5=Five}
        
        NavigableMap<Integer, String> headMap = map.headMap(5, true);
        System.out.println("Head map (<= 5): " + headMap); // {1=One, 3=Three, 5=Five}
        
        NavigableMap<Integer, String> tailMap = map.tailMap(5, false);
        System.out.println("Tail map (> 5): " + tailMap); // {7=Seven, 9=Nine}
    }
}

企業級應用實例

1. 時間序列數據管理

public class TimeSeriesDataManager {
    
    private final TreeMap<LocalDateTime, Double> timeSeriesData;
    
    public TimeSeriesDataManager() {
        this.timeSeriesData = new TreeMap<>();
    }
    
    // 添加數據點
    public void addDataPoint(LocalDateTime timestamp, Double value) {
        timeSeriesData.put(timestamp, value);
    }
    
    // 獲取指定時間範圍的數據
    public NavigableMap<LocalDateTime, Double> getDataInRange(
            LocalDateTime startTime, LocalDateTime endTime) {
        return timeSeriesData.subMap(startTime, true, endTime, true);
    }
    
    // 獲取最新數據
    public Map.Entry<LocalDateTime, Double> getLatestData() {
        return timeSeriesData.lastEntry();
    }
    
    // 獲取指定時間之前的最新數據
    public Map.Entry<LocalDateTime, Double> getLatestDataBefore(LocalDateTime time) {
        return timeSeriesData.lowerEntry(time);
    }
    
    // 獲取指定時間之後的最早數據
    public Map.Entry<LocalDateTime, Double> getEarliestDataAfter(LocalDateTime time) {
        return timeSeriesData.higherEntry(time);
    }
    
    // 計算時間範圍內的平均值
    public double getAverageInRange(LocalDateTime startTime, LocalDateTime endTime) {
        NavigableMap<LocalDateTime, Double> rangeData = getDataInRange(startTime, endTime);
        return rangeData.values().stream()
                .mapToDouble(Double::doubleValue)
                .average()
                .orElse(0.0);
    }
    
    // 清理舊數據
    public void cleanupOldData(LocalDateTime cutoffTime) {
        timeSeriesData.headMap(cutoffTime, false).clear();
    }
    
    // 獲取數據統計信息
    public DataStatistics getStatistics() {
        if (timeSeriesData.isEmpty()) {
            return new DataStatistics();
        }
        
        DoubleSummaryStatistics stats = timeSeriesData.values().stream()
                .mapToDouble(Double::doubleValue)
                .summaryStatistics();
        
        return new DataStatistics(
            timeSeriesData.firstKey(),
            timeSeriesData.lastKey(),
            stats.getCount(),
            stats.getMin(),
            stats.getMax(),
            stats.getAverage()
        );
    }
    
    public static class DataStatistics {
        private final LocalDateTime earliestTime;
        private final LocalDateTime latestTime;
        private final long count;
        private final double min;
        private final double max;
        private final double average;
        
        public DataStatistics() {
            this(null, null, 0, 0, 0, 0);
        }
        
        public DataStatistics(LocalDateTime earliestTime, LocalDateTime latestTime, 
                            long count, double min, double max, double average) {
            this.earliestTime = earliestTime;
            this.latestTime = latestTime;
            this.count = count;
            this.min = min;
            this.max = max;
            this.average = average;
        }
        
        // Getters
        public LocalDateTime getEarliestTime() { return earliestTime; }
        public LocalDateTime getLatestTime() { return latestTime; }
        public long getCount() { return count; }
        public double getMin() { return min; }
        public double getMax() { return max; }
        public double getAverage() { return average; }
    }
}

2. 範圍查詢系統

public class RangeQuerySystem<T extends Comparable<T>, V> {
    
    private final TreeMap<T, V> dataMap;
    private final ReentrantReadWriteLock lock;
    private final ReadLock readLock;
    private final WriteLock writeLock;
    
    public RangeQuerySystem() {
        this.dataMap = new TreeMap<>();
        this.lock = new ReentrantReadWriteLock();
        this.readLock = lock.readLock();
        this.writeLock = lock.writeLock();
    }
    
    // 線程安全的插入操作
    public void put(T key, V value) {
        writeLock.lock();
        try {
            dataMap.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
    
    // 線程安全的獲取操作
    public V get(T key) {
        readLock.lock();
        try {
            return dataMap.get(key);
        } finally {
            readLock.unlock();
        }
    }
    
    // 範圍查詢
    public List<Map.Entry<T, V>> rangeQuery(T start, T end) {
        readLock.lock();
        try {
            return new ArrayList<>(dataMap.subMap(start, true, end, true).entrySet());
        } finally {
            readLock.unlock();
        }
    }
    
    // 前綴查詢
    public List<Map.Entry<T, V>> prefixQuery(T prefix) {
        readLock.lock();
        try {
            NavigableMap<T, V> tailMap = dataMap.tailMap(prefix, true);
            List<Map.Entry<T, V>> result = new ArrayList<>();
            
            for (Map.Entry<T, V> entry : tailMap.entrySet()) {
                if (entry.getKey().toString().startsWith(prefix.toString())) {
                    result.add(entry);
                } else {
                    break;
                }
            }
            
            return result;
        } finally {
            readLock.unlock();
        }
    }
    
    // 獲取最接近的值
    public Map.Entry<T, V> getClosest(T target) {
        readLock.lock();
        try {
            Map.Entry<T, V> floor = dataMap.floorEntry(target);
            Map.Entry<T, V> ceiling = dataMap.ceilingEntry(target);
            
            if (floor == null) return ceiling;
            if (ceiling == null) return floor;
            
            // 比較距離
            if (target.compareTo(floor.getKey()) <= ceiling.getKey().compareTo(target)) {
                return floor;
            } else {
                return ceiling;
            }
        } finally {
            readLock.unlock();
        }
    }
    
    // 批量插入
    public void putAll(Map<T, V> map) {
        writeLock.lock();
        try {
            dataMap.putAll(map);
        } finally {
            writeLock.unlock();
        }
    }
    
    // 條件刪除
    public int removeIf(Predicate<Map.Entry<T, V>> condition) {
        writeLock.lock();
        try {
            List<T> keysToRemove = dataMap.entrySet().stream()
                    .filter(condition)
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());
            
            keysToRemove.forEach(dataMap::remove);
            return keysToRemove.size();
        } finally {
            writeLock.unlock();
        }
    }
    
    // 獲取統計信息
    public RangeStatistics getStatistics() {
        readLock.lock();
        try {
            return new RangeStatistics(
                dataMap.size(),
                dataMap.isEmpty() ? null : dataMap.firstKey(),
                dataMap.isEmpty() ? null : dataMap.lastKey()
            );
        } finally {
            readLock.unlock();
        }
    }
    
    public static class RangeStatistics {
        private final int size;
        private final Object minKey;
        private final Object maxKey;
        
        public RangeStatistics(int size, Object minKey, Object maxKey) {
            this.size = size;
            this.minKey = minKey;
            this.maxKey = maxKey;
        }
        
        // Getters
        public int getSize() { return size; }
        public Object getMinKey() { return minKey; }
        public Object getMaxKey() { return maxKey; }
    }
}

3. 優先級任務調度器

public class PriorityTaskScheduler {
    
    private final TreeMap<Priority, Queue<Task>> taskQueues;
    private final ExecutorService executor;
    private final ScheduledExecutorService scheduler;
    private final AtomicBoolean running;
    
    public PriorityTaskScheduler(int threadPoolSize) {
        this.taskQueues = new TreeMap<>();
        this.executor = Executors.newFixedThreadPool(threadPoolSize);
        this.scheduler = Executors.newScheduledThreadPool(2);
        this.running = new AtomicBoolean(true);
        
        // 初始化優先級隊列
        for (Priority priority : Priority.values()) {
            taskQueues.put(priority, new ConcurrentLinkedQueue<>());
        }
        
        // 啟動任務調度
        startTaskScheduling();
    }
    
    // 提交任務
    public void submitTask(Task task) {
        if (!running.get()) {
            throw new IllegalStateException("Scheduler is shutdown");
        }
        
        taskQueues.get(task.getPriority()).offer(task);
    }
    
    // 提交延遲任務
    public void submitDelayedTask(Task task, long delay, TimeUnit unit) {
        scheduler.schedule(() -> submitTask(task), delay, unit);
    }
    
    // 提交週期性任務
    public void submitPeriodicTask(Task task, long initialDelay, long period, TimeUnit unit) {
        scheduler.scheduleAtFixedRate(() -> {
            if (running.get()) {
                submitTask(task);
            }
        }, initialDelay, period, unit);
    }
    
    // 啟動任務調度
    private void startTaskScheduling() {
        scheduler.scheduleAtFixedRate(this::processNextTask, 0, 10, TimeUnit.MILLISECONDS);
    }
    
    // 處理下一個任務
    private void processNextTask() {
        if (!running.get()) {
            return;
        }
        
        // 從最高優先級開始查找任務
        NavigableMap<Priority, Queue<Task>> descendingMap = taskQueues.descendingMap();
        
        for (Map.Entry<Priority, Queue<Task>> entry : descendingMap.entrySet()) {
            Queue<Task> queue = entry.getValue();
            Task task = queue.poll();
            
            if (task != null) {
                executor.submit(new TaskRunner(task));
                return;
            }
        }
    }
    
    // 獲取隊列統計信息
    public QueueStatistics getQueueStatistics() {
        Map<Priority, Integer> queueSizes = new EnumMap<>(Priority.class);
        int totalTasks = 0;
        
        for (Map.Entry<Priority, Queue<Task>> entry : taskQueues.entrySet()) {
            int size = entry.getValue().size();
            queueSizes.put(entry.getKey(), size);
            totalTasks += size;
        }
        
        return new QueueStatistics(queueSizes, totalTasks);
    }
    
    // 清空指定優先級的任務
    public int clearTasks(Priority priority) {
        Queue<Task> queue = taskQueues.get(priority);
        int size = queue.size();
        queue.clear();
        return size;
    }
    
    // 關閉調度器
    public void shutdown() {
        running.set(false);
        executor.shutdown();
        scheduler.shutdown();
        
        try {
            if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
            if (!scheduler.awaitTermination(30, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    
    // 優先級枚舉
    public enum Priority {
        LOW(1), NORMAL(2), HIGH(3), CRITICAL(4);
        
        private final int value;
        
        Priority(int value) {
            this.value = value;
        }
        
        public int getValue() {
            return value;
        }
    }
    
    // 任務介面
    public interface Task {
        void execute();
        Priority getPriority();
        String getName();
    }
    
    // 任務運行器
    private static class TaskRunner implements Runnable {
        private final Task task;
        
        public TaskRunner(Task task) {
            this.task = task;
        }
        
        @Override
        public void run() {
            try {
                task.execute();
            } catch (Exception e) {
                System.err.println("Task execution failed: " + task.getName());
                e.printStackTrace();
            }
        }
    }
    
    // 隊列統計信息
    public static class QueueStatistics {
        private final Map<Priority, Integer> queueSizes;
        private final int totalTasks;
        
        public QueueStatistics(Map<Priority, Integer> queueSizes, int totalTasks) {
            this.queueSizes = queueSizes;
            this.totalTasks = totalTasks;
        }
        
        public Map<Priority, Integer> getQueueSizes() { return queueSizes; }
        public int getTotalTasks() { return totalTasks; }
    }
}

效能分析與優化

1. 時間複雜度分析

public class TreeMapPerformanceAnalysis {
    
    public static void main(String[] args) {
        performanceComparison();
        memoryAnalysis();
        concurrencyTest();
    }
    
    // 效能比較
    private static void performanceComparison() {
        int[] sizes = {1000, 10000, 100000, 1000000};
        
        for (int size : sizes) {
            System.out.println("Size: " + size);
            
            // TreeMap 測試
            long startTime = System.nanoTime();
            TreeMap<Integer, String> treeMap = new TreeMap<>();
            for (int i = 0; i < size; i++) {
                treeMap.put(i, "value" + i);
            }
            long treeMapInsertTime = System.nanoTime() - startTime;
            
            // 搜索測試
            startTime = System.nanoTime();
            for (int i = 0; i < 1000; i++) {
                treeMap.get(i * size / 1000);
            }
            long treeMapSearchTime = System.nanoTime() - startTime;
            
            // HashMap 比較
            startTime = System.nanoTime();
            HashMap<Integer, String> hashMap = new HashMap<>();
            for (int i = 0; i < size; i++) {
                hashMap.put(i, "value" + i);
            }
            long hashMapInsertTime = System.nanoTime() - startTime;
            
            startTime = System.nanoTime();
            for (int i = 0; i < 1000; i++) {
                hashMap.get(i * size / 1000);
            }
            long hashMapSearchTime = System.nanoTime() - startTime;
            
            System.out.printf("TreeMap - Insert: %d ns, Search: %d ns\n", 
                            treeMapInsertTime, treeMapSearchTime);
            System.out.printf("HashMap - Insert: %d ns, Search: %d ns\n\n", 
                            hashMapInsertTime, hashMapSearchTime);
        }
    }
    
    // 記憶體分析
    private static void memoryAnalysis() {
        Runtime runtime = Runtime.getRuntime();
        
        runtime.gc();
        long beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        for (int i = 0; i < 100000; i++) {
            treeMap.put(i, "value" + i);
        }
        
        long afterMemory = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("TreeMap memory usage: " + (afterMemory - beforeMemory) + " bytes");
        
        // 對比 HashMap
        runtime.gc();
        beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        
        HashMap<Integer, String> hashMap = new HashMap<>();
        for (int i = 0; i < 100000; i++) {
            hashMap.put(i, "value" + i);
        }
        
        afterMemory = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("HashMap memory usage: " + (afterMemory - beforeMemory) + " bytes");
    }
    
    // 並發測試
    private static void concurrencyTest() {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        ConcurrentSkipListMap<Integer, String> concurrentMap = new ConcurrentSkipListMap<>();
        
        // 填充初始數據
        for (int i = 0; i < 10000; i++) {
            treeMap.put(i, "value" + i);
            concurrentMap.put(i, "value" + i);
        }
        
        // 並發讀取測試
        int threadCount = 4;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        
        System.out.println("Concurrent read test:");
        
        // TreeMap 同步讀取
        long startTime = System.nanoTime();
        CountDownLatch latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < 10000; j++) {
                        synchronized (treeMap) {
                            treeMap.get(j);
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }
        
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        long treeMapTime = System.nanoTime() - startTime;
        System.out.println("TreeMap (synchronized): " + treeMapTime + " ns");
        
        // ConcurrentSkipListMap 測試
        startTime = System.nanoTime();
        latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < 10000; j++) {
                        concurrentMap.get(j);
                    }
                } finally {
                    latch.countDown();
                }
            });
        }
        
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        long concurrentMapTime = System.nanoTime() - startTime;
        System.out.println("ConcurrentSkipListMap: " + concurrentMapTime + " ns");
        
        executor.shutdown();
    }
}

2. 最佳化建議

public class TreeMapOptimizationTips {
    
    // 1. 使用適當的比較器
    public static void comparatorOptimization() {
        // 避免在比較器中進行複雜計算
        TreeMap<String, Integer> badExample = new TreeMap<>((s1, s2) -> {
            // 壞例子：每次比較都進行昂貴的計算
            return expensiveCalculation(s1) - expensiveCalculation(s2);
        });
        
        // 好例子：預先計算或使用緩存
        Map<String, Integer> cache = new ConcurrentHashMap<>();
        TreeMap<String, Integer> goodExample = new TreeMap<>((s1, s2) -> {
            int val1 = cache.computeIfAbsent(s1, TreeMapOptimizationTips::expensiveCalculation);
            int val2 = cache.computeIfAbsent(s2, TreeMapOptimizationTips::expensiveCalculation);
            return val1 - val2;
        });
    }
    
    // 2. 批量操作優化
    public static void batchOperationOptimization() {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        
        // 批量插入比單個插入效率更高
        Map<Integer, String> batchData = new HashMap<>();
        for (int i = 0; i < 1000; i++) {
            batchData.put(i, "value" + i);
        }
        treeMap.putAll(batchData);
        
        // 使用子映射進行批量操作
        NavigableMap<Integer, String> subMap = treeMap.subMap(100, true, 200, false);
        subMap.clear(); // 比逐個刪除效率更高
    }
    
    // 3. 記憶體優化
    public static void memoryOptimization() {
        // 使用原始類型包裝器時注意自動裝箱
        TreeMap<Integer, Integer> map = new TreeMap<>();
        
        // 避免不必要的對象創建
        for (int i = 0; i < 1000; i++) {
            map.put(i, i * 2); // 會創建 Integer 對象
        }
        
        // 考慮使用專門的原始類型集合庫（如 Eclipse Collections）
        // 或者使用 TIntIntMap 等原始類型映射
    }
    
    // 4. 並發優化
    public static void concurrencyOptimization() {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        
        // 使用 ConcurrentSkipListMap 替代同步的 TreeMap
        ConcurrentSkipListMap<Integer, String> concurrentMap = new ConcurrentSkipListMap<>();
        
        // 或者使用讀寫鎖
        ReadWriteLock lock = new ReentrantReadWriteLock();
        ReadLock readLock = lock.readLock();
        WriteLock writeLock = lock.writeLock();
        
        // 讀操作
        readLock.lock();
        try {
            treeMap.get(1);
        } finally {
            readLock.unlock();
        }
        
        // 寫操作
        writeLock.lock();
        try {
            treeMap.put(1, "value");
        } finally {
            writeLock.unlock();
        }
    }
    
    private static int expensiveCalculation(String s) {
        // 模擬昂貴的計算
        return s.hashCode() * 31;
    }
}

實際應用場景

1. LeetCode 問題解決

public class TreeMapLeetCodeSolutions {
    
    // LeetCode 2055: 蠟燭之間的盤子
    public int[] platesBetweenCandles(String s, int[][] queries) {
        TreeMap<Integer, Integer> candlePositions = new TreeMap<>();
        
        // 記錄蠟燭位置
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '|') {
                candlePositions.put(i, i);
            }
        }
        
        int[] result = new int[queries.length];
        
        for (int i = 0; i < queries.length; i++) {
            int left = queries[i][0];
            int right = queries[i][1];
            
            // 找到範圍內的第一個和最後一個蠟燭
            Integer firstCandle = candlePositions.ceilingKey(left);
            Integer lastCandle = candlePositions.floorKey(right);
            
            if (firstCandle != null && lastCandle != null && firstCandle <= lastCandle) {
                // 計算蠟燭之間的盤子數量
                int totalLength = lastCandle - firstCandle + 1;
                int candleCount = candlePositions.subMap(firstCandle, true, lastCandle, true).size();
                result[i] = totalLength - candleCount;
            } else {
                result[i] = 0;
            }
        }
        
        return result;
    }
    
    // LeetCode 220: 存在重複元素 III
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeMap<Integer, Integer> window = new TreeMap<>();
        
        for (int i = 0; i < nums.length; i++) {
            int num = nums[i];
            
            // 查找是否存在差值小於等於 t 的數字
            Integer floor = window.floorKey(num);
            Integer ceiling = window.ceilingKey(num);
            
            if ((floor != null && (long) num - floor <= t) || 
                (ceiling != null && (long) ceiling - num <= t)) {
                return true;
            }
            
            // 添加當前數字到窗口
            window.put(num, window.getOrDefault(num, 0) + 1);
            
            // 維護窗口大小
            if (i >= k) {
                int oldNum = nums[i - k];
                window.put(oldNum, window.get(oldNum) - 1);
                if (window.get(oldNum) == 0) {
                    window.remove(oldNum);
                }
            }
        }
        
        return false;
    }
    
    // LeetCode 732: 我的日程安排表 III
    static class MyCalendarThree {
        private TreeMap<Integer, Integer> timeline;
        
        public MyCalendarThree() {
            timeline = new TreeMap<>();
        }
        
        public int book(int start, int end) {
            timeline.put(start, timeline.getOrDefault(start, 0) + 1);
            timeline.put(end, timeline.getOrDefault(end, 0) - 1);
            
            int activeEvents = 0;
            int maxEvents = 0;
            
            for (int count : timeline.values()) {
                activeEvents += count;
                maxEvents = Math.max(maxEvents, activeEvents);
            }
            
            return maxEvents;
        }
    }
}

2. 分佈式系統中的應用

public class DistributedSystemApplications {
    
    // 一致性哈希環
    public static class ConsistentHashRing {
        private final TreeMap<Long, String> ring;
        private final int virtualNodes;
        
        public ConsistentHashRing(int virtualNodes) {
            this.ring = new TreeMap<>();
            this.virtualNodes = virtualNodes;
        }
        
        public void addNode(String node) {
            for (int i = 0; i < virtualNodes; i++) {
                long hash = hash(node + ":" + i);
                ring.put(hash, node);
            }
        }
        
        public void removeNode(String node) {
            for (int i = 0; i < virtualNodes; i++) {
                long hash = hash(node + ":" + i);
                ring.remove(hash);
            }
        }
        
        public String getNode(String key) {
            if (ring.isEmpty()) {
                return null;
            }
            
            long hash = hash(key);
            Map.Entry<Long, String> entry = ring.ceilingEntry(hash);
            
            if (entry == null) {
                entry = ring.firstEntry();
            }
            
            return entry.getValue();
        }
        
        private long hash(String key) {
            return key.hashCode() & 0xFFFFFFFFL;
        }
    }
    
    // 負載平衡器
    public static class LoadBalancer {
        private final TreeMap<Integer, List<String>> weightedServers;
        private final AtomicInteger currentWeight;
        
        public LoadBalancer() {
            this.weightedServers = new TreeMap<>();
            this.currentWeight = new AtomicInteger(0);
        }
        
        public void addServer(String server, int weight) {
            weightedServers.computeIfAbsent(weight, k -> new ArrayList<>()).add(server);
        }
        
        public String selectServer() {
            if (weightedServers.isEmpty()) {
                return null;
            }
            
            // 加權輪詢算法
            int totalWeight = weightedServers.lastKey();
            int current = currentWeight.updateAndGet(w -> (w + 1) % totalWeight);
            
            for (Map.Entry<Integer, List<String>> entry : weightedServers.descendingMap().entrySet()) {
                if (current < entry.getKey()) {
                    List<String> servers = entry.getValue();
                    return servers.get(current % servers.size());
                }
            }
            
            return null;
        }
    }
}

最佳實踐與建議

1. 選擇適當的比較策略

public class TreeMapBestPractices {
    
    // 1. 自然排序 vs 自定義比較器
    public static void comparatorChoice() {
        // 對於實現 Comparable 的類型，使用自然排序
        TreeMap<String, Integer> naturalOrder = new TreeMap<>();
        
        // 對於需要自定義排序的情況，使用比較器
        TreeMap<String, Integer> customOrder = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        
        // 複雜對象的多字段排序
        TreeMap<Person, String> personMap = new TreeMap<>(
            Comparator.comparing(Person::getAge)
                .thenComparing(Person::getName)
        );
    }
    
    // 2. 空值處理
    public static void nullHandling() {
        // TreeMap 不允許 null 鍵
        TreeMap<String, Integer> map = new TreeMap<>();
        // map.put(null, 1); // 會拋出 NullPointerException
        
        // 但允許 null 值
        map.put("key", null);
        
        // 如果需要支持 null 鍵，使用自定義比較器
        TreeMap<String, Integer> nullSafeMap = new TreeMap<>((s1, s2) -> {
            if (s1 == null && s2 == null) return 0;
            if (s1 == null) return -1;
            if (s2 == null) return 1;
            return s1.compareTo(s2);
        });
    }
    
    // 3. 線程安全處理
    public static void threadSafety() {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        
        // 方法1：使用 Collections.synchronizedMap
        Map<Integer, String> syncMap = Collections.synchronizedMap(treeMap);
        
        // 方法2：使用 ConcurrentSkipListMap
        ConcurrentSkipListMap<Integer, String> concurrentMap = new ConcurrentSkipListMap<>();
        
        // 方法3：使用讀寫鎖
        ReadWriteLock lock = new ReentrantReadWriteLock();
        // 在讀寫操作時使用相應的鎖
    }
    
    // 4. 效能考慮
    public static void performanceConsiderations() {
        // 預先指定初始容量（TreeMap 沒有初始容量概念，但可以批量插入）
        Map<Integer, String> initialData = new HashMap<>();
        for (int i = 0; i < 1000; i++) {
            initialData.put(i, "value" + i);
        }
        
        TreeMap<Integer, String> treeMap = new TreeMap<>(initialData);
        
        // 避免頻繁的範圍查詢操作
        NavigableMap<Integer, String> subMap = treeMap.subMap(100, true, 200, false);
        // 對 subMap 的操作會影響原始 map
    }
    
    static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String getName() { return name; }
        public int getAge() { return age; }
    }
}

2. 常見錯誤避免

public class TreeMapCommonMistakes {
    
    // 錯誤1：在迭代過程中修改 TreeMap
    public static void avoidConcurrentModification() {
        TreeMap<Integer, String> map = new TreeMap<>();
        for (int i = 0; i < 10; i++) {
            map.put(i, "value" + i);
        }
        
        // 錯誤的做法
        // for (Integer key : map.keySet()) {
        //     if (key % 2 == 0) {
        //         map.remove(key); // ConcurrentModificationException
        //     }
        // }
        
        // 正確的做法1：使用迭代器
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            if (iterator.next() % 2 == 0) {
                iterator.remove();
            }
        }
        
        // 正確的做法2：收集要刪除的鍵
        List<Integer> keysToRemove = map.keySet().stream()
                .filter(key -> key % 2 == 0)
                .collect(Collectors.toList());
        keysToRemove.forEach(map::remove);
    }
    
    // 錯誤2：比較器不一致
    public static void avoidInconsistentComparator() {
        // 錯誤：比較器與 equals 不一致
        TreeMap<String, Integer> badMap = new TreeMap<>((s1, s2) -> {
            return s1.length() - s2.length(); // 只比較長度
        });
        
        badMap.put("abc", 1);
        badMap.put("def", 2); // 會覆蓋 "abc"，因為長度相同
        
        // 正確：確保比較器一致性
        TreeMap<String, Integer> goodMap = new TreeMap<>((s1, s2) -> {
            int lengthCompare = s1.length() - s2.length();
            if (lengthCompare != 0) {
                return lengthCompare;
            }
            return s1.compareTo(s2); // 長度相同時比較內容
        });
    }
    
    // 錯誤3：誤用子映射
    public static void avoidSubMapMisuse() {
        TreeMap<Integer, String> map = new TreeMap<>();
        for (int i = 0; i < 10; i++) {
            map.put(i, "value" + i);
        }
        
        // 錯誤：認為子映射是獨立的
        NavigableMap<Integer, String> subMap = map.subMap(2, true, 8, false);
        subMap.clear(); // 這會影響原始 map
        
        // 正確：如果需要獨立的副本
        NavigableMap<Integer, String> independentCopy = new TreeMap<>(subMap);
    }
}

總結

TreeMap 是 Java 集合框架中功能強大的有序映射實現，基於紅黑樹提供了 O(log n) 的高效操作。通過本文的深入分析，我們了解了：

Java Map 按 Value 排序：完整實作與效能優化指南

Sun, 28 Mar 2021 15:10:59 +0800

概述

在 Java 程式開發中，經常需要對 Map 集合按照 Value 值進行排序。Map 本身並不保證元素的順序，因此需要採用特定的技術來實現按 Value 排序。本文將深入介紹多種實作方式，並分析其效能特徵和適用場景。

核心概念

Map 排序特性：Map 接口本身不提供排序功能
排序策略：通過轉換為 List 或使用 Stream API 實現
排序穩定性：保持相等元素的相對順序
效能考量：時間複雜度和空間複雜度的權衡

常見應用場景

統計排名：字頻統計、用戶評分排序
資料分析：銷售數據排序、效能指標排名
快取管理：LRU 快取的熱點資料排序
搜尋結果：相關性得分排序

實作方法一：Collections.sort + Map.Entry

1. 基礎實作

這是最傳統且直觀的方法，通過將 Map 的 entrySet 轉換為 List 進行排序。

package com.example.sorting;

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

public class MapSortingExample {
    
    public static void main(String[] args) {
        // 創建測試資料
        Map<String, Integer> wordFrequency = createSampleData();
        
        // 方法一：使用 Collections.sort 排序
        Map<String, Integer> sortedByValue = sortByValueUsingCollections(wordFrequency);
        System.out.println("排序結果: " + sortedByValue);
    }
    
    /**
     * 使用 Collections.sort 按 Value 排序（降序）
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortByValueUsingCollections(Map<K, V> map) {
        // 將 Map 的 entrySet 轉換為 List
        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
        
        // 使用 Collections.sort 排序
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> entry1, Map.Entry<K, V> entry2) {
                // 降序排列：entry2 - entry1
                return entry2.getValue().compareTo(entry1.getValue());
            }
        });
        
        // 將排序後的結果放入 LinkedHashMap 保持順序
        Map<K, V> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        
        return sortedMap;
    }
    
    /**
     * 創建測試資料
     */
    private static Map<String, Integer> createSampleData() {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 25);
        map.put("cherry", 5);
        map.put("date", 15);
        map.put("elderberry", 30);
        return map;
    }
}

2. Lambda 表達式簡化版本

/**
 * 使用 Lambda 表達式簡化比較器
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValueWithLambda(Map<K, V> map) {
    List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
    
    // Lambda 表達式簡化比較器
    Collections.sort(list, (entry1, entry2) -> 
        entry2.getValue().compareTo(entry1.getValue())
    );
    
    Map<K, V> sortedMap = new LinkedHashMap<>();
    for (Map.Entry<K, V> entry : list) {
        sortedMap.put(entry.getKey(), entry.getValue());
    }
    
    return sortedMap;
}

/**
 * 更簡潔的 Lambda 版本，支援升序/降序
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValue(
        Map<K, V> map, boolean ascending) {
    
    List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
    
    if (ascending) {
        Collections.sort(list, Map.Entry.comparingByValue());
    } else {
        Collections.sort(list, Map.Entry.<K, V>comparingByValue().reversed());
    }
    
    return list.stream()
               .collect(Collectors.toMap(
                   Map.Entry::getKey, 
                   Map.Entry::getValue,
                   (oldValue, newValue) -> oldValue, 
                   LinkedHashMap::new
               ));
}

實作方法二：Stream API

1. 基礎 Stream 排序

/**
 * 使用 Stream API 進行排序
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValueUsingStream(
        Map<K, V> map, boolean ascending) {
    
    return map.entrySet()
              .stream()
              .sorted(ascending ? 
                  Map.Entry.comparingByValue() : 
                  Map.Entry.<K, V>comparingByValue().reversed())
              .collect(Collectors.toMap(
                  Map.Entry::getKey,
                  Map.Entry::getValue,
                  (oldValue, newValue) -> oldValue,
                  LinkedHashMap::new
              ));
}

/**
 * 支援自訂比較器的 Stream 排序
 */
public static <K, V> Map<K, V> sortByValueWithCustomComparator(
        Map<K, V> map, Comparator<V> valueComparator) {
    
    return map.entrySet()
              .stream()
              .sorted(Map.Entry.comparingByValue(valueComparator))
              .collect(Collectors.toMap(
                  Map.Entry::getKey,
                  Map.Entry::getValue,
                  (oldValue, newValue) -> oldValue,
                  LinkedHashMap::new
              ));
}

2. 並行 Stream 排序

/**
 * 使用並行 Stream 提升大資料集的排序效能
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValueParallel(
        Map<K, V> map, boolean ascending) {
    
    return map.entrySet()
              .parallelStream()
              .sorted(ascending ? 
                  Map.Entry.comparingByValue() : 
                  Map.Entry.<K, V>comparingByValue().reversed())
              .collect(Collectors.toMap(
                  Map.Entry::getKey,
                  Map.Entry::getValue,
                  (oldValue, newValue) -> oldValue,
                  LinkedHashMap::new
              ));
}

實作方法三：使用 TreeMap

1. Value-to-Key 反轉策略

/**
 * 使用 TreeMap 實現按 Value 排序
 * 注意：此方法適用於 Value 值唯一的情況
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValueUsingTreeMap(Map<K, V> map) {
    // 創建一個以 Value 為 Key 的 TreeMap
    TreeMap<V, K> reversedMap = new TreeMap<>(Collections.reverseOrder());
    
    for (Map.Entry<K, V> entry : map.entrySet()) {
        reversedMap.put(entry.getValue(), entry.getKey());
    }
    
    // 重新構建原始格式的 Map
    Map<K, V> sortedMap = new LinkedHashMap<>();
    for (Map.Entry<V, K> entry : reversedMap.entrySet()) {
        sortedMap.put(entry.getValue(), entry.getKey());
    }
    
    return sortedMap;
}

/**
 * 處理重複 Value 的 TreeMap 排序
 */
public static <K, V extends Comparable<V>> Map<K, V> sortByValueWithDuplicates(Map<K, V> map) {
    // 使用 TreeMap，Key 為複合鍵：Value + 原始Key
    TreeMap<String, Map.Entry<K, V>> sortedTreeMap = new TreeMap<>((key1, key2) -> {
        String[] parts1 = key1.split("###");
        String[] parts2 = key2.split("###");
        
        @SuppressWarnings("unchecked")
        V value1 = (V) parts1[0];
        @SuppressWarnings("unchecked") 
        V value2 = (V) parts2[0];
        
        int valueComparison = value2.compareTo(value1); // 降序
        if (valueComparison != 0) {
            return valueComparison;
        }
        return parts1[1].compareTo(parts2[1]); // 按原始 Key 排序
    });
    
    for (Map.Entry<K, V> entry : map.entrySet()) {
        String compositeKey = entry.getValue() + "###" + entry.getKey();
        sortedTreeMap.put(compositeKey, entry);
    }
    
    Map<K, V> result = new LinkedHashMap<>();
    for (Map.Entry<K, V> entry : sortedTreeMap.values()) {
        result.put(entry.getKey(), entry.getValue());
    }
    
    return result;
}

實作方法四：Key List 排序

1. 基於 Key 的間接排序

/**
 * 通過排序 Key 列表實現間接排序
 * 適用於需要保留原始 Map 的場景
 */
public static <K, V extends Comparable<V>> List<K> sortKeysByValue(
        Map<K, V> map, boolean ascending) {
    
    List<K> keys = new ArrayList<>(map.keySet());
    
    Collections.sort(keys, (key1, key2) -> {
        V value1 = map.get(key1);
        V value2 = map.get(key2);
        
        if (ascending) {
            return value1.compareTo(value2);
        } else {
            return value2.compareTo(value1);
        }
    });
    
    return keys;
}

/**
 * 使用排序後的 Key 列表創建新的有序 Map
 */
public static <K, V> Map<K, V> createSortedMapFromKeys(Map<K, V> originalMap, List<K> sortedKeys) {
    Map<K, V> sortedMap = new LinkedHashMap<>();
    for (K key : sortedKeys) {
        sortedMap.put(key, originalMap.get(key));
    }
    return sortedMap;
}

複雜排序場景

1. 多級排序

/**
 * 多級排序：先按 Value 排序，Value 相同時按 Key 排序
 */
public static <K extends Comparable<K>, V extends Comparable<V>> Map<K, V> 
        multiLevelSort(Map<K, V> map) {
    
    return map.entrySet()
              .stream()
              .sorted(Map.Entry.<K, V>comparingByValue().reversed()
                     .thenComparing(Map.Entry.comparingByKey()))
              .collect(Collectors.toMap(
                  Map.Entry::getKey,
                  Map.Entry::getValue,
                  (oldValue, newValue) -> oldValue,
                  LinkedHashMap::new
              ));
}

2. 自訂物件排序

/**
 * 自訂物件作為 Value 的排序
 */
public static class ScoreData implements Comparable<ScoreData> {
    private final int score;
    private final String level;
    
    public ScoreData(int score, String level) {
        this.score = score;
        this.level = level;
    }
    
    @Override
    public int compareTo(ScoreData other) {
        int scoreComparison = Integer.compare(other.score, this.score); // 分數降序
        if (scoreComparison != 0) {
            return scoreComparison;
        }
        return this.level.compareTo(other.level); // 等級升序
    }
    
    // getter, setter, toString 方法
    public int getScore() { return score; }
    public String getLevel() { return level; }
    
    @Override
    public String toString() {
        return String.format("ScoreData{score=%d, level='%s'}", score, level);
    }
}

/**
 * 排序包含自訂物件的 Map
 */
public static Map<String, ScoreData> sortByScoreData(Map<String, ScoreData> map) {
    return map.entrySet()
              .stream()
              .sorted(Map.Entry.comparingByValue())
              .collect(Collectors.toMap(
                  Map.Entry::getKey,
                  Map.Entry::getValue,
                  (oldValue, newValue) -> oldValue,
                  LinkedHashMap::new
              ));
}

效能分析與比較

1. 效能測試框架

package com.example.performance;

import java.util.*;
import java.util.concurrent.TimeUnit;

public class MapSortingPerformanceTest {
    
    private static final int[] DATA_SIZES = {1000, 10000, 100000, 1000000};
    
    public static void main(String[] args) {
        System.out.println("Map Sorting Performance Comparison");
        System.out.println("=====================================");
        
        for (int size : DATA_SIZES) {
            System.out.printf("\nTesting with %d elements:\n", size);
            Map<String, Integer> testData = generateTestData(size);
            
            runPerformanceTest("Collections.sort", testData, 
                MapSortingExample::sortByValueUsingCollections);
                
            runPerformanceTest("Stream API", testData, 
                map -> sortByValueUsingStream(map, false));
                
            runPerformanceTest("Parallel Stream", testData, 
                map -> sortByValueParallel(map, false));
        }
    }
    
    private static void runPerformanceTest(String method, Map<String, Integer> data, 
                                         SortingFunction<String, Integer> sortFunction) {
        // 預熱
        for (int i = 0; i < 3; i++) {
            sortFunction.sort(new HashMap<>(data));
        }
        
        // 正式測試
        long startTime = System.nanoTime();
        Map<String, Integer> result = sortFunction.sort(new HashMap<>(data));
        long endTime = System.nanoTime();
        
        long duration = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
        System.out.printf("  %-15s: %4d ms (result size: %d)\n", 
                         method, duration, result.size());
    }
    
    private static Map<String, Integer> generateTestData(int size) {
        Map<String, Integer> map = new HashMap<>();
        Random random = new Random(42); // 固定種子確保可重現性
        
        for (int i = 0; i < size; i++) {
            String key = "key" + i;
            Integer value = random.nextInt(1000);
            map.put(key, value);
        }
        
        return map;
    }
    
    @FunctionalInterface
    interface SortingFunction<K, V> {
        Map<K, V> sort(Map<K, V> map);
    }
}

2. 效能分析結果

方法	時間複雜度	空間複雜度	適用場景
Collections.sort	O(n log n)	O(n)	小到中型資料集，需要穩定排序
Stream API	O(n log n)	O(n)	函數式程式設計風格，程式碼簡潔
Parallel Stream	O(n log n)	O(n)	大型資料集，多核心處理器
TreeMap 反轉	O(n log n)	O(n)	Value 值唯一，需要持續有序

3. 記憶體使用分析

/**
 * 記憶體使用監控工具
 */
public class MemoryAnalyzer {
    
    public static void analyzeMemoryUsage(String testName, Runnable test) {
        System.gc(); // 建議垃圾回收
        
        Runtime runtime = Runtime.getRuntime();
        long beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        
        test.run();
        
        long afterMemory = runtime.totalMemory() - runtime.freeMemory();
        long memoryUsed = afterMemory - beforeMemory;
        
        System.out.printf("%s - Memory used: %.2f MB\n", 
                         testName, memoryUsed / (1024.0 * 1024.0));
    }
}

實際應用範例

1. 字頻統計和排序

/**
 * 文本字頻統計與排序應用
 */
public class WordFrequencyAnalyzer {
    
    /**
     * 統計文本中的字頻並排序
     */
    public static Map<String, Integer> analyzeWordFrequency(String text, int topN) {
        // 文本預處理和字頻統計
        Map<String, Integer> wordCount = Arrays.stream(text.toLowerCase()
                                                          .replaceAll("[^a-zA-Z\\s]", "")
                                                          .split("\\s+"))
                                              .filter(word -> !word.isEmpty())
                                              .collect(Collectors.toMap(
                                                  word -> word,
                                                  word -> 1,
                                                  Integer::sum,
                                                  HashMap::new
                                              ));
        
        // 按頻率排序並取前 N 個
        return wordCount.entrySet()
                       .stream()
                       .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                       .limit(topN)
                       .collect(Collectors.toMap(
                           Map.Entry::getKey,
                           Map.Entry::getValue,
                           (oldValue, newValue) -> oldValue,
                           LinkedHashMap::new
                       ));
    }
    
    public static void main(String[] args) {
        String sampleText = "The quick brown fox jumps over the lazy dog. " +
                           "The dog was really lazy and the fox was very quick.";
        
        Map<String, Integer> topWords = analyzeWordFrequency(sampleText, 5);
        
        System.out.println("Top 5 most frequent words:");
        topWords.forEach((word, count) -> 
            System.out.printf("  %s: %d times\n", word, count));
    }
}

2. 使用者評分排序系統

/**
 * 使用者評分排序系統
 */
public class UserRatingSystem {
    
    public static class UserRating {
        private final String userId;
        private final double averageRating;
        private final int totalReviews;
        
        public UserRating(String userId, double averageRating, int totalReviews) {
            this.userId = userId;
            this.averageRating = averageRating;
            this.totalReviews = totalReviews;
        }
        
        public double getWeightedScore() {
            // 加權評分：考慮評論數量
            return averageRating * Math.log(totalReviews + 1);
        }
        
        // getter 方法
        public String getUserId() { return userId; }
        public double getAverageRating() { return averageRating; }
        public int getTotalReviews() { return totalReviews; }
        
        @Override
        public String toString() {
            return String.format("UserRating{userId='%s', avgRating=%.2f, reviews=%d, weighted=%.2f}",
                               userId, averageRating, totalReviews, getWeightedScore());
        }
    }
    
    /**
     * 根據加權評分排序用戶
     */
    public static Map<String, UserRating> sortUsersByRating(Map<String, UserRating> users) {
        return users.entrySet()
                   .stream()
                   .sorted(Map.Entry.<String, UserRating>comparingByValue(
                       (r1, r2) -> Double.compare(r2.getWeightedScore(), r1.getWeightedScore())))
                   .collect(Collectors.toMap(
                       Map.Entry::getKey,
                       Map.Entry::getValue,
                       (oldValue, newValue) -> oldValue,
                       LinkedHashMap::new
                   ));
    }
    
    public static void main(String[] args) {
        Map<String, UserRating> users = new HashMap<>();
        users.put("user1", new UserRating("user1", 4.5, 100));
        users.put("user2", new UserRating("user2", 4.8, 50));
        users.put("user3", new UserRating("user3", 4.2, 200));
        users.put("user4", new UserRating("user4", 4.9, 25));
        
        Map<String, UserRating> sortedUsers = sortUsersByRating(users);
        
        System.out.println("Users sorted by weighted rating:");
        sortedUsers.values().forEach(System.out::println);
    }
}

最佳實踐與建議

1. 選擇合適的排序方法

/**
 * 排序方法選擇指南
 */
public class SortingMethodSelector {
    
    /**
     * 根據資料特徵選擇最佳排序方法
     */
    public static <K, V extends Comparable<V>> Map<K, V> smartSort(
            Map<K, V> map, SortingContext context) {
        
        int size = map.size();
        
        // 小資料集：使用 Collections.sort
        if (size < 1000) {
            return sortByValueUsingCollections(map);
        }
        
        // 大資料集且有多核心：使用並行 Stream
        if (size > 100000 && context.isParallelProcessingAvailable()) {
            return sortByValueParallel(map, context.isAscending());
        }
        
        // 中等資料集：使用 Stream API
        return sortByValueUsingStream(map, context.isAscending());
    }
    
    public static class SortingContext {
        private final boolean ascending;
        private final boolean parallelProcessingAvailable;
        
        public SortingContext(boolean ascending, boolean parallelProcessingAvailable) {
            this.ascending = ascending;
            this.parallelProcessingAvailable = parallelProcessingAvailable;
        }
        
        public boolean isAscending() { return ascending; }
        public boolean isParallelProcessingAvailable() { return parallelProcessingAvailable; }
    }
}

2. 避免常見陷阱

/**
 * 常見錯誤和解決方案
 */
public class CommonPitfalls {
    
    /**
     * 錯誤：使用 HashMap 儲存排序結果（會丟失順序）
     */
    public static <K, V extends Comparable<V>> Map<K, V> wrongApproach(Map<K, V> map) {
        // ❌ 錯誤：HashMap 不保證順序
        return map.entrySet()
                  .stream()
                  .sorted(Map.Entry.comparingByValue())
                  .collect(Collectors.toMap(
                      Map.Entry::getKey,
                      Map.Entry::getValue,
                      (oldValue, newValue) -> oldValue,
                      HashMap::new  // ❌ 這裡應該使用 LinkedHashMap
                  ));
    }
    
    /**
     * 正確：使用 LinkedHashMap 保持順序
     */
    public static <K, V extends Comparable<V>> Map<K, V> correctApproach(Map<K, V> map) {
        // ✅ 正確：LinkedHashMap 保持插入順序
        return map.entrySet()
                  .stream()
                  .sorted(Map.Entry.comparingByValue())
                  .collect(Collectors.toMap(
                      Map.Entry::getKey,
                      Map.Entry::getValue,
                      (oldValue, newValue) -> oldValue,
                      LinkedHashMap::new  // ✅ 正確
                  ));
    }
    
    /**
     * 處理 null 值的排序
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortWithNulls(Map<K, V> map) {
        return map.entrySet()
                  .stream()
                  .sorted(Map.Entry.comparingByValue(
                      Comparator.nullsLast(Comparator.naturalOrder())))
                  .collect(Collectors.toMap(
                      Map.Entry::getKey,
                      Map.Entry::getValue,
                      (oldValue, newValue) -> oldValue,
                      LinkedHashMap::new
                  ));
    }
}

3. 執行緒安全考量

/**
 * 執行緒安全的 Map 排序
 */
public class ThreadSafeSorting {
    
    /**
     * 對 ConcurrentHashMap 進行安全排序
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortConcurrentMap(
            ConcurrentHashMap<K, V> concurrentMap) {
        
        // 創建快照避免併發修改
        Map<K, V> snapshot = new HashMap<>(concurrentMap);
        
        return snapshot.entrySet()
                      .stream()
                      .sorted(Map.Entry.comparingByValue())
                      .collect(Collectors.toMap(
                          Map.Entry::getKey,
                          Map.Entry::getValue,
                          (oldValue, newValue) -> oldValue,
                          LinkedHashMap::new
                      ));
    }
    
    /**
     * 返回執行緒安全的排序結果
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortAndMakeThreadSafe(Map<K, V> map) {
        Map<K, V> sortedMap = sortByValueUsingStream(map, false);
        return Collections.synchronizedMap(sortedMap);
    }
}

總結

Map 按 Value 排序是 Java 開發中的常見需求，本文介紹了四種主要實作方法：

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

Wed, 20 Mar 2019 20:58:17 +0800

概述

Java 8 引入了多個強大的 Map 計算方法，這些方法提供了原子性的讀取-計算-寫入操作，不僅簡化了程式碼，也提高了執行效率和執行緒安全性。本文將深入探討這些方法的使用場景、效能特性和最佳實踐。

核心計算方法

putIfAbsent：條件式插入，僅在 Key 不存在時插入值
compute：基於 Key 和現有 Value 計算新值
computeIfAbsent：Key 不存在時執行計算並插入
computeIfPresent：Key 存在時執行計算並更新
merge：合併現有值與新值

優勢與特點

原子性操作：避免 Check-Then-Act 競態條件
效能優化：減少重複的查找操作
簡潔語法：使用 Lambda 表達式簡化程式碼
執行緒安全：與 ConcurrentHashMap 結合提供執行緒安全

基礎使用範例

1. 環境設定與初始化

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));
    }
}

方法一：putIfAbsent

1. 基礎用法

/**
 * 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
}

2. 實際應用：快取初始化

/**
 * 快取初始化模式：確保每個 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);
        }
    }
}

方法二：compute

1. 基礎用法

/**
 * 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 被移除
}

2. 複雜計算範例

/**
 * 複雜計算應用：統計和聚合操作
 */
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);
    }
}

方法三：computeIfAbsent

1. 基礎用法

/**
 * 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 不會被插入
}

2. 實際應用：延遲初始化集合

/**
 * 延遲初始化應用：動態創建集合和複雜對象
 */
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));
    }
}

方法四：computeIfPresent

1. 基礎用法

/**
 * 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);
}

2. 實際應用：條件式更新

/**
 * 條件式更新應用：基於現有值的智能更新
 */
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"));
    }
}

方法五：merge

1. 基礎用法

/**
 * 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
}

2. 高級合併應用

/**
 * 高級合併應用：資料聚合和統計分析
 */
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));
    }
}

執行緒安全與 ConcurrentHashMap

1. 原子操作的重要性

/**
 * 執行緒安全的計算操作
 */
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();
    }
}

2. 高效能並發應用

/**
 * 高效能並發統計系統
 */
public class HighPerformanceStats {
    
    private final ConcurrentHashMap<String, Long> metrics = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Double> averages = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Integer> counts = new ConcurrentHashMap<>();
    
    /**
     * 記錄指標值並更新平均值
     */
    public void recordMetric(String metricName, double value) {
        // 原子性更新計數
        counts.compute(metricName, (k, v) -> v == null ? 1 : v + 1);
        
        // 原子性更新平均值
        averages.compute(metricName, (k, currentAvg) -> {
            if (currentAvg == null) {
                return value;
            }
            int count = counts.get(metricName);
            return ((currentAvg * (count - 1)) + value) / count;
        });
    }
    
    /**
     * 批量更新指標
     */
    public void recordBatch(Map<String, Double> batchMetrics) {
        batchMetrics.forEach(this::recordMetric);
    }
    
    /**
     * 獲取統計摘要
     */
    public Map<String, String> getStatsSummary() {
        Map<String, String> summary = new HashMap<>();
        
        averages.forEach((metric, avg) -> {
            int count = counts.getOrDefault(metric, 0);
            summary.put(metric, String.format("avg=%.2f, count=%d", avg, count));
        });
        
        return summary;
    }
    
    /**
     * 重置特定指標
     */
    public void resetMetric(String metricName) {
        averages.remove(metricName);
        counts.remove(metricName);
    }
    
    /**
     * 條件式重置：僅重置低活躍度指標
     */
    public int cleanupLowActivityMetrics(int minCount) {
        int removed = 0;
        
        for (String metric : new HashSet<>(counts.keySet())) {
            Integer count = counts.computeIfPresent(metric, (k, v) -> v >= minCount ? v : null);
            if (count == null) {
                averages.remove(metric);
                removed++;
            }
        }
        
        return removed;
    }
}

效能分析與優化

1. 效能比較測試

/**
 * Map 計算方法的效能比較
 */
public class PerformanceComparison {
    
    private static final int OPERATIONS = 1_000_000;
    private static final String[] KEYS = IntStream.range(0, 1000)
                                                  .mapToObj(i -> "key" + i)
                                                  .toArray(String[]::new);
    
    /**
     * 傳統方式：檢查-計算-更新
     */
    public static long testTraditionalApproach() {
        Map<String, Integer> map = new HashMap<>();
        Random random = new Random(42);
        
        long startTime = System.nanoTime();
        
        for (int i = 0; i < OPERATIONS; i++) {
            String key = KEYS[random.nextInt(KEYS.length)];
            Integer current = map.get(key);
            if (current == null) {
                map.put(key, 1);
            } else {
                map.put(key, current + 1);
            }
        }
        
        return System.nanoTime() - startTime;
    }
    
    /**
     * 使用 compute 方法
     */
    public static long testComputeApproach() {
        Map<String, Integer> map = new HashMap<>();
        Random random = new Random(42);
        
        long startTime = System.nanoTime();
        
        for (int i = 0; i < OPERATIONS; i++) {
            String key = KEYS[random.nextInt(KEYS.length)];
            map.compute(key, (k, v) -> v == null ? 1 : v + 1);
        }
        
        return System.nanoTime() - startTime;
    }
    
    /**
     * 使用 merge 方法
     */
    public static long testMergeApproach() {
        Map<String, Integer> map = new HashMap<>();
        Random random = new Random(42);
        
        long startTime = System.nanoTime();
        
        for (int i = 0; i < OPERATIONS; i++) {
            String key = KEYS[random.nextInt(KEYS.length)];
            map.merge(key, 1, Integer::sum);
        }
        
        return System.nanoTime() - startTime;
    }
    
    /**
     * 使用 computeIfAbsent + computeIfPresent 組合
     */
    public static long testComputeIfApproach() {
        Map<String, Integer> map = new HashMap<>();
        Random random = new Random(42);
        
        long startTime = System.nanoTime();
        
        for (int i = 0; i < OPERATIONS; i++) {
            String key = KEYS[random.nextInt(KEYS.length)];
            if (map.computeIfAbsent(key, k -> 0) != null) {
                map.computeIfPresent(key, (k, v) -> v + 1);
            }
        }
        
        return System.nanoTime() - startTime;
    }
    
    public static void main(String[] args) {
        System.out.println("Map 計算方法效能比較 (" + OPERATIONS + " 操作)");
        System.out.println("================================================");
        
        // 預熱 JVM
        for (int i = 0; i < 5; i++) {
            testTraditionalApproach();
            testComputeApproach();
            testMergeApproach();
            testComputeIfApproach();
        }
        
        // 正式測試
        long traditional = testTraditionalApproach();
        long compute = testComputeApproach();
        long merge = testMergeApproach();
        long computeIf = testComputeIfApproach();
        
        System.out.printf("傳統方式:         %8.2f ms\n", traditional / 1_000_000.0);
        System.out.printf("compute 方法:     %8.2f ms\n", compute / 1_000_000.0);
        System.out.printf("merge 方法:       %8.2f ms\n", merge / 1_000_000.0);
        System.out.printf("computeIf 組合:   %8.2f ms\n", computeIf / 1_000_000.0);
        
        System.out.println("\n相對效能 (以傳統方式為基準):");
        System.out.printf("compute 方法:     %.2fx\n", (double) traditional / compute);
        System.out.printf("merge 方法:       %.2fx\n", (double) traditional / merge);
        System.out.printf("computeIf 組合:   %.2fx\n", (double) traditional / computeIf);
    }
}

2. 記憶體使用分析

/**
 * 記憶體使用分析工具
 */
public class MemoryAnalysis {
    
    /**
     * 分析不同實作方式的記憶體使用
     */
    public static void analyzeMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        
        // 測試資料大小
        int dataSize = 100_000;
        
        System.out.println("記憶體使用分析 (資料大小: " + dataSize + ")");
        System.out.println("=========================================");
        
        // 測試 HashMap + compute
        System.gc();
        long beforeHashMap = runtime.totalMemory() - runtime.freeMemory();
        
        Map<String, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < dataSize; i++) {
            hashMap.compute("key" + (i % 1000), (k, v) -> v == null ? 1 : v + 1);
        }
        
        long afterHashMap = runtime.totalMemory() - runtime.freeMemory();
        long hashMapMemory = afterHashMap - beforeHashMap;
        
        // 測試 ConcurrentHashMap + compute
        System.gc();
        long beforeConcurrent = runtime.totalMemory() - runtime.freeMemory();
        
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        for (int i = 0; i < dataSize; i++) {
            concurrentMap.compute("key" + (i % 1000), (k, v) -> v == null ? 1 : v + 1);
        }
        
        long afterConcurrent = runtime.totalMemory() - runtime.freeMemory();
        long concurrentMemory = afterConcurrent - beforeConcurrent;
        
        System.out.printf("HashMap 記憶體使用:           %.2f MB\n", hashMapMemory / (1024.0 * 1024.0));
        System.out.printf("ConcurrentHashMap 記憶體使用: %.2f MB\n", concurrentMemory / (1024.0 * 1024.0));
        System.out.printf("記憶體使用比例:               %.2fx\n", (double) concurrentMemory / hashMapMemory);
        
        // 保持引用避免被垃圾回收
        System.out.println("HashMap 大小: " + hashMap.size());
        System.out.println("ConcurrentHashMap 大小: " + concurrentMap.size());
    }
    
    public static void main(String[] args) {
        analyzeMemoryUsage();
    }
}

實際應用案例

1. 網站訪問統計系統

/**
 * 網站訪問統計系統
 */
public class WebTrafficAnalyzer {
    
    private final ConcurrentHashMap<String, Long> pageViews = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Set<String>> uniqueVisitors = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Long> totalBandwidth = new ConcurrentHashMap<>();
    
    /**
     * 記錄頁面訪問
     */
    public void recordPageView(String page, String visitorId, long bandwidthBytes) {
        // 增加頁面瀏覽量
        pageViews.merge(page, 1L, Long::sum);
        
        // 記錄唯一訪客
        uniqueVisitors.computeIfAbsent(page, k -> ConcurrentHashMap.newKeySet()).add(visitorId);
        
        // 累加頻寬使用
        totalBandwidth.merge(page, bandwidthBytes, Long::sum);
    }
    
    /**
     * 獲取頁面統計報告
     */
    public Map<String, PageStats> getPageStats() {
        Map<String, PageStats> stats = new HashMap<>();
        
        for (String page : pageViews.keySet()) {
            long views = pageViews.getOrDefault(page, 0L);
            int uniqueCount = uniqueVisitors.getOrDefault(page, Collections.emptySet()).size();
            long bandwidth = totalBandwidth.getOrDefault(page, 0L);
            
            stats.put(page, new PageStats(views, uniqueCount, bandwidth));
        }
        
        return stats;
    }
    
    /**
     * 清理低活躍度頁面數據
     */
    public int cleanupLowActivityPages(long minViews) {
        int removed = 0;
        
        Iterator<Map.Entry<String, Long>> iterator = pageViews.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Long> entry = iterator.next();
            if (entry.getValue() < minViews) {
                String page = entry.getKey();
                iterator.remove();
                uniqueVisitors.remove(page);
                totalBandwidth.remove(page);
                removed++;
            }
        }
        
        return removed;
    }
    
    public static class PageStats {
        private final long pageViews;
        private final int uniqueVisitors;
        private final long totalBandwidth;
        
        public PageStats(long pageViews, int uniqueVisitors, long totalBandwidth) {
            this.pageViews = pageViews;
            this.uniqueVisitors = uniqueVisitors;
            this.totalBandwidth = totalBandwidth;
        }
        
        public double getAverageBandwidthPerView() {
            return pageViews > 0 ? (double) totalBandwidth / pageViews : 0;
        }
        
        @Override
        public String toString() {
            return String.format("PageStats{views=%d, unique=%d, bandwidth=%d bytes, avg=%.2f bytes/view}",
                               pageViews, uniqueVisitors, totalBandwidth, getAverageBandwidthPerView());
        }
        
        // getter 方法
        public long getPageViews() { return pageViews; }
        public int getUniqueVisitors() { return uniqueVisitors; }
        public long getTotalBandwidth() { return totalBandwidth; }
    }
}

2. 分散式快取管理

/**
 * 分散式快取管理系統
 */
public class DistributedCacheManager {
    
    private final ConcurrentHashMap<String, CacheEntry> cache = new ConcurrentHashMap<>();
    private final long defaultTTL = 300_000; // 5 分鐘預設 TTL
    
    /**
     * 放入快取項目
     */
    public void put(String key, Object value, long ttlMillis) {
        long expireTime = System.currentTimeMillis() + ttlMillis;
        cache.put(key, new CacheEntry(value, expireTime));
    }
    
    public void put(String key, Object value) {
        put(key, value, defaultTTL);
    }
    
    /**
     * 獲取快取項目（自動清理過期項目）
     */
    public Object get(String key) {
        return cache.computeIfPresent(key, (k, entry) -> {
            if (entry.isExpired()) {
                return null; // 過期，移除
            }
            entry.updateAccessTime();
            return entry;
        })?.getValue();
    }
    
    /**
     * 條件式更新：僅在值存在且未過期時更新
     */
    public boolean updateIfPresent(String key, Function<Object, Object> updater) {
        CacheEntry updated = cache.computeIfPresent(key, (k, entry) -> {
            if (entry.isExpired()) {
                return null; // 過期，移除
            }
            Object newValue = updater.apply(entry.getValue());
            return new CacheEntry(newValue, entry.getExpireTime());
        });
        
        return updated != null;
    }
    
    /**
     * 獲取或計算值（延遲載入模式）
     */
    public Object getOrCompute(String key, Function<String, Object> valueComputer, long ttlMillis) {
        return cache.compute(key, (k, entry) -> {
            if (entry != null && !entry.isExpired()) {
                entry.updateAccessTime();
                return entry;
            }
            
            // 快取未命中或已過期，重新計算
            Object newValue = valueComputer.apply(key);
            long expireTime = System.currentTimeMillis() + ttlMillis;
            return new CacheEntry(newValue, expireTime);
        }).getValue();
    }
    
    /**
     * 批量清理過期項目
     */
    public int cleanupExpired() {
        int removed = 0;
        long now = System.currentTimeMillis();
        
        Iterator<Map.Entry<String, CacheEntry>> iterator = cache.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, CacheEntry> entry = iterator.next();
            if (entry.getValue().getExpireTime() <= now) {
                iterator.remove();
                removed++;
            }
        }
        
        return removed;
    }
    
    /**
     * 獲取快取統計資訊
     */
    public CacheStats getStats() {
        long now = System.currentTimeMillis();
        int totalEntries = cache.size();
        int expiredEntries = 0;
        long totalSize = 0;
        
        for (CacheEntry entry : cache.values()) {
            if (entry.getExpireTime() <= now) {
                expiredEntries++;
            }
            totalSize += entry.getEstimatedSize();
        }
        
        return new CacheStats(totalEntries, expiredEntries, totalSize);
    }
    
    /**
     * 快取項目類別
     */
    public static class CacheEntry {
        private final Object value;
        private final long expireTime;
        private volatile long lastAccessTime;
        
        public CacheEntry(Object value, long expireTime) {
            this.value = value;
            this.expireTime = expireTime;
            this.lastAccessTime = System.currentTimeMillis();
        }
        
        public boolean isExpired() {
            return System.currentTimeMillis() > expireTime;
        }
        
        public void updateAccessTime() {
            this.lastAccessTime = System.currentTimeMillis();
        }
        
        public long getEstimatedSize() {
            // 簡單的大小估算
            if (value instanceof String) {
                return ((String) value).length() * 2L; // Unicode 字元
            } else if (value instanceof byte[]) {
                return ((byte[]) value).length;
            } else {
                return 100L; // 預設估算
            }
        }
        
        // getter 方法
        public Object getValue() { return value; }
        public long getExpireTime() { return expireTime; }
        public long getLastAccessTime() { return lastAccessTime; }
    }
    
    /**
     * 快取統計資訊
     */
    public static class CacheStats {
        private final int totalEntries;
        private final int expiredEntries;
        private final long totalSize;
        
        public CacheStats(int totalEntries, int expiredEntries, long totalSize) {
            this.totalEntries = totalEntries;
            this.expiredEntries = expiredEntries;
            this.totalSize = totalSize;
        }
        
        public int getActiveEntries() {
            return totalEntries - expiredEntries;
        }
        
        public double getHitRatio() {
            return totalEntries > 0 ? (double) getActiveEntries() / totalEntries : 0;
        }
        
        @Override
        public String toString() {
            return String.format("CacheStats{total=%d, active=%d, expired=%d, size=%d bytes, hitRatio=%.2f%%}",
                               totalEntries, getActiveEntries(), expiredEntries, totalSize, getHitRatio() * 100);
        }
        
        // getter 方法
        public int getTotalEntries() { return totalEntries; }
        public int getExpiredEntries() { return expiredEntries; }
        public long getTotalSize() { return totalSize; }
    }
}

最佳實踐與建議

1. 方法選擇指南

/**
 * Map 計算方法選擇指南
 */
public class MethodSelectionGuide {
    
    /**
     * 基於使用場景選擇最適合的方法
     */
    public static void demonstrateMethodSelection() {
        System.out.println("Map 計算方法選擇指南");
        System.out.println("==================");
        
        // 場景 1: 簡單的 Key 存在性檢查與插入
        System.out.println("場景 1: 初始化集合元素");
        System.out.println("推薦: putIfAbsent 或 computeIfAbsent");
        Map<String, List<String>> groups = new ConcurrentHashMap<>();
        
        // 使用 computeIfAbsent（推薦）
        groups.computeIfAbsent("admins", k -> new ArrayList<>()).add("alice");
        
        // 場景 2: 累加計數器
        System.out.println("場景 2: 計數器累加");
        System.out.println("推薦: merge 或 compute");
        Map<String, Integer> counters = new ConcurrentHashMap<>();
        
        // 使用 merge（推薦）
        counters.merge("clicks", 1, Integer::sum);
        
        // 場景 3: 條件式更新現有值
        System.out.println("場景 3: 條件式更新");
        System.out.println("推薦: computeIfPresent");
        Map<String, Integer> scores = new ConcurrentHashMap<>();
        scores.put("player1", 100);
        
        // 使用 computeIfPresent（推薦）
        scores.computeIfPresent("player1", (k, v) -> v > 50 ? v + 10 : v);
        
        // 場景 4: 複雜的計算邏輯
        System.out.println("場景 4: 複雜計算");
        System.out.println("推薦: compute");
        Map<String, String> stateMachine = new ConcurrentHashMap<>();
        
        // 使用 compute（推薦）
        stateMachine.compute("task1", (k, currentState) -> {
            if (currentState == null) return "CREATED";
            switch (currentState) {
                case "CREATED": return "PROCESSING";
                case "PROCESSING": return "COMPLETED";
                default: return currentState;
            }
        });
        
        System.out.println("結果展示:");
        System.out.println("群組: " + groups);
        System.out.println("計數器: " + counters);
        System.out.println("分數: " + scores);
        System.out.println("狀態: " + stateMachine);
    }
}

2. 常見陷阱與解決方案

/**
 * 常見陷阱與解決方案
 */
public class CommonPitfalls {
    
    /**
     * 陷阱 1: 在計算函數中執行耗時操作
     */
    public static void demonstrateExpensiveOperationPitfall() {
        System.out.println("陷阱 1: 計算函數中的耗時操作");
        
        ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();
        
        // ❌ 錯誤做法：在計算函數中執行耗時操作
        String badResult = cache.computeIfAbsent("user123", key -> {
            try {
                Thread.sleep(1000); // 模擬耗時的資料庫查詢
                return "User data for " + key;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return null;
            }
        });
        
        // ✅ 正確做法：預先計算或使用異步載入
        CompletableFuture<String> futureResult = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000); // 模擬耗時操作
                return "User data for user456";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return null;
            }
        });
        
        // 只在快取中存儲已計算的結果
        try {
            String goodResult = cache.putIfAbsent("user456", futureResult.get());
            System.out.println("預計算結果: " + goodResult);
        } catch (Exception e) {
            System.err.println("計算失敗: " + e.getMessage());
        }
    }
    
    /**
     * 陷阱 2: 在計算函數中修改 Map 本身
     */
    public static void demonstrateRecursiveModificationPitfall() {
        System.out.println("陷阱 2: 遞迴修改陷阱");
        
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("a", 1);
        
        try {
            // ❌ 錯誤做法：在計算函數中修改同一個 Map
            map.compute("a", (key, value) -> {
                map.put("b", 2); // 這可能導致死鎖或異常
                return value + 1;
            });
        } catch (Exception e) {
            System.err.println("遞迴修改錯誤: " + e.getMessage());
        }
        
        // ✅ 正確做法：分離計算和修改操作
        Integer currentValue = map.get("a");
        if (currentValue != null) {
            map.put("a", currentValue + 1);
            map.put("b", 2);
        }
        
        System.out.println("安全修改後的 Map: " + map);
    }
    
    /**
     * 陷阱 3: 計算函數拋出異常
     */
    public static void demonstrateExceptionHandlingPitfall() {
        System.out.println("陷阱 3: 異常處理陷阱");
        
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        
        // ❌ 可能有問題：未處理計算函數中的異常
        try {
            map.compute("risky", (key, value) -> {
                if (Math.random() > 0.5) {
                    throw new RuntimeException("隨機失敗");
                }
                return value == null ? 1 : value + 1;
            });
        } catch (RuntimeException e) {
            System.err.println("計算失敗: " + e.getMessage());
        }
        
        // ✅ 正確做法：在計算函數內部處理異常
        map.compute("safe", (key, value) -> {
            try {
                // 可能拋出異常的操作
                if (Math.random() > 0.5) {
                    throw new RuntimeException("隨機失敗");
                }
                return value == null ? 1 : value + 1;
            } catch (Exception e) {
                System.err.println("內部處理異常: " + e.getMessage());
                return value; // 返回原值或預設值
            }
        });
        
        System.out.println("異常處理後的 Map: " + map);
    }
    
    /**
     * 陷阱 4: null 值處理不當
     */
    public static void demonstrateNullHandlingPitfall() {
        System.out.println("陷阱 4: null 值處理陷阱");
        
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("key1", "value1");
        map.put("key2", null); // ConcurrentHashMap 不允許 null 值，這會拋出異常
        
        // ✅ 正確做法：避免 null 值
        map.compute("key3", (key, value) -> {
            if (value == null) {
                return "default_value";
            }
            return value.toUpperCase();
        });
        
        // 使用 Optional 處理可能的 null 值
        String result = Optional.ofNullable(map.get("key3"))
                               .map(String::toUpperCase)
                               .orElse("DEFAULT");
        
        System.out.println("安全處理 null 後的結果: " + result);
    }
    
    public static void main(String[] args) {
        demonstrateExpensiveOperationPitfall();
        demonstrateRecursiveModificationPitfall();
        demonstrateExceptionHandlingPitfall();
        // demonstrateNullHandlingPitfall(); // 會拋出異常
    }
}

總結

Java Map 的計算方法為開發者提供了強大的工具來進行高效的資料操作：