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)類(lèi),本文詳細(xì)介紹了集合框架的層次結(jié)構(gòu)、常見(jiàn)接口和實(shí)現(xiàn)類(lèi)的特點(diǎn)、使用場(chǎng)景以及最佳實(shí)踐,幫助開(kāi)發(fā)者高效地進(jìn)行數(shù)據(jù)存儲(chǔ)和操作,感興趣的朋友跟隨小編一起看看吧
引言
Java集合框架是Java語(yǔ)言中用于存儲(chǔ)和操作數(shù)據(jù)的一組核心接口和實(shí)現(xiàn)類(lèi)。它提供了一套標(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)類(lèi)) // │ ├── LinkedList (實(shí)現(xiàn)類(lèi)) // │ └── Vector (實(shí)現(xiàn)類(lèi)，線程安全) // │ └── Stack (子類(lèi)) // ├── Set (接口) // │ ├── HashSet (實(shí)現(xiàn)類(lèi)) // │ │ └── LinkedHashSet (子類(lèi)) // │ └── TreeSet (實(shí)現(xiàn)類(lèi)) // └── Queue (接口) // ├── PriorityQueue (實(shí)現(xiàn)類(lèi)) // └── Deque (接口) // └── ArrayDeque (實(shí)現(xiàn)類(lèi)) // // Map (接口) // ├── HashMap (實(shí)現(xiàn)類(lèi)) // │ └── LinkedHashMap (子類(lèi)) // ├── TreeMap (實(shí)現(xiàn)類(lèi)) // └── Hashtable (實(shí)現(xiàn)類(lèi)，線程安全) // └── Properties (子類(lèi))
1.2 集合框架的優(yōu)勢(shì)
- 標(biāo)準(zhǔn)化：統(tǒng)一的API設(shè)計(jì)，易于學(xué)習(xí)和使用
- 高性能：針對(duì)不同場(chǎng)景優(yōu)化的實(shí)現(xiàn)
- 類(lèi)型安全：通過(guò)泛型確保類(lèi)型安全
- 可擴(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);
}
}四、集合工具類(lèi)：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工具類(lèi)使用
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)類(lèi) | 理由 |
|---|---|---|
| 快速隨機(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)銷(xiāo)大
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ì)介紹了各種集合類(lèi)的特點(diǎn)、使用場(chǎng)景和最佳實(shí)踐：
- 根據(jù)需求選擇合適的集合類(lèi)
- 理解不同集合的性能特征
- 掌握集合的遍歷和操作技巧
- 注意線程安全和并發(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)文章
Java內(nèi)存釋放實(shí)現(xiàn)代碼案例
這篇文章主要介紹了Java內(nèi)存釋放實(shí)現(xiàn)代碼案例,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2020-12-12
Java中的Semaphore計(jì)數(shù)信號(hào)量詳細(xì)解析
這篇文章主要介紹了Java中的Semaphore計(jì)數(shù)信號(hào)量詳細(xì)解析,Semaphore?是一個(gè)計(jì)數(shù)信號(hào)量,必須由獲取它的線程釋放,常用于限制可以訪問(wèn)某些資源的線程數(shù)量,例如通過(guò)?Semaphore?限流,需要的朋友可以參考下2023-11-11
Java查詢(xún)Elasticsearch數(shù)據(jù)根據(jù)指定id檢索(in查詢(xún))、sql權(quán)限過(guò)濾、多字段匹配檢索及數(shù)據(jù)排序
在Java開(kāi)發(fā)中Elasticsearch(簡(jiǎn)稱(chēng)ES)是一個(gè)非常流行的搜索引擎,它提供了強(qiáng)大的全文搜索和分析功能,這篇文章主要給大家介紹了關(guān)于Java查詢(xún)Elasticsearch數(shù)據(jù)根據(jù)指定id檢索(in查詢(xún))、sql權(quán)限過(guò)濾、多字段匹配檢索及數(shù)據(jù)排序的相關(guān)資料,需要的朋友可以參考下2024-05-05
通過(guò)maven配置不同的開(kāi)發(fā)環(huán)境方式
文章介紹了如何使用Maven來(lái)控制不同環(huán)境（開(kāi)發(fā)、測(cè)試、生產(chǎn)）下的配置文件的加載,具體方法包括在項(xiàng)目目錄下創(chuàng)建特定文件夾存放環(huán)境配置文件,以及在pom文件中添加相關(guān)配置,這樣,可以方便地通過(guò)選擇環(huán)境并刷新來(lái)啟動(dòng)項(xiàng)目,提高了配置管理的效率和便捷性2025-10-10
java實(shí)現(xiàn)將ftp和http的文件直接傳送到hdfs
前面幾篇文章，我們已經(jīng)做了很好的鋪墊了，幾個(gè)要用到的工具我們都做了出來(lái)，本文就是將他們集合起來(lái)，說(shuō)下具體的用法，小伙伴們可以參考下。2015-03-03
全面剖析java 數(shù)據(jù)類(lèi)型與運(yùn)算符
這篇文章主要介紹了Java基本數(shù)據(jù)類(lèi)型和運(yùn)算符,結(jié)合實(shí)例形式詳細(xì)分析了java基本數(shù)據(jù)類(lèi)型、數(shù)據(jù)類(lèi)型轉(zhuǎn)換、算術(shù)運(yùn)算符、邏輯運(yùn)算符等相關(guān)原理與操作技巧,需要的朋友可以參考下2021-09-09
Java的異常處理為什么會(huì)影響性能?異常開(kāi)銷(xiāo)很大。那么,這是不是就意味著您不該使用異常?當(dāng)然不是。但是,何時(shí)應(yīng)該使用異常,何時(shí)又不應(yīng)該使用異常呢?不幸的是,答案不是一下子就說(shuō)得清楚的，我們來(lái)詳細(xì)探討下。2015-05-05
java中fastjson生成和解析json數(shù)據(jù)（序列化和反序列化數(shù)據(jù)）
本篇文章主要介紹了java中fastjson生成和解析json數(shù)據(jù)（序列化和反序列化數(shù)據(jù)），具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下。2017-02-02
java注解實(shí)現(xiàn)websocket服務(wù)的兩種方式
Java WebSocket是一種基于TCP協(xié)議的雙向全雙工消息傳輸技術(shù),它允許服務(wù)器和客戶端之間實(shí)時(shí)通信,具有低延遲和高效率的特點(diǎn),下面這篇文章主要給大家介紹了關(guān)于java注解實(shí)現(xiàn)websocket服務(wù)的兩種方式,需要的朋友可以參考下2024-08-08
Java同步鎖synchronized用法的最全總結(jié)
這篇文章主要介紹了Java同步鎖synchronized用法的最全總結(jié),需要的朋友可以參考下,文章詳細(xì)講解了Java同步鎖Synchronized的使用方法和需要注意的點(diǎn)，希望對(duì)你有所幫助2023-03-03