Java集合框架數(shù)據(jù)存儲(chǔ)與操作的神器
更新時(shí)間：2025年12月24日 09:16:32 作者：情愛(ài)少有真誠(chéng)
Java集合框架提供了多種數(shù)據(jù)結(jié)構(gòu)和操作方法,包括Collection接口、Map接口以及各種實(shí)現(xiàn)類,本文詳細(xì)介紹了集合框架的層次結(jié)構(gòu)、常見(jiàn)接口和實(shí)現(xiàn)類的特點(diǎn)、使用場(chǎng)景以及最佳實(shí)踐,幫助開(kāi)發(fā)者高效地進(jìn)行數(shù)據(jù)存儲(chǔ)和操作,感興趣的朋友跟隨小編一起看看吧
引言
Java集合框架是Java語(yǔ)言中用于存儲(chǔ)和操作數(shù)據(jù)的一組核心接口和實(shí)現(xiàn)類。它提供了一套標(biāo)準(zhǔn)化的方法來(lái)處理各種數(shù)據(jù)結(jié)構(gòu)，使開(kāi)發(fā)人員能夠?qū)Ｗ⒂跇I(yè)務(wù)邏輯而不是底層數(shù)據(jù)結(jié)構(gòu)的實(shí)現(xiàn)。本文將深入探討Java集合框架的各個(gè)組成部分，并通過(guò)實(shí)例展示如何高效地使用它們。
一、集合框架概覽
1.1 集合框架層次結(jié)構(gòu)
Java集合框架主要分為兩大分支：
- Collection接口：?jiǎn)瘟袛?shù)據(jù)集合，包括List、Set和Queue
- Map接口：雙列數(shù)據(jù)集合，存儲(chǔ)鍵值對(duì)
// 集合框架主要接口關(guān)系圖 // Collection (接口) // ├── List (接口) // │ ├── ArrayList (實(shí)現(xiàn)類) // │ ├── LinkedList (實(shí)現(xiàn)類) // │ └── Vector (實(shí)現(xiàn)類，線程安全) // │ └── Stack (子類) // ├── Set (接口) // │ ├── HashSet (實(shí)現(xiàn)類) // │ │ └── LinkedHashSet (子類) // │ └── TreeSet (實(shí)現(xiàn)類) // └── Queue (接口) // ├── PriorityQueue (實(shí)現(xiàn)類) // └── Deque (接口) // └── ArrayDeque (實(shí)現(xiàn)類) // // Map (接口) // ├── HashMap (實(shí)現(xiàn)類) // │ └── LinkedHashMap (子類) // ├── TreeMap (實(shí)現(xiàn)類) // └── Hashtable (實(shí)現(xiàn)類，線程安全) // └── Properties (子類)
1.2 集合框架的優(yōu)勢(shì)
- 標(biāo)準(zhǔn)化：統(tǒng)一的API設(shè)計(jì)，易于學(xué)習(xí)和使用
- 高性能：針對(duì)不同場(chǎng)景優(yōu)化的實(shí)現(xiàn)
- 類型安全：通過(guò)泛型確保類型安全
- 可擴(kuò)展：易于擴(kuò)展和自定義實(shí)現(xiàn)
- 算法支持：內(nèi)置排序、搜索等算法
二、Collection接口及其實(shí)現(xiàn)
2.1 List接口：有序、可重復(fù)的集合
import java.util.*;
public class ListExample {
public static void main(String[] args) {
// 1. ArrayList - 基于動(dòng)態(tài)數(shù)組，隨機(jī)訪問(wèn)快
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("Python");
arrayList.add("C++");
arrayList.add(1, "JavaScript"); // 在指定位置插入
System.out.println("ArrayList內(nèi)容: " + arrayList);
System.out.println("第二個(gè)元素: " + arrayList.get(1));
System.out.println("元素?cái)?shù)量: " + arrayList.size());
// ArrayList的遍歷方式
System.out.println("\nArrayList遍歷:");
// 方式1：普通for循環(huán)
for (int i = 0; i < arrayList.size(); i++) {
System.out.print(arrayList.get(i) + " ");
}
// 方式2：增強(qiáng)for循環(huán)
System.out.println("\n增強(qiáng)for循環(huán):");
for (String language : arrayList) {
System.out.print(language + " ");
}
// 方式3：迭代器
System.out.println("\n迭代器遍歷:");
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
// 方式4：Lambda表達(dá)式（Java 8+）
System.out.println("\nLambda表達(dá)式遍歷:");
arrayList.forEach(lang -> System.out.print(lang + " "));
// 方式5：方法引用
System.out.println("\n方法引用遍歷:");
arrayList.forEach(System.out::print);
// 2. LinkedList - 基于雙向鏈表，插入刪除快
List<Integer> linkedList = new LinkedList<>();
linkedList.add(10);
linkedList.add(20);
linkedList.add(30);
linkedList.addFirst(5); // 在開(kāi)頭添加
linkedList.addLast(40); // 在末尾添加
System.out.println("\n\nLinkedList內(nèi)容: " + linkedList);
System.out.println("第一個(gè)元素: " + ((LinkedList<Integer>) linkedList).getFirst());
System.out.println("最后一個(gè)元素: " + ((LinkedList<Integer>) linkedList).getLast());
// LinkedList作為隊(duì)列使用
Queue<Integer> queue = new LinkedList<>(linkedList);
System.out.println("\n隊(duì)列操作:");
System.out.println("隊(duì)首元素: " + queue.peek());
System.out.println("出隊(duì)元素: " + queue.poll());
System.out.println("剩余隊(duì)列: " + queue);
// LinkedList作為棧使用
Deque<Integer> stack = new LinkedList<>();
stack.push(1); // 入棧
stack.push(2);
stack.push(3);
System.out.println("\n棧操作:");
System.out.println("棧頂元素: " + stack.peek());
System.out.println("出棧元素: " + stack.pop());
System.out.println("剩余棧: " + stack);
// 3. Vector - 線程安全的ArrayList（已過(guò)時(shí)，不推薦使用）
List<String> vector = new Vector<>();
vector.add("線程安全");
vector.add("但不推薦使用");
System.out.println("\nVector: " + vector);
}
}2.2 Set接口：無(wú)序、不可重復(fù)的集合
import java.util.*;
public class SetExample {
public static void main(String[] args) {
// 1. HashSet - 基于哈希表，無(wú)序
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");
hashSet.add("Apple"); // 重復(fù)元素不會(huì)被添加
System.out.println("HashSet: " + hashSet);
System.out.println("包含Banana? " + hashSet.contains("Banana"));
System.out.println("Set大小: " + hashSet.size());
// 2. LinkedHashSet - 保持插入順序的HashSet
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("第一");
linkedHashSet.add("第二");
linkedHashSet.add("第三");
linkedHashSet.add("第一"); // 不會(huì)重復(fù)添加
System.out.println("\nLinkedHashSet: " + linkedHashSet);
// 3. TreeSet - 基于紅黑樹(shù)，自動(dòng)排序
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(2);
treeSet.add(8);
treeSet.add(1);
treeSet.add(5); // 不會(huì)重復(fù)添加
System.out.println("\nTreeSet（自然排序）: " + treeSet);
// 自定義排序的TreeSet
Set<String> customTreeSet = new TreeSet<>((s1, s2) ->
s2.compareTo(s1)); // 降序排序
customTreeSet.add("Java");
customTreeSet.add("Python");
customTreeSet.add("C++");
System.out.println("TreeSet（自定義降序）: " + customTreeSet);
// Set操作：交集、并集、差集
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
// 并集
Set<Integer> union = new HashSet<>(set1);
union.addAll(set2);
System.out.println("\n并集: " + union);
// 交集
Set<Integer> intersection = new HashSet<>(set1);
intersection.retainAll(set2);
System.out.println("交集: " + intersection);
// 差集（set1 - set2）
Set<Integer> difference = new HashSet<>(set1);
difference.removeAll(set2);
System.out.println("差集(set1-set2): " + difference);
}
}2.3 Queue接口：隊(duì)列實(shí)現(xiàn)
import java.util.*;
public class QueueExample {
public static void main(String[] args) {
// 1. PriorityQueue - 優(yōu)先級(jí)隊(duì)列
Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(5);
priorityQueue.offer(1);
priorityQueue.offer(3);
priorityQueue.offer(2);
priorityQueue.offer(4);
System.out.println("PriorityQueue元素: " + priorityQueue);
System.out.println("按優(yōu)先級(jí)出隊(duì):");
while (!priorityQueue.isEmpty()) {
System.out.print(priorityQueue.poll() + " ");
}
// 自定義優(yōu)先級(jí)的PriorityQueue
Queue<String> customPriorityQueue = new PriorityQueue<>(
(s1, s2) -> s2.length() - s1.length() // 按字符串長(zhǎng)度降序
);
customPriorityQueue.offer("Java");
customPriorityQueue.offer("Python");
customPriorityQueue.offer("C");
customPriorityQueue.offer("JavaScript");
System.out.println("\n\n按字符串長(zhǎng)度優(yōu)先級(jí)出隊(duì):");
while (!customPriorityQueue.isEmpty()) {
System.out.print(customPriorityQueue.poll() + " ");
}
// 2. ArrayDeque - 雙端隊(duì)列
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("前端"); // 添加到隊(duì)首
deque.addLast("后端"); // 添加到隊(duì)尾
deque.offerFirst("移動(dòng)端");
deque.offerLast("數(shù)據(jù)庫(kù)");
System.out.println("\n\nArrayDeque內(nèi)容: " + deque);
System.out.println("隊(duì)首元素: " + deque.peekFirst());
System.out.println("隊(duì)尾元素: " + deque.peekLast());
System.out.println("移除隊(duì)首: " + deque.pollFirst());
System.out.println("移除隊(duì)尾: " + deque.pollLast());
System.out.println("剩余隊(duì)列: " + deque);
// 使用ArrayDeque作為棧
Deque<Integer> stack = new ArrayDeque<>();
stack.push(10); // 入棧
stack.push(20);
stack.push(30);
System.out.println("\nArrayDeque作為棧:");
System.out.println("棧頂元素: " + stack.peek());
System.out.println("出棧: " + stack.pop());
System.out.println("出棧后: " + stack);
}
}三、Map接口及其實(shí)現(xiàn)
import java.util.*;
public class MapExample {
public static void main(String[] args) {
// 1. HashMap - 最常用的Map實(shí)現(xiàn)
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Java", 95);
hashMap.put("Python", 90);
hashMap.put("C++", 88);
hashMap.put("Java", 96); // 更新已有鍵的值
hashMap.putIfAbsent("JavaScript", 92); // 僅當(dāng)鍵不存在時(shí)放入
System.out.println("HashMap內(nèi)容: " + hashMap);
System.out.println("Java的分?jǐn)?shù): " + hashMap.get("Java"));
System.out.println("包含Python鍵? " + hashMap.containsKey("Python"));
System.out.println("包含分?jǐn)?shù)90? " + hashMap.containsValue(90));
System.out.println("Map大小: " + hashMap.size());
// HashMap遍歷方式
System.out.println("\nHashMap遍歷:");
// 方式1：遍歷鍵集合
System.out.println("遍歷鍵:");
for (String key : hashMap.keySet()) {
System.out.println(key + ": " + hashMap.get(key));
}
// 方式2：遍歷值集合
System.out.println("\n遍歷值:");
for (Integer value : hashMap.values()) {
System.out.println(value);
}
// 方式3：遍歷鍵值對(duì)集合
System.out.println("\n遍歷鍵值對(duì):");
for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 方式4：迭代器遍歷
System.out.println("\n迭代器遍歷:");
Iterator<Map.Entry<String, Integer>> iterator =
hashMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 方式5：Lambda表達(dá)式（Java 8+）
System.out.println("\nLambda表達(dá)式遍歷:");
hashMap.forEach((key, value) ->
System.out.println(key + ": " + value));
// 2. LinkedHashMap - 保持插入順序的HashMap
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("第一", 1);
linkedHashMap.put("第二", 2);
linkedHashMap.put("第三", 3);
System.out.println("\nLinkedHashMap（保持插入順序）: " + linkedHashMap);
// 3. TreeMap - 基于紅黑樹(shù)，按鍵排序
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Orange", 3);
treeMap.put("Apple", 5);
treeMap.put("Banana", 2);
System.out.println("\nTreeMap（按鍵排序）: " + treeMap);
// 自定義排序的TreeMap
Map<String, Integer> customTreeMap = new TreeMap<>(
(s1, s2) -> s2.compareTo(s1) // 降序排序
);
customTreeMap.put("Java", 95);
customTreeMap.put("Python", 90);
customTreeMap.put("C++", 88);
System.out.println("TreeMap（自定義降序）: " + customTreeMap);
// Map操作示例
System.out.println("\nMap操作示例:");
// 獲取或默認(rèn)值
int javaScore = hashMap.getOrDefault("Java", 0);
int rubyScore = hashMap.getOrDefault("Ruby", 0);
System.out.println("Java分?jǐn)?shù): " + javaScore);
System.out.println("Ruby分?jǐn)?shù)（默認(rèn)0）: " + rubyScore);
// 替換值
hashMap.replace("Python", 90, 95);
System.out.println("替換后Python分?jǐn)?shù): " + hashMap.get("Python"));
// 合并值
hashMap.merge("Java", 2, (oldValue, newValue) -> oldValue + newValue);
System.out.println("合并后Java分?jǐn)?shù): " + hashMap.get("Java"));
// 計(jì)算值（如果鍵不存在）
hashMap.computeIfAbsent("Go", k -> 85);
System.out.println("Go分?jǐn)?shù): " + hashMap.get("Go"));
// 刪除鍵
hashMap.remove("C++");
System.out.println("刪除C++后: " + hashMap);
}
}四、集合工具類：Collections和Arrays
import java.util.*;
public class CollectionsExample {
public static void main(String[] args) {
// 創(chuàng)建測(cè)試數(shù)據(jù)
List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));
List<String> fruits = new ArrayList<>(Arrays.asList(
"Apple", "Banana", "Orange", "Grape", "Mango"
));
// 1. 排序操作
System.out.println("原始列表: " + numbers);
Collections.sort(numbers);
System.out.println("排序后: " + numbers);
// 自定義排序
Collections.sort(fruits, (s1, s2) -> s2.compareTo(s1)); // 降序
System.out.println("水果降序: " + fruits);
// 2. 查找操作
int index = Collections.binarySearch(numbers, 8);
System.out.println("\n元素8的索引: " + index);
// 3. 反轉(zhuǎn)和隨機(jī)排序
Collections.reverse(numbers);
System.out.println("反轉(zhuǎn)后: " + numbers);
Collections.shuffle(numbers);
System.out.println("隨機(jī)排序后: " + numbers);
// 4. 最大最小值
System.out.println("最大值: " + Collections.max(numbers));
System.out.println("最小值: " + Collections.min(numbers));
// 5. 填充和復(fù)制
List<Integer> copy = new ArrayList<>(Collections.nCopies(5, 0));
System.out.println("\n填充5個(gè)0: " + copy);
Collections.fill(copy, 1);
System.out.println("填充為1后: " + copy);
// 6. 不可變集合
List<String> unmodifiableList =
Collections.unmodifiableList(fruits);
System.out.println("\n不可變列表: " + unmodifiableList);
// 7. 同步集合（線程安全）
List<String> synchronizedList =
Collections.synchronizedList(new ArrayList<>());
synchronizedList.add("線程安全");
System.out.println("同步列表: " + synchronizedList);
// 8. Arrays工具類使用
int[] array = {5, 2, 8, 1, 9};
System.out.println("\n原始數(shù)組: " + Arrays.toString(array));
Arrays.sort(array);
System.out.println("排序后數(shù)組: " + Arrays.toString(array));
int[] filledArray = new int[5];
Arrays.fill(filledArray, 7);
System.out.println("填充數(shù)組: " + Arrays.toString(filledArray));
int[] copyArray = Arrays.copyOf(array, 3);
System.out.println("復(fù)制前3個(gè)元素: " + Arrays.toString(copyArray));
}
}五、Java 8+新特性：Stream API
import java.util.*;
import java.util.stream.*;
public class StreamExample {
public static void main(String[] args) {
List<String> languages = Arrays.asList(
"Java", "Python", "JavaScript", "C++", "Go", "Ruby", "Swift"
);
// 1. 過(guò)濾和收集
List<String> filtered = languages.stream()
.filter(lang -> lang.startsWith("J")) // 過(guò)濾以J開(kāi)頭的
.collect(Collectors.toList()); // 收集到List
System.out.println("以J開(kāi)頭的語(yǔ)言: " + filtered);
// 2. 映射轉(zhuǎn)換
List<String> upperCase = languages.stream()
.map(String::toUpperCase) // 轉(zhuǎn)為大寫(xiě)
.collect(Collectors.toList());
System.out.println("大寫(xiě)語(yǔ)言: " + upperCase);
// 3. 排序
List<String> sorted = languages.stream()
.sorted() // 自然排序
.collect(Collectors.toList());
System.out.println("排序后: " + sorted);
// 4. 限制和跳過(guò)
List<String> limited = languages.stream()
.limit(3) // 取前3個(gè)
.collect(Collectors.toList());
System.out.println("前3個(gè)語(yǔ)言: " + limited);
// 5. 統(tǒng)計(jì)操作
long count = languages.stream()
.filter(lang -> lang.length() > 3)
.count();
System.out.println("長(zhǎng)度大于3的語(yǔ)言數(shù)量: " + count);
// 6. 查找操作
Optional<String> first = languages.stream()
.filter(lang -> lang.length() > 5)
.findFirst();
first.ifPresent(lang ->
System.out.println("第一個(gè)長(zhǎng)度大于5的語(yǔ)言: " + lang));
// 7. 去重
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinct = numbers.stream()
.distinct() // 去重
.collect(Collectors.toList());
System.out.println("去重后: " + distinct);
// 8. 規(guī)約操作
Optional<Integer> sum = numbers.stream()
.reduce(Integer::sum); // 求和
sum.ifPresent(s -> System.out.println("總和: " + s));
// 9. 分組操作
Map<Integer, List<String>> grouped = languages.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println("按長(zhǎng)度分組: " + grouped);
// 10. 并行流
List<String> parallelResult = languages.parallelStream()
.filter(lang -> lang.length() > 2)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println("并行流處理結(jié)果: " + parallelResult);
}
}六、最佳實(shí)踐和性能優(yōu)化
6.1 集合選擇指南
| 需求 | 推薦實(shí)現(xiàn)類 | 理由 |
|---|---|---|
| 快速隨機(jī)訪問(wèn) | ArrayList | 基于數(shù)組，O(1)訪問(wèn) |
| 頻繁插入刪除 | LinkedList | 基于鏈表，O(1)插入刪除 |
| 需要排序 | TreeSet/TreeMap | 自動(dòng)排序 |
| 需要唯一元素 | HashSet/HashMap | 基于哈希表，O(1)查找 |
| 需要保持插入順序 | LinkedHashSet/LinkedHashMap | 保持插入順序 |
| 線程安全需求 | CopyOnWriteArrayList, ConcurrentHashMap | 并發(fā)安全 |
6.2 性能優(yōu)化建議
import java.util.*;
public class PerformanceTips {
public static void main(String[] args) {
// 1. 指定初始容量
List<String> list = new ArrayList<>(1000); // 避免頻繁擴(kuò)容
Map<String, Integer> map = new HashMap<>(1000, 0.75f);
// 2. 使用增強(qiáng)for循環(huán)而非迭代器
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 推薦：增強(qiáng)for循環(huán)
for (Integer num : numbers) {
System.out.print(num + " ");
}
// 3. 使用entrySet遍歷Map
Map<String, Integer> scores = new HashMap<>();
scores.put("Java", 95);
scores.put("Python", 90);
// 推薦：遍歷entrySet
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 不推薦：遍歷keySet再get
for (String key : scores.keySet()) {
System.out.println(key + ": " + scores.get(key)); // 兩次查找
}
// 4. 批量操作
List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> target = new ArrayList<>(source.size());
// 推薦：批量添加
target.addAll(source);
// 5. 使用不可變集合
List<String> immutableList = List.of("A", "B", "C"); // Java 9+
Set<String> immutableSet = Set.of("A", "B", "C");
Map<String, Integer> immutableMap = Map.of("A", 1, "B", 2);
// 6. 并發(fā)場(chǎng)景使用并發(fā)集合
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("Key1", 1);
concurrentMap.putIfAbsent("Key2", 2);
}
}七、常見(jiàn)問(wèn)題與解決方案
7.1 集合的線程安全問(wèn)題
import java.util.*;
import java.util.concurrent.*;
public class ThreadSafeCollections {
public static void main(String[] args) throws InterruptedException {
// 1. 非線程安全的HashMap
Map<String, Integer> unsafeMap = new HashMap<>();
// 2. 使用Collections.synchronizedMap包裝
Map<String, Integer> synchronizedMap =
Collections.synchronizedMap(new HashMap<>());
// 3. 使用ConcurrentHashMap（推薦）
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
// 測(cè)試線程安全
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
final int index = i;
executor.execute(() -> {
concurrentMap.put("key" + index, index);
});
}
executor.shutdown();
executor.awaitTermination(1, TimeUnit.SECONDS);
System.out.println("ConcurrentHashMap大小: " + concurrentMap.size());
// 4. CopyOnWriteArrayList用于讀多寫(xiě)少的場(chǎng)景
List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
copyOnWriteList.add("Java");
copyOnWriteList.add("Python");
// 迭代時(shí)安全，但寫(xiě)操作開(kāi)銷大
for (String item : copyOnWriteList) {
System.out.println(item);
}
}
}7.2 避免ConcurrentModificationException
import java.util.*;
public class ConcurrentModificationFix {
public static void main(String[] args) {
List<String> list = new ArrayList<>(Arrays.asList(
"Java", "Python", "C++", "JavaScript"
));
// 錯(cuò)誤示例：在迭代時(shí)修改集合
try {
for (String lang : list) {
if (lang.equals("C++")) {
list.remove(lang); // 拋出ConcurrentModificationException
}
}
} catch (ConcurrentModificationException e) {
System.out.println("錯(cuò)誤：迭代時(shí)修改集合");
}
// 正確方法1：使用迭代器的remove方法
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String lang = iterator.next();
if (lang.equals("C++")) {
iterator.remove(); // 安全刪除
}
}
System.out.println("方法1處理后: " + list);
// 正確方法2：使用Java 8+的removeIf
list.add("C++"); // 恢復(fù)數(shù)據(jù)
list.removeIf(lang -> lang.equals("C++"));
System.out.println("方法2處理后: " + list);
// 正確方法3：收集要?jiǎng)h除的元素，最后統(tǒng)一刪除
list.add("C++"); // 恢復(fù)數(shù)據(jù)
List<String> toRemove = new ArrayList<>();
for (String lang : list) {
if (lang.equals("C++")) {
toRemove.add(lang);
}
}
list.removeAll(toRemove);
System.out.println("方法3處理后: " + list);
}
}總結(jié)
Java集合框架是Java編程中最重要的組成部分之一，掌握好集合框架的使用對(duì)于編寫(xiě)高效、可維護(hù)的代碼至關(guān)重要。本文詳細(xì)介紹了各種集合類的特點(diǎn)、使用場(chǎng)景和最佳實(shí)踐：
- 根據(jù)需求選擇合適的集合類
- 理解不同集合的性能特征
- 掌握集合的遍歷和操作技巧
- 注意線程安全和并發(fā)修改問(wèn)題
- 善用Java 8+的新特性如Stream API
記住，沒(méi)有"最好"的集合，只有"最適合"的集合。在實(shí)際開(kāi)發(fā)中，根據(jù)具體需求選擇合適的集合實(shí)現(xiàn)，才能真正發(fā)揮集合框架的威力。
學(xué)習(xí)建議：
- 深入理解各種集合的內(nèi)部實(shí)現(xiàn)原理
- 掌握J(rèn)ava 8+的Lambda表達(dá)式和Stream API
- 學(xué)習(xí)并發(fā)集合的使用場(chǎng)景
- 了解Java版本更新中集合框架的新特性
希望這篇博客能幫助您全面掌握J(rèn)ava集合框架，提升編程效率！
到此這篇關(guān)于Java集合框架：數(shù)據(jù)存儲(chǔ)與操作的利器的文章就介紹到這了,更多相關(guān)java集合框架內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
springboot+jsonp解決前端跨域問(wèn)題小結(jié)
這篇文章主要介紹了springboot+jsonp解決前端跨域問(wèn)題小結(jié)，小編覺(jué)得挺不錯(cuò)的，現(xiàn)在分享給大家，也給大家做個(gè)參考。一起跟隨小編過(guò)來(lái)看看吧2018-06-06
docx格式的文件本質(zhì)上是一個(gè)XML文件,只要用占位符在指定的地方標(biāo)記,然后替換掉標(biāo)記出的內(nèi)容，這篇文章主要介紹了java替換word/doc文件中的內(nèi)容,需要的朋友可以參考下2023-06-06
springboot基于Redis發(fā)布訂閱集群下WebSocket的解決方案
這篇文章主要介紹了springboot基于Redis發(fā)布訂閱集群下WebSocket的解決方案，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
mybatis教程之增刪改查_(kāi)動(dòng)力節(jié)點(diǎn)Java學(xué)院整理
這篇文章主要介紹了mybatis教程之增刪改查,小編覺(jué)得挺不錯(cuò)的，現(xiàn)在分享給大家，也給大家做個(gè)參考。一起跟隨小編過(guò)來(lái)看看吧2017-09-09
這篇文章主要為大家介紹了java線程池參數(shù)自定義設(shè)置詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-11-11
完美解決MybatisPlus插件分頁(yè)查詢不起作用總是查詢?nèi)繑?shù)據(jù)問(wèn)題
這篇文章主要介紹了解決MybatisPlus插件分頁(yè)查詢不起作用總是查詢?nèi)繑?shù)據(jù)問(wèn)題,本文給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2020-08-08
淺談java線程中生產(chǎn)者與消費(fèi)者的問(wèn)題
下面小編就為大家?guī)?lái)一篇淺談java線程中生產(chǎn)者與消費(fèi)者的問(wèn)題。小編覺(jué)得挺不錯(cuò)的，現(xiàn)在就分享給大家，也給大家做個(gè)參考。一起跟隨小編過(guò)來(lái)看看吧2016-07-07
java連接mysql數(shù)據(jù)庫(kù)亂碼的解決方法
這篇文章主要介紹通過(guò)java連接mysql數(shù)據(jù)庫(kù)的時(shí)候，頁(yè)面出現(xiàn)亂碼，這里簡(jiǎn)單分享下解決方法， 需要的朋友可以參考下2013-05-05
詳解Eclipse Validating緩慢的優(yōu)化
這篇文章主要介紹了詳解Eclipse Validating緩慢的優(yōu)化，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2021-03-03
SpringMVC攔截器創(chuàng)建配置及執(zhí)行順序
這篇文章主要為大家介紹了SpringMVC攔截器創(chuàng)建配置及執(zhí)行順序，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-05-05