Thread Safety 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) 的高效操作。通過本文的深入分析，我們了解了：

Kotlin lateinit 完整實作指南：延遲初始化與企業級開發最佳實踐

Thu, 05 Aug 2021 21:07:54 +0800

Kotlin lateinit 完整實作指南

簡介

在 Kotlin 開發中，lateinit 關鍵字提供了一種延遲初始化屬性的優雅方式，特別適用於依賴注入、Android 開發和 Spring Boot 應用。本文將深入探討 lateinit 的工作原理、使用場景、與 lazy 的比較，以及在企業級開發中的最佳實踐。

lateinit 基本概念

核心特性

lateinit 是 Kotlin 提供的延遲初始化修飾符，允許開發者聲明非空屬性而不需要立即初始化：

class UserService {
    // 延遲初始化，避免空值檢查
    lateinit var userRepository: UserRepository
    lateinit var cacheManager: CacheManager
    
    fun initializeServices() {
        userRepository = UserRepositoryImpl()
        cacheManager = RedisCacheManager()
    }
    
    fun findUser(id: Long): User {
        // 直接使用，無需空值檢查
        return userRepository.findById(id) ?: throw UserNotFoundException(id)
    }
}

語法規則與限制

class PropertyRules {
    // ✅ 正確：var 屬性
    lateinit var validProperty: String
    
    // ❌ 錯誤：lateinit 不能用於 val
    // lateinit val invalidProperty: String // 編譯錯誤
    
    // ❌ 錯誤：原始類型不支援
    // lateinit var invalidInt: Int // 編譯錯誤
    
    // ❌ 錯誤：可空類型不支援
    // lateinit var invalidNullable: String? // 編譯錯誤
    
    // ✅ 正確：自定義類別
    lateinit var database: Database
    
    // ✅ 正確：介面類型
    lateinit var service: ServiceInterface
}

lateinit 詳細機制

內部實現原理

// Kotlin 編譯後的 Java 等效代碼
public class UserService {
    private String name;
    
    public final String getName() {
        String var1 = this.name;
        if (var1 == null) {
            Intrinsics.throwUninitializedPropertyAccessException("name");
        }
        return var1;
    }
    
    public final void setName(String value) {
        Intrinsics.checkNotNullParameter(value, "value");
        this.name = value;
    }
}

初始化檢查機制

class InitializationChecker {
    lateinit var database: Database
    lateinit var config: AppConfig
    
    fun checkInitialization() {
        // 檢查是否已初始化
        if (::database.isInitialized) {
            println("Database is ready")
        } else {
            println("Database not initialized")
        }
        
        // 安全初始化模式
        if (!::config.isInitialized) {
            config = loadDefaultConfig()
        }
    }
    
    fun safeAccess(): String {
        return if (::database.isInitialized) {
            database.getConnectionInfo()
        } else {
            "Database not available"
        }
    }
}

企業級應用場景

1. Spring Boot 依賴注入

@Service
class UserManagementService {
    
    @Autowired
    lateinit var userRepository: UserRepository
    
    @Autowired
    lateinit var emailService: EmailService
    
    @Autowired
    lateinit var auditService: AuditService
    
    @Value("\${app.user.max-login-attempts}")
    lateinit var maxLoginAttempts: String
    
    @PostConstruct
    fun validateDependencies() {
        require(::userRepository.isInitialized) { "UserRepository not injected" }
        require(::emailService.isInitialized) { "EmailService not injected" }
        require(::auditService.isInitialized) { "AuditService not injected" }
        
        logger.info("All dependencies initialized successfully")
    }
    
    fun createUser(userData: UserCreateRequest): User {
        val user = User(
            email = userData.email,
            username = userData.username,
            hashedPassword = hashPassword(userData.password)
        )
        
        val savedUser = userRepository.save(user)
        
        // 發送歡迎郵件
        emailService.sendWelcomeEmail(savedUser)
        
        // 記錄審計日誌
        auditService.logUserCreation(savedUser)
        
        return savedUser
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(UserManagementService::class.java)
    }
}

