集合框架

/** 包裝類別的快取陷阱：== 比較的是參考，不是數值 */ public class BoxingTrap

public static void main(String[] args)

// 自動裝箱：int 值自動包成 Integer 物件 Integer a = 100; Integer b = 100; Integer c = 1000; Integer d = 1000;

// -128〜127 落在快取區間：a 與 b 指向同一個快取物件 System.out.println("100 == 100：" + (a == b));

// 1000 超出快取區間：c 與 d 是兩個不同的物件 System.out.println("1000 == 1000：" + (c == d));

// 正解：包裝物件一律用 equals 比較數值 System.out.println("equals 比較：" + c.equals(d));

import java.util.ArrayList; import java.util.List;

/** ArrayList 常用操作總覽 */ public class ArrayListBasics

public static void main(String[] args)

// 用介面型別宣告 + 菱形運算子：右邊的型別參數可以省略 List<String> fruits = new ArrayList<>();

fruits.add("蘋果"); // 加到尾端 fruits.add("香蕉"); fruits.add("櫻桃"); fruits.add(1, "藍莓"); // 插到索引 1，後面的元素往後挪 System.out.println("目前內容：" + fruits);

System.out.println("取索引 2：" + fruits.get(2)); System.out.println("元素個數：" + fruits.size()); System.out.println("包含香蕉？" + fruits.contains("香蕉")); System.out.println("香蕉的索引：" + fruits.indexOf("香蕉"));

fruits.set(0, "鳳梨"); // 覆蓋索引 0 的元素 fruits.remove("藍莓"); // 依值刪除（第一個相符者） fruits.remove(1); // 依索引刪除 System.out.println("調整之後：" + fruits); System.out.println("是否為空：" + fruits.isEmpty());

LinkedList<String> queue = new LinkedList<>(); queue.addLast("甲"); // 尾端加入：一般排隊 queue.addLast("乙"); queue.addFirst("急件"); // 頭端插隊：O(1)，不必搬動任何元素 String next = queue.removeFirst(); // 取出隊頭：「急件」

import java.util.ArrayList; import java.util.Iterator; import java.util.List;

/** 四種走訪方式的比較 */ public class TraversalDemo

public static void main(String[] args)

List<String> langs = new ArrayList<>(List.of("Java", "Kotlin", "Go"));

// 方式一：傳統索引 for——需要索引值的時候用 for (int i = 0; i < langs.size(); i++) System.out.println("索引 " + i + "：" + langs.get(i));

// 方式二：for-each——最常用，簡潔且不會寫錯邊界 for (String lang : langs) System.out.print(lang + " "); System.out.println();

// 方式三：Iterator——走訪中需要刪除元素時的正規做法 Iterator<String> it = langs.iterator(); while (it.hasNext()) System.out.print(it.next().length() + " "); System.out.println();

// 方式四：forEach 搭配 lambda（進階篇詳述，先感受寫法） langs.forEach(lang -> System.out.print(lang + " ")); System.out.println();

import java.util.LinkedHashSet; import java.util.Objects; import java.util.Set;

/** 會員：正確覆寫 equals 與 hashCode，HashSet 才能正確去重 */ class Member

private final String id; // 會員編號：身分依據 private final String name;

Member(String id, String name) this.id = id; this.name = name;

@Override public boolean equals(Object obj) if (this == obj) return true; if (obj == null || getClass() != obj.getClass()) return false; return id.equals(((Member) obj).id); // 以編號判斷同一人

@Override public int hashCode() return Objects.hash(id); // 與 equals 使用同一組欄位

@Override public String toString() return name + "(" + id + ")";

/** 驗證去重是否生效 */ public class HashSetDemo

public static void main(String[] args)

// 用 LinkedHashSet 讓輸出順序可預測（依插入順序） Set<Member> members = new LinkedHashSet<>();

members.add(new Member("M001", "小明")); members.add(new Member("M002", "小華")); // 編號重複：equals 與 hashCode 判定為同一人，不會加入 boolean added = members.add(new Member("M001", "小明"));

System.out.println("重複加入成功嗎？" + added); System.out.println("集合內容：" + members); // contains 也是靠 hashCode 與 equals 運作 System.out.println("包含 M002 嗎？" + members.contains(new Member("M002", "任意名字")));

import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; import java.util.TreeSet;

/** 三種 Set 的順序行為比較 */ public class SetOrderDemo

public static void main(String[] args)

String[] data = "banana", "apple", "cherry", "apple" ;

Set<String> hash = new HashSet<>(); // 不保證任何順序 Set<String> linked = new LinkedHashSet<>(); // 記住插入順序 Set<String> tree = new TreeSet<>(); // 隨時保持排序

for (String s : data) // 同一批資料放進三種 Set hash.add(s); linked.add(s); tree.add(s);

// HashSet 的走訪順序不可依賴，因此只印元素個數 System.out.println("元素個數（重複已剔除）：" + hash.size()); System.out.println("LinkedHashSet：" + linked); System.out.println("TreeSet：" + tree);

import java.util.LinkedHashMap; import java.util.Map;

/** Map 常用操作：以「商品庫存」為例 */ public class MapBasics

public static void main(String[] args)

