Java 集合框架核心解析：List、Set 與 Map 完全指南

集合框架概述

在 Java 開發中，資料存儲與操作是核心需求。JDK 在 java.util 包中提供了一組專門用於存儲對象的類與介面，統稱為集合框架。這些容器類透過大量介面設計，統一了各類集合的使用方式，極大提升了開發效率。

集合框架提供兩種基本存儲模式：

1. 索引式存取（Collection 介面）：元素按順序存放，索引從 0 開始。可重複元素由 List 實現，不可重複由 Set 實現。
2. 鍵值對存取（Map 介面）：以「名稱-數值」對存儲，鍵不可重複且非 null，值可重複。

底層資料結構（陣列、鏈表、樹、哈希表等）決定了各實現類的性能特徵：陣列查詢快，鏈表增刪靈活，樹結構有序，哈希表查找極快。此外，存入集合的對象建議覆寫 equals() 與 hashCode() 以提升效率。

List 系列：有序、可重複

List 介面實現類以索引操作元素，允許重複。常見實現：

• ArrayList：陣列底層，隨機存取快（O(1)），適合頻繁查詢場景。
• LinkedList：雙向鏈表底層，頭尾增刪優（O(1)），適合頻繁插入/刪除場景。
• Vector：同步線程安全，效率較低，歷史遺留類。
• Stack：繼承 Vector，提供 LIFO 棧操作（push/pop）。

核心方法速查

實戰範例

import java.util.*;

public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("1"); list.add("2"); list.add("3");
        list.add("1"); list.add("1");           // 允許重複
        list.add(1, "12");                      // 索引 1 插入
        list.set(2, "a");                       // 修改索引 2
        list.remove("1");                       // 刪除首個 "1"
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        // 輸出：12, a, 3, 1, 1
    }
}

Set 系列：無序、不可重複

Set 介面強制元素唯一，適合去重、成員資格測試等場景。主要實現：

• HashSet：哈希表底層，存取極快（O(1)），無序。
• LinkedHashSet：鏈表+哈希表，維護插入順序。
• TreeSet：紅黑樹底層，元素自動排序（自然順序或 Comparator）。
• CopyOnWriteArraySet：線程安全，寫時復制，適合讀多寫少。

Set 無 get(index)，遍歷需用 Iterator 或增強 for 循環。不支援插入、修改操作。

實戰範例

import java.util.*;

public class SetDemo {
    public static void main(String[] args) {
        Set set = new HashSet<>();
        set.add("1"); set.add("2"); set.add("3");
        set.add("1"); set.add("1");             // 重複元素被忽略
        
        Iterator it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        // 輸出順序不固定，如：3, 2, 1
    }
}

Map 系列：鍵值映射

Map 以 Key-Value 存儲，Key 唯一，Value 可重複。常見實現：

• HashMap：哈希表，高性能，允許 null key/value。
• LinkedHashMap：維護插入或存取順序。
• TreeMap：紅黑樹，Key 自動排序。

核心方法

實戰範例

import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("蘋果", "2.5");
        map.put("桔子", "2.5");
        map.put("香蕉", "3");
        map.put("菠蘿", "2");
        
        map.remove("桔子");          // 刪除
        map.put("菠蘿", "5");        // 修改值
        
        System.out.println("個數：" + map.size());
        
        for (String key : map.keySet()) {
            System.out.println(key + ":" + map.get(key));
        }
        // 輸出：個數：3, 香蕉:3, 菠蘿:5, 蘋果:2.5
    }
}

綜合應用：表達式計算器

利用 Vector（List 實現）存儲拆分後的運算元與運算符，按優先級計算四則運算（不含括號）。

import java.util.*;

public class CalcStr {
    public static void main(String[] args) {
        System.out.println(calc("1+20*3/5"));  // 13.0
    }
    
    public static double calc(String s) {
        Vector v = split(s);
        return calcVector(v);
    }
    
    private static Vector split(String s) {
        Vector v = new Vector<>();
        StringBuilder num = new StringBuilder();
        for (char c : s.toCharArray()) {
            if ("+-*/".indexOf(c) >= 0) {
                v.add(num.toString());
                v.add(String.valueOf(c));
                num.setLength(0);
            } else {
                num.append(c);
            }
        }
        v.add(num.toString());
        return v;
    }
    
    private static double calcVector(Vector v) {
        // 先算乘除
        while (true) {
            int idxMul = v.indexOf("*");
            int idxDiv = v.indexOf("/");
            if (idxMul == -1 && idxDiv == -1) break;
            
            int idx = (idxMul != -1 && (idxDiv == -1 || idxMul < idxDiv)) ? idxMul : idxDiv;
            String op = v.get(idx);
            double a = Double.parseDouble(v.get(idx - 1));
            double b = Double.parseDouble(v.get(idx + 1));
            double res = op.equals("*") ? a * b : a / b;
            
            v.remove(idx - 1); v.remove(idx - 1); v.remove(idx - 1);
            v.insertElementAt(String.valueOf(res), idx - 1);
        }
        // 再算加減
        while (true) {
            int idxAdd = v.indexOf("+");
            int idxSub = v.indexOf("-");
            if (idxAdd == -1 && idxSub == -1) break;
            
            int idx = (idxAdd != -1 && (idxSub == -1 || idxAdd < idxSub)) ? idxAdd : idxSub;
            String op = v.get(idx);
            double a = Double.parseDouble(v.get(idx - 1));
            double b = Double.parseDouble(v.get(idx + 1));
            double res = op.equals("+") ? a + b : a - b;
            
            v.remove(idx - 1); v.remove(idx - 1); v.remove(idx - 1);
            v.insertElementAt(String.valueOf(res), idx - 1);
        }
        return Double.parseDouble(v.get(0));
    }
}

選型建議

• 需頻繁隨機存取、少增刪 → ArrayList
• 需頻繁頭尾增刪、佇列/棧操作 → LinkedList
• 需去重、快速判斷存在性 → HashSet
• 需去重且保持插入順序 → LinkedHashSet
• 需去重且自動排序 → TreeSet
• 鍵值映射、高性能查找 → HashMap
• 鍵值映射且需有序 → TreeMap / LinkedHashMap