2. Android 開發中的應用

class MainActivity : AppCompatActivity() {
    
    // View 元件延遲初始化
    lateinit var recyclerView: RecyclerView
    lateinit var adapter: UserAdapter
    lateinit var viewModel: UserViewModel
    
    // 網路元件
    lateinit var apiService: ApiService
    lateinit var networkManager: NetworkManager
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        initializeViews()
        initializeNetwork()
        initializeViewModel()
        setupObservers()
    }
    
    private fun initializeViews() {
        recyclerView = findViewById(R.id.recyclerView)
        adapter = UserAdapter { user -> onUserClicked(user) }
        recyclerView.adapter = adapter
        recyclerView.layoutManager = LinearLayoutManager(this)
    }
    
    private fun initializeNetwork() {
        apiService = RetrofitBuilder.createApiService()
        networkManager = NetworkManager(this)
    }
    
    private fun initializeViewModel() {
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]
    }
    
    private fun setupObservers() {
        // 確保所有元件都已初始化
        require(::viewModel.isInitialized) { "ViewModel not initialized" }
        require(::adapter.isInitialized) { "Adapter not initialized" }
        
        viewModel.users.observe(this) { users ->
            adapter.submitList(users)
        }
        
        viewModel.loading.observe(this) { isLoading ->
            // 處理載入狀態
        }
    }
    
    private fun onUserClicked(user: User) {
        if (::networkManager.isInitialized && networkManager.isConnected()) {
            // 處理用戶點擊事件
            viewModel.loadUserDetails(user.id)
        } else {
            showNoNetworkError()
        }
    }
}

3. 配置管理系統

@Component
class ConfigurationManager {
    
    @Value("\${database.url}")
    lateinit var databaseUrl: String
    
    @Value("\${database.username}")
    lateinit var databaseUsername: String
    
    @Value("\${redis.host}")
    lateinit var redisHost: String
    
    @Value("\${jwt.secret}")
    lateinit var jwtSecret: String
    
    lateinit var databaseConfig: DatabaseConfig
    lateinit var redisConfig: RedisConfig
    lateinit var securityConfig: SecurityConfig
    
    @PostConstruct
    fun initializeConfigurations() {
        validateRequiredProperties()
        buildConfigurations()
        logConfigurationStatus()
    }
    
    private fun validateRequiredProperties() {
        val errors = mutableListOf<String>()
        
        if (!::databaseUrl.isInitialized || databaseUrl.isBlank()) {
            errors.add("Database URL not configured")
        }
        
        if (!::databaseUsername.isInitialized || databaseUsername.isBlank()) {
            errors.add("Database username not configured")
        }
        
        if (!::redisHost.isInitialized || redisHost.isBlank()) {
            errors.add("Redis host not configured")
        }
        
        if (!::jwtSecret.isInitialized || jwtSecret.isBlank()) {
            errors.add("JWT secret not configured")
        }
        
        if (errors.isNotEmpty()) {
            throw ConfigurationException("Configuration errors: ${errors.joinToString(", ")}")
        }
    }
    
    private fun buildConfigurations() {
        databaseConfig = DatabaseConfig(
            url = databaseUrl,
            username = databaseUsername,
            maxPoolSize = 20,
            connectionTimeout = Duration.ofSeconds(30)
        )
        
        redisConfig = RedisConfig(
            host = redisHost,
            port = 6379,
            timeout = Duration.ofSeconds(10)
        )
        
        securityConfig = SecurityConfig(
            jwtSecret = jwtSecret,
            tokenExpiration = Duration.ofHours(24),
            refreshTokenExpiration = Duration.ofDays(7)
        )
    }
    
    private fun logConfigurationStatus() {
        logger.info("Configuration initialized successfully:")
        logger.info("- Database: ${databaseConfig.url}")
        logger.info("- Redis: ${redisConfig.host}:${redisConfig.port}")
        logger.info("- Security: JWT configured with ${securityConfig.tokenExpiration} expiration")
    }
    