// 用 LinkedHashMap 讓走訪順序可預測（HashMap 不保證順序） Map<String, Integer> stock = new LinkedHashMap<>();

stock.put("鍵盤", 10); // 新增鍵值對 stock.put("滑鼠", 25); stock.put("螢幕", 3); stock.put("鍵盤", 12); // 鍵已存在：新值覆蓋舊值

System.out.println("鍵盤庫存：" + stock.get("鍵盤")); // get 查無此鍵回傳 null；getOrDefault 可以給預設值 System.out.println("耳機庫存：" + stock.getOrDefault("耳機", 0)); System.out.println("有賣螢幕嗎？" + stock.containsKey("螢幕"));

stock.remove("螢幕"); // 依鍵刪除

// merge：鍵存在就用函數合併新舊值；不存在就直接放入 stock.merge("滑鼠", 5, Integer::sum); // 25 + 5 = 30 stock.merge("耳機", 8, Integer::sum); // 不存在，直接放 8

System.out.println("目前庫存：" + stock); System.out.println("商品種類數：" + stock.size());

import java.util.LinkedHashMap; import java.util.Map;

/** Map 的三種走訪方式 */ public class MapTraversal

public static void main(String[] args)

Map<String, Integer> scores = new LinkedHashMap<>(); scores.put("國文", 88); scores.put("英文", 95); scores.put("數學", 72);

// 走訪一：keySet()——只需要鍵 for (String subject : scores.keySet()) System.out.print(subject + " "); System.out.println();

// 走訪二：values()——只需要值 int total = 0; for (int score : scores.values()) total += score; // 自動拆箱：Integer 轉回 int System.out.println("總分：" + total);

// 走訪三：entrySet()——鍵值都要（完整走訪的首選） for (Map.Entry<String, Integer> entry : scores.entrySet()) System.out.println(entry.getKey() + "：" + entry.getValue());

import java.util.ArrayList; import java.util.Comparator; import java.util.List;

/** 學生：示範排序用的簡單資料類別 */ class Student

final String name; // 聚焦排序示範，欄位用套件層級存取 final int score;

Student(String name, int score) this.name = name; this.score = score;

@Override public String toString() return name + "=" + score;

/** Comparator 搭配 lambda：排序規則想怎麼換就怎麼換 */ public class SortingDemo

public static void main(String[] args)

List<Student> list = new ArrayList<>(List.of( new Student("Bob", 92), new Student("Cindy", 85), new Student("Amy", 85), new Student("David", 78)));

// 依分數遞增：comparingInt 接收「怎麼取出比較鍵」的函數 list.sort(Comparator.comparingInt(s -> s.score)); System.out.println("分數遞增：" + list);

// 依分數遞減：reversed() 反轉既有規則 list.sort(Comparator.comparingInt((Student s) -> s.score) .reversed()); System.out.println("分數遞減：" + list);

// 多鍵排序：先比分數（遞減），同分再依姓名字母序 list.sort(Comparator.comparingInt((Student s) -> s.score) .reversed() .thenComparing(s -> s.name)); System.out.println("同分比名：" + list);

import java.util.ArrayList; import java.util.Collections; import java.util.List;

/** Collections 工具類別的常用靜態方法 */ public class CollectionsDemo

public static void main(String[] args)

List<Integer> nums = new ArrayList<>(List.of(5, 1, 4, 2, 3));

Collections.sort(nums); // 遞增排序（就地修改） System.out.println("排序：" + nums);

Collections.reverse(nums); // 反轉 System.out.println("反轉：" + nums);

System.out.println("最大值：" + Collections.max(nums)); System.out.println("最小值：" + Collections.min(nums));

// Collections.shuffle(nums); // 隨機洗牌：每次結果不同

// 不可修改視圖：任何寫入操作都會拋出例外 List<Integer> readOnly = Collections.unmodifiableList(nums); try readOnly.add(99); catch (UnsupportedOperationException e) System.out.println("唯讀清單拒絕修改");

import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map;

/** * 單字頻率統計：集合框架的綜合應用。 * 流程：切割文字、用 HashMap 計數、搬進 List 排序、輸出前三名。 */ public class WordFrequency

public static void main(String[] args)

String text = "the quick brown fox jumps over the lazy dog " + "the fox is quick and the dog is lazy";

// 步驟一：以空白切割成單字陣列 String[] words = text.split(" ");

// 步驟二：HashMap 累計次數（鍵：單字；值：出現次數） Map<String, Integer> freq = new HashMap<>(); for (String w : words) freq.merge(w, 1, Integer::sum); // 首次放 1，之後累加

// 步驟三：Map 本身沒有順序概念，搬進 List 才能排序 List<Map.Entry<String, Integer>> entries = new ArrayList<>(freq.entrySet());

// 次數遞減；次數相同再依字母序，讓結果完全可預測 entries.sort(Comparator .comparingInt((Map.Entry<String, Integer> e) -> e.getValue()) .reversed() .thenComparing(Map.Entry::getKey));

// 步驟四：輸出前三名 System.out.println("出現次數前三名："); for (int i = 0; i < 3; i++) Map.Entry<String, Integer> e = entries.get(i); System.out.println((i + 1) + ". " + e.getKey() + "：" + e.getValue() + " 次");