    fun getDatabaseConfig(): DatabaseConfig {
        require(::databaseConfig.isInitialized) { "Database configuration not initialized" }
        return databaseConfig
    }
    
    fun getRedisConfig(): RedisConfig {
        require(::redisConfig.isInitialized) { "Redis configuration not initialized" }
        return redisConfig
    }
    
    fun getSecurityConfig(): SecurityConfig {
        require(::securityConfig.isInitialized) { "Security configuration not initialized" }
        return securityConfig
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(ConfigurationManager::class.java)
    }
}

lateinit vs lazy 詳細比較

特性對比表

特性	lateinit	lazy
初始化時機	手動控制	首次訪問時
線程安全	否	是（預設）
可變性	var（可重新賦值）	val（不可變）
初始化檢查	::property.isInitialized	無需檢查
記憶體開銷	低	略高（Lazy包裝）
適用場景	依賴注入、外部初始化	延遲計算、高開銷操作

使用場景比較

class ComparisonExample {
    
    // lateinit：適合依賴注入
    @Autowired
    lateinit var repository: UserRepository
    
    // lazy：適合計算密集型初始化
    private val expensiveResource: DatabaseConnection by lazy {
        createDatabaseConnection() // 僅在首次使用時執行
    }
    
    // lateinit：可重新賦值
    lateinit var currentUser: User
    
    fun switchUser(newUser: User) {
        currentUser = newUser // 可以重新賦值
    }
    
    // lazy：線程安全的單例初始化
    private val singleton: ServiceManager by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        ServiceManager.create()
    }
    
    // lateinit：手動控制初始化時機
    lateinit var testDatabase: TestDatabase
    
    @BeforeEach
    fun setupTest() {
        testDatabase = createTestDatabase()
    }
    
    @AfterEach
    fun cleanupTest() {
        if (::testDatabase.isInitialized) {
            testDatabase.cleanup()
        }
    }
}

進階使用模式

1. 條件初始化模式

class ConditionalInitialization {
    lateinit var primaryDatabase: Database
    lateinit var secondaryDatabase: Database
    
    fun initializeDatabases(config: DatabaseConfig) {
        // 主資料庫總是初始化
        primaryDatabase = createDatabase(config.primary)
        
        // 次要資料庫僅在啟用時初始化
        if (config.enableSecondary) {
            secondaryDatabase = createDatabase(config.secondary)
        }
    }
    
    fun executeQuery(query: String): QueryResult {
        val result = primaryDatabase.execute(query)
        
        // 安全地使用次要資料庫
        if (::secondaryDatabase.isInitialized) {
            secondaryDatabase.logQuery(query, result)
        }
        
        return result
    }
}

2. 初始化鏈模式

class InitializationChain {
    lateinit var configService: ConfigService
    lateinit var databaseService: DatabaseService
    lateinit var cacheService: CacheService
    lateinit var businessService: BusinessService
    
    fun initializeAll() {
        initializeConfig()
        initializeDatabase()
        initializeCache()
        initializeBusiness()
        validateInitialization()
    }
    
    private fun initializeConfig() {
        configService = ConfigService()
        logger.info("Config service initialized")
    }
    
    private fun initializeDatabase() {
        require(::configService.isInitialized) { "Config service must be initialized first" }
        databaseService = DatabaseService(configService.getDatabaseConfig())
        logger.info("Database service initialized")
    }
    
    private fun initializeCache() {
        require(::configService.isInitialized) { "Config service must be initialized first" }
        cacheService = CacheService(configService.getCacheConfig())
        logger.info("Cache service initialized")
    }
    
    private fun initializeBusiness() {
        require(::databaseService.isInitialized) { "Database service must be initialized first" }
        require(::cacheService.isInitialized) { "Cache service must be initialized first" }
        
        businessService = BusinessService(databaseService, cacheService)
        logger.info("Business service initialized")
    }
    
    private fun validateInitialization() {
        val errors = mutableListOf<String>()
        
        if (!::configService.isInitialized) errors.add("ConfigService")
        if (!::databaseService.isInitialized) errors.add("DatabaseService")
        if (!::cacheService.isInitialized) errors.add("CacheService")
        if (!::businessService.isInitialized) errors.add("BusinessService")
        
        if (errors.isNotEmpty()) {
            throw InitializationException("未初始化的服務: ${errors.joinToString(", ")}")
        }
        
        logger.info("所有服務初始化完成")
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(InitializationChain::class.java)
    }
}

3. 資源管理模式

class ResourceManager : AutoCloseable {
    lateinit var connectionPool: ConnectionPool
    lateinit var cacheManager: CacheManager
    lateinit var fileManager: FileManager
    
    private val initializedResources = mutableSetOf<String>()
    
    fun initializeConnectionPool(config: ConnectionConfig) {
        connectionPool = ConnectionPool.create(config)
        initializedResources.add("connectionPool")
        logger.info("Connection pool initialized with ${config.maxConnections} connections")
    }
    
    fun initializeCacheManager(config: CacheConfig) {
        cacheManager = CacheManager.create(config)
        initializedResources.add("cacheManager")
        logger.info("Cache manager initialized with ${config.maxSize} max size")
    }
    
    fun initializeFileManager(config: FileConfig) {
        fileManager = FileManager.create(config)
        initializedResources.add("fileManager")
        logger.info("File manager initialized with root: ${config.rootPath}")
    }
    
    fun getResourceStatus(): Map<String, Boolean> {
        return mapOf(
            "connectionPool" to ::connectionPool.isInitialized,
            "cacheManager" to ::cacheManager.isInitialized,
            "fileManager" to ::fileManager.isInitialized
        )
    }
    
    override fun close() {
        logger.info("開始關閉資源管理器")
        
        // 按相反順序關閉資源
        if (::fileManager.isInitialized) {
            try {
                fileManager.close()
                logger.info("File manager closed")
            } catch (e: Exception) {
                logger.error("Error closing file manager", e)
            }
        }
        
        if (::cacheManager.isInitialized) {
            try {
                cacheManager.close()
                logger.info("Cache manager closed")
            } catch (e: Exception) {
                logger.error("Error closing cache manager", e)
            }
        }
        
        if (::connectionPool.isInitialized) {
            try {
                connectionPool.close()
                logger.info("Connection pool closed")
            } catch (e: Exception) {
                logger.error("Error closing connection pool", e)
            }
        }
        
        initializedResources.clear()
        logger.info("資源管理器關閉完成")
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(ResourceManager::class.java)
    }
}

測試策略

1. 單元測試模式

class UserServiceTest {
    
    @Mock
    lateinit var userRepository: UserRepository
    
    @Mock
    lateinit var emailService: EmailService
    
    @InjectMocks
    lateinit var userService: UserService
    
    @BeforeEach
    fun setup() {
        MockitoAnnotations.openMocks(this)
        
        // 驗證依賴注入是否成功
        assertTrue(::userRepository.isInitialized, "UserRepository should be initialized")
        assertTrue(::emailService.isInitialized, "EmailService should be initialized")
        assertTrue(::userService.isInitialized, "UserService should be initialized")
    }
    
    @Test
    fun `should create user successfully`() {
        // Given
        val userData = UserCreateRequest(
            email = "test@example.com",
            username = "testuser"
        )
        val expectedUser = User(1L, "test@example.com", "testuser")
        
        `when`(userRepository.save(any())).thenReturn(expectedUser)
        doNothing().`when`(emailService).sendWelcomeEmail(any())
        
        // When
        val result = userService.createUser(userData)
        
        // Then
        assertEquals(expectedUser, result)
        verify(userRepository).save(any())
        verify(emailService).sendWelcomeEmail(expectedUser)
    }
    
    @Test
    fun `should handle uninitialized dependencies gracefully`() {
        // 測試未初始化的情況
        val service = UserService()
        
        assertFalse(service::userRepository.isInitialized)
        assertFalse(service::emailService.isInitialized)
        
        assertThrows<UninitializedPropertyAccessException> {
            service.createUser(UserCreateRequest("test@example.com", "test"))
        }
    }
}

2. 整合測試模式

@SpringBootTest
@TestPropertySource(properties = [
    "spring.datasource.url=jdbc:h2:mem:testdb",
    "spring.jpa.hibernate.ddl-auto=create-drop"
])
class UserServiceIntegrationTest {
    
    @Autowired
    lateinit var userService: UserService
    
    @Autowired
    lateinit var userRepository: UserRepository
    
    @TestConfiguration
    class TestConfig {
        @Bean
        @Primary
        fun mockEmailService(): EmailService = mockk(relaxed = true)
    }
    
    @Test
    fun `should initialize all dependencies in Spring context`() {
        // 驗證 Spring 上下文中的依賴注入
        assertTrue(userService::userRepository.isInitialized)
        assertTrue(userService::emailService.isInitialized)
        
        // 執行實際的業務邏輯測試
        val userData = UserCreateRequest("integration@test.com", "integrationuser")
        val result = userService.createUser(userData)
        
        assertNotNull(result.id)
        assertEquals("integration@test.com", result.email)
        assertEquals("integrationuser", result.username)
        
        // 驗證資料實際儲存
        val savedUser = userRepository.findById(result.id!!)
        assertTrue(savedUser.isPresent)
        assertEquals(result.email, savedUser.get().email)
    }
}

效能優化與最佳實踐

1. 記憶體管理

class MemoryOptimizedService {
    // 大型物件使用 lateinit 延遲初始化
    lateinit var largeDataSet: LargeDataSet
    lateinit var heavyProcessor: HeavyProcessor
    
    // 小型配置物件可以直接初始化
    private val config = ServiceConfig()
    
    fun initializeHeavyResources() {
        if (!::largeDataSet.isInitialized) {
            largeDataSet = LargeDataSet.loadFromDatabase()
            logger.info("Large dataset loaded: ${largeDataSet.size} records")
        }
        
        if (!::heavyProcessor.isInitialized) {
            heavyProcessor = HeavyProcessor(largeDataSet)
            logger.info("Heavy processor initialized")
        }
    }
    
    fun processDataIfReady(input: String): String? {
        return if (::heavyProcessor.isInitialized) {
            heavyProcessor.process(input)
        } else {
            logger.warn("Heavy processor not initialized, skipping processing")
            null
        }
    }
    
    // 清理資源
    fun cleanup() {
        if (::heavyProcessor.isInitialized) {
            heavyProcessor.cleanup()
        }
        
        if (::largeDataSet.isInitialized) {
            largeDataSet.cleanup()
        }
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(MemoryOptimizedService::class.java)
    }
}

2. 線程安全考量

class ThreadSafeService {
    @Volatile
    lateinit var sharedResource: SharedResource
    
    private val initializationLock = ReentrantLock()
    private val condition = initializationLock.newCondition()
    
    fun initializeSharedResource(config: ResourceConfig) {
        initializationLock.withLock {
            if (!::sharedResource.isInitialized) {
                sharedResource = SharedResource.create(config)
                condition.signalAll() // 通知等待的線程
                logger.info("Shared resource initialized")
            }
        }
    }
    
    fun accessSharedResource(): String {
        // 等待初始化完成
        initializationLock.withLock {
            while (!::sharedResource.isInitialized) {
                condition.await(5, TimeUnit.SECONDS)
                if (!::sharedResource.isInitialized) {
                    throw TimeoutException("Shared resource initialization timeout")
                }
            }
        }
        
        return sharedResource.getData()
    }
    
    fun isResourceReady(): Boolean {
        return ::sharedResource.isInitialized
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(ThreadSafeService::class.java)
    }
}

常見陷阱與錯誤處理

1. 常見錯誤模式

class CommonMistakes {
    lateinit var service: SomeService
    
    // ❌ 錯誤：在初始化前訪問
    fun badExample1() {
        service.doSomething() // UninitializedPropertyAccessException
    }
    
    // ❌ 錯誤：忘記檢查初始化狀態
    fun badExample2() {
        val result = service.getData() // 可能未初始化
        return result
    }
    
    // ✅ 正確：檢查後訪問
    fun goodExample1() {
        if (::service.isInitialized) {
            service.doSomething()
        } else {
            logger.warn("Service not initialized")
        }
    }
    
    // ✅ 正確：防禦性初始化
    fun goodExample2(): String {
        if (!::service.isInitialized) {
            service = SomeService.createDefault()
        }
        return service.getData()
    }
}

2. 錯誤處理策略

class ErrorHandlingService {
    lateinit var primaryService: PrimaryService
    lateinit var backupService: BackupService
    
    fun processRequest(request: Request): Response {
        return try {
            // 嘗試使用主要服務
            if (::primaryService.isInitialized) {
                primaryService.process(request)
            } else {
                throw ServiceNotInitializedException("Primary service not available")
            }
        } catch (e: ServiceNotInitializedException) {
            logger.warn("Primary service unavailable, falling back to backup", e)
            
            // 備援服務處理
            if (::backupService.isInitialized) {
                backupService.process(request)
            } else {
                throw ServiceUnavailableException("No services available")
            }
        } catch (e: Exception) {
            logger.error("Unexpected error processing request", e)
            throw ProcessingException("Failed to process request", e)
        }
    }
    
    fun healthCheck(): HealthStatus {
        val status = HealthStatus()
        
        status.primaryServiceAvailable = ::primaryService.isInitialized
        status.backupServiceAvailable = ::backupService.isInitialized
        
        status.overallStatus = when {
            status.primaryServiceAvailable -> HealthStatus.Status.HEALTHY
            status.backupServiceAvailable -> HealthStatus.Status.DEGRADED
            else -> HealthStatus.Status.UNHEALTHY
        }
        
        return status
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(ErrorHandlingService::class.java)
    }
}

企業級最佳實踐

1. 初始化驗證框架

@Component
class InitializationValidator {
    
    fun validateObject(obj: Any): ValidationResult {
        val result = ValidationResult()
        val clazz = obj::class
        
        // 使用反射檢查所有 lateinit 屬性
        clazz.memberProperties
            .filterIsInstance<KMutableProperty1<Any, Any>>()
            .filter { it.isLateinit }
            .forEach { property ->
                try {
                    if (!property.isInitialized(obj)) {
                        result.addError("Property '${property.name}' is not initialized")
                    } else {
                        result.addSuccess("Property '${property.name}' is initialized")
                    }
                } catch (e: Exception) {
                    result.addError("Error checking property '${property.name}': ${e.message}")
                }
            }
        
        return result
    }
    
    @EventListener
    fun onApplicationReady(event: ApplicationReadyEvent) {
        logger.info("開始驗證應用程式初始化狀態")
        
        val context = event.applicationContext
        val beanNames = context.beanDefinitionNames
        
        var totalBeans = 0
        var validatedBeans = 0
        var errorCount = 0
        
        beanNames.forEach { beanName ->
            try {
                val bean = context.getBean(beanName)
                totalBeans++
                
                val result = validateObject(bean)
                if (result.hasErrors()) {
                    logger.warn("Bean '$beanName' has initialization issues: ${result.getErrors()}")
                    errorCount += result.getErrorCount()
                } else {
                    validatedBeans++
                }
            } catch (e: Exception) {
                logger.debug("Skipped validation for bean '$beanName': ${e.message}")
            }
        }
        
        logger.info("初始化驗證完成: $validatedBeans/$totalBeans beans validated, $errorCount errors found")
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(InitializationValidator::class.java)
    }
}

data class ValidationResult(
    private val errors: MutableList<String> = mutableListOf(),
    private val successes: MutableList<String> = mutableListOf()
) {
    fun addError(error: String) = errors.add(error)
    fun addSuccess(success: String) = successes.add(success)
    fun hasErrors() = errors.isNotEmpty()
    fun getErrors() = errors.toList()
    fun getSuccesses() = successes.toList()
    fun getErrorCount() = errors.size
}

2. 監控與診斷

@Component
class LateinitMonitor {
    
    private val meterRegistry: MeterRegistry = Metrics.globalRegistry
    private val initializationTimer = Timer.builder("lateinit.initialization.time")
        .description("Time taken to initialize lateinit properties")
        .register(meterRegistry)
    
    fun <T> monitorInitialization(
        propertyName: String,
        initializer: () -> T
    ): T {
        return Timer.Sample.start(meterRegistry).use { sample ->
            try {
                val result = initializer()
                
                // 記錄成功的初始化
                Counter.builder("lateinit.initialization.success")
                    .tag("property", propertyName)
                    .register(meterRegistry)
                    .increment()
                
                sample.stop(initializationTimer.withTag("property", propertyName))
                logger.info("Successfully initialized property: $propertyName")
                
                result
            } catch (e: Exception) {
                // 記錄失敗的初始化
                Counter.builder("lateinit.initialization.failure")
                    .tag("property", propertyName)
                    .tag("error", e.javaClass.simpleName)
                    .register(meterRegistry)
                    .increment()
                
                logger.error("Failed to initialize property: $propertyName", e)
                throw e
            }
        }
    }
    
    @Scheduled(fixedRate = 60000) // 每分鐘檢查一次
    fun reportInitializationStatus() {
        val successCount = meterRegistry.counter("lateinit.initialization.success").count()
        val failureCount = meterRegistry.counter("lateinit.initialization.failure").count()
        val totalCount = successCount + failureCount
        
        if (totalCount > 0) {
            val successRate = (successCount / totalCount) * 100
            logger.info("Lateinit initialization statistics - Success rate: ${"%.2f".format(successRate)}% ($successCount/$totalCount)")
        }
    }
    
    companion object {
        private val logger = LoggerFactory.getLogger(LateinitMonitor::class.java)
    }
}

效能基準測試

初始化效能比較

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
class LateinitPerformanceBenchmark {
    
    // 測試類別
    class LateinitExample {
        lateinit var service: ExpensiveService
        
        fun initializeService() {
            service = ExpensiveService()
        }
    }
    
    class LazyExample {
        private val service: ExpensiveService by lazy { ExpensiveService() }
        
        fun getService(): ExpensiveService = service
    }
    
    class EagerExample {
        private val service: ExpensiveService = ExpensiveService()
        
        fun getService(): ExpensiveService = service
    }
    
    @Benchmark
    fun lateinitInitialization(): ExpensiveService {
        val example = LateinitExample()
        example.initializeService()
        return example.service
    }
    
    @Benchmark
    fun lazyInitialization(): ExpensiveService {
        val example = LazyExample()
        return example.getService()
    }
    
    @Benchmark
    fun eagerInitialization(): ExpensiveService {
        val example = EagerExample()
        return example.getService()
    }
    
    @Benchmark
    fun lateinitAccessAfterInit(): String {
        val example = LateinitExample()
        example.initializeService()
        return example.service.getData() // 訪問已初始化的屬性
    }
    
    @Benchmark
    fun lazyAccess(): String {
        val example = LazyExample()
        example.getService() // 首次訪問，觸發初始化
        return example.getService().getData() // 再次訪問，使用快取值
    }
}

總結

lateinit 是 Kotlin 中強大的延遲初始化機制，特別適用於：

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 的計算方法為開發者提供了強大的工具來進行高效的資料操作：