Java存儲(chǔ)數(shù)據(jù)之?dāng)?shù)組與集合的詳細(xì)操作

更新時(shí)間：2026年01月22日 14:16:29 作者：invicinble

這篇文章主要介紹了Java中數(shù)組和集合的基本概念、優(yōu)勢(shì)和使用場(chǎng)景,并詳細(xì)探討了集合的各個(gè)子類及其特性,同時(shí),文章還涵蓋了如何遍歷集合以及遍歷過(guò)程中的一些注意事項(xiàng),感興趣的朋友跟隨小編一起看看吧

Java存儲(chǔ)數(shù)據(jù)：數(shù)組與集合

一、數(shù)組（Array）

1. 邏輯特征

固定大小：創(chuàng)建時(shí)指定長(zhǎng)度，不能動(dòng)態(tài)改變
類型統(tǒng)一：所有元素必須是相同數(shù)據(jù)類型
內(nèi)存連續(xù)：元素在內(nèi)存中連續(xù)存儲(chǔ)
效率高：通過(guò)索引直接訪問(wèn)，時(shí)間復(fù)雜度O(1)
功能簡(jiǎn)單：提供基本的存儲(chǔ)和訪問(wèn)能力

2. 代碼層面

// 1. 聲明和初始化
int[] numbers = new int[5];  // 長(zhǎng)度為5的整型數(shù)組
String[] names = {"張三", "李四", "王五"};
// 2. 訪問(wèn)和修改
numbers[0] = 10;
System.out.println(numbers[0]);  // 輸出: 10
// 3. 遍歷數(shù)組
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}
// 4. 增強(qiáng)for循環(huán)
for (int num : numbers) {
    System.out.println(num);
}
// 5. 多維數(shù)組
int[][] matrix = new int[3][3];
matrix[0][0] = 1;

3. 數(shù)組的局限性

// 問(wèn)題1: 數(shù)組大小固定，無(wú)法動(dòng)態(tài)擴(kuò)展
int[] arr = new int[3];
// arr[3] = 4;  // ArrayIndexOutOfBoundsException
// 問(wèn)題2: 只能存儲(chǔ)同一類型數(shù)據(jù)
// arr[0] = "hello";  // 編譯錯(cuò)誤
// 問(wèn)題3: 缺少高級(jí)操作方法
// 沒(méi)有內(nèi)置的add(), remove(), contains()等方法

二、為什么需要集合（Collection）

1. 數(shù)組的不足

大小固定：不能動(dòng)態(tài)增長(zhǎng)或收縮
功能有限：缺少增刪改查的高級(jí)方法
類型限制：只能存儲(chǔ)相同類型
代碼繁瑣：需要手動(dòng)處理很多邏輯

2. 集合的優(yōu)勢(shì)

動(dòng)態(tài)擴(kuò)容：自動(dòng)調(diào)整大小
功能豐富：提供各種操作方法
類型靈活：通過(guò)泛型支持類型安全
算法支持：內(nèi)置排序、查找等算法

三、集合知識(shí)體系

Java集合框架 (Java Collections Framework)
│
├── Collection接口 (單列集合)
│   ├── List接口 (有序、可重復(fù))
│   │   ├── ArrayList: 數(shù)組實(shí)現(xiàn)，查詢快，增刪慢
│   │   ├── LinkedList: 鏈表實(shí)現(xiàn)，增刪快，查詢慢
│   │   └── Vector: 線程安全的ArrayList（已過(guò)時(shí)）
│   │
│   ├── Set接口 (無(wú)序、不可重復(fù))
│   │   ├── HashSet: 哈希表實(shí)現(xiàn)
│   │   ├── LinkedHashSet: 有序的HashSet
│   │   └── TreeSet: 紅黑樹(shù)實(shí)現(xiàn)，可排序
│   │
│   └── Queue接口 (隊(duì)列)
│       ├── LinkedList: 也實(shí)現(xiàn)了Queue
│       ├── PriorityQueue: 優(yōu)先級(jí)隊(duì)列
│       └── ArrayDeque: 雙端隊(duì)列
│
└── Map接口 (雙列集合，鍵值對(duì))
    ├── HashMap: 最常用的Map
    ├── LinkedHashMap: 有序的HashMap
    ├── TreeMap: 可排序的Map
    └── Hashtable: 線程安全的Map（已過(guò)時(shí)）

四、主要集合類示例

1. ArrayList（最常用）

// 創(chuàng)建ArrayList
List<String> list = new ArrayList<>();
// 添加元素（自動(dòng)擴(kuò)容）
list.add("Java");
list.add("Python");
list.add("C++");
// 獲取元素
String first = list.get(0);
// 修改元素
list.set(1, "JavaScript");
// 刪除元素
list.remove(2);
// 遍歷
for (String language : list) {
    System.out.println(language);
}
// 其他常用方法
int size = list.size();        // 大小
boolean empty = list.isEmpty(); // 是否為空
boolean contains = list.contains("Java"); // 是否包含

2. LinkedList

// 創(chuàng)建LinkedList
LinkedList<Integer> linkedList = new LinkedList<>();
// 添加元素
linkedList.add(10);
linkedList.addFirst(5);   // 頭部添加
linkedList.addLast(20);   // 尾部添加
// 作為隊(duì)列使用
linkedList.offer(30);     // 入隊(duì)
int head = linkedList.poll(); // 出隊(duì)
// 作為棧使用
linkedList.push(40);      // 壓棧
int top = linkedList.pop(); // 彈棧

3. HashSet

// 創(chuàng)建HashSet
Set<String> set = new HashSet<>();
// 添加元素
set.add("Apple");
set.add("Banana");
set.add("Apple");  // 重復(fù)，不會(huì)添加
// 遍歷（無(wú)序）
for (String fruit : set) {
    System.out.println(fruit);
}
// 常用操作
set.remove("Banana");
boolean hasApple = set.contains("Apple");

4. HashMap

// 創(chuàng)建HashMap
Map<String, Integer> map = new HashMap<>();

// 添加鍵值對(duì)
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 28);

// 獲取值
int age = map.get("Alice");

// 遍歷
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 鍵集合和值集合
Set<String> keys = map.keySet();
Collection<Integer> values = map.values();

五、集合與數(shù)組的對(duì)比

特性	數(shù)組	集合
大小	固定，聲明時(shí)確定	動(dòng)態(tài)，可自動(dòng)擴(kuò)容
類型	必須統(tǒng)一	通過(guò)泛型支持多種類型
性能	訪問(wèn)快(O(1))	實(shí)現(xiàn)不同，性能各異
功能	基本操作	豐富的高級(jí)操作
存儲(chǔ)	基本類型和對(duì)象	只能存儲(chǔ)對(duì)象
線程安全	不安全	大部分不安全

六、最佳實(shí)踐建議

優(yōu)先使用集合：除非對(duì)性能有極致要求，否則優(yōu)先使用集合
選擇合適的集合：
- 需要頻繁查詢 → ArrayList
- 需要頻繁增刪 → LinkedList
- 需要去重 → HashSet
- 需要鍵值對(duì) → HashMap
使用泛型：確保類型安全
考慮線程安全：多線程環(huán)境使用ConcurrentHashMap、CopyOnWriteArrayList
初始化大小：如果知道大概數(shù)據(jù)量，可以指定初始容量

// 指定初始容量
List<String> list = new ArrayList<>(1000);
Map<String, Integer> map = new HashMap<>(500);

七、總結(jié)

數(shù)組是Java語(yǔ)言的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)，簡(jiǎn)單高效但功能有限
集合是對(duì)數(shù)組的封裝和擴(kuò)展，提供了更強(qiáng)大、更靈活的數(shù)據(jù)管理能力
現(xiàn)代Java開(kāi)發(fā)中，集合是首選，數(shù)組主要用于：
- 性能敏感的場(chǎng)景
- 處理基本數(shù)據(jù)類型
- 與遺留代碼或API交互
理解不同集合的特性，根據(jù)需求選擇最合適的工具

實(shí)際開(kāi)發(fā)中，ArrayList和HashMap是最常用的集合類，掌握了它們就解決了80%的數(shù)據(jù)存儲(chǔ)問(wèn)題。

好的，專門(mén)說(shuō)說(shuō)遍歷集合！這是天天要用的操作，分幾種情況給你講清楚。

List遍歷（最常用）

1.普通for循環(huán)（有索引時(shí)用）

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (int i = 0; i < list.size(); i++) {
    String item = list.get(i);
    System.out.println(item);
}

優(yōu)點(diǎn)：能拿到索引，方便操作
缺點(diǎn)：只有 ArrayList 這種基于數(shù)組的用著快，LinkedList 用這個(gè)就慢（因?yàn)橐粋€(gè)個(gè)數(shù)過(guò)去）

2.增強(qiáng)for循環(huán)（最常用、最簡(jiǎn)潔）

for (String item : list) {
    System.out.println(item);
}

優(yōu)點(diǎn)：寫(xiě)法簡(jiǎn)單，可讀性好
缺點(diǎn)：遍歷時(shí)不能修改集合（刪除、新增會(huì)拋異常）

3.迭代器Iterator（可以在遍歷時(shí)安全刪除）

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if ("B".equals(item)) {
        iterator.remove();  // 安全刪除當(dāng)前元素
    }
}

優(yōu)點(diǎn)：唯一能在遍歷時(shí)安全刪除元素的方式
缺點(diǎn)：代碼稍多

4.ListIterator（雙向遍歷，可以修改）

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String item = listIterator.next();
    if ("B".equals(item)) {
        listIterator.set("B+");  // 修改當(dāng)前元素
    }
}
// 還可以倒著遍歷
while (listIterator.hasPrevious()) {
    System.out.println(listIterator.previous());
}

5.Java 8的forEach + Lambda（很流行）

// 方式1：Lambda表達(dá)式
list.forEach(item -> System.out.println(item));
// 方式2：方法引用
list.forEach(System.out::println);
// 帶索引的（Java 8沒(méi)有原生支持，但可以這樣）
IntStream.range(0, list.size())
         .forEach(i -> System.out.println(i + ": " + list.get(i)));

Set遍歷

Set沒(méi)索引，所以只能用這幾種：

Set<String> set = new HashSet<>(Arrays.asList("A", "B", "C"));
// 1. 增強(qiáng)for循環(huán)
for (String item : set) {
    System.out.println(item);
}
// 2. 迭代器
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}
// 3. Java 8 forEach
set.forEach(item -> System.out.println(item));

Map遍歷（重點(diǎn)！）

1.遍歷EntrySet（最推薦、最高效）

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + "=" + value);
}

為什么最推薦？：一次遍歷同時(shí)拿到key和value，不用再通過(guò)key去查value（map.get(key) 還有哈希計(jì)算的開(kāi)銷）

2.遍歷KeySet（不推薦在遍歷中取值）

for (String key : map.keySet()) {
    Integer value = map.get(key);  // 這里又做了一次哈希查找
    System.out.println(key + "=" + value);
}

缺點(diǎn)：多了一次 map.get(key) 的哈希查找，效率低

3.遍歷Values（只關(guān)心值時(shí)用）

for (Integer value : map.values()) {
    System.out.println(value);
}

4.迭代器方式

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    // 可以在遍歷時(shí)刪除
    if ("A".equals(entry.getKey())) {
        iterator.remove();
    }
}

5.Java 8的forEach（最簡(jiǎn)潔）

// Lambda表達(dá)式
map.forEach((key, value) -> System.out.println(key + "=" + value));
// 或者用entrySet的stream
map.entrySet().stream()
    .filter(entry -> entry.getValue() > 1)
    .forEach(entry -> System.out.println(entry.getKey()));

遍歷時(shí)的注意事項(xiàng)

1.不要在foreach循環(huán)里直接增刪元素

// ? 錯(cuò)誤！會(huì)拋 ConcurrentModificationException
for (String item : list) {
    if ("B".equals(item)) {
        list.remove(item);  // 直接調(diào)用list的remove
    }
}
// ? 正確！用迭代器的remove
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("B".equals(it.next())) {
        it.remove();  // 用迭代器自己的remove方法
    }
}

2.Java 8的removeIf（刪除元素新姿勢(shì)）

// 刪除所有值為"B"的元素
list.removeIf(item -> "B".equals(item));
// Map刪除滿足條件的entry
map.entrySet().removeIf(entry -> entry.getValue() > 10);

3.并行遍歷（大數(shù)據(jù)量時(shí)考慮）

// 使用parallelStream（注意線程安全）
list.parallelStream().forEach(item -> {
    // 這里可以并行處理
});
// 或者用ConcurrentHashMap的forEach（線程安全）
ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.forEach(1, (key, value) -> System.out.println(key));

實(shí)際工作怎么選？

日常開(kāi)發(fā)：

單純遍歷List/Set → 增強(qiáng)for循環(huán)（最簡(jiǎn)潔）
遍歷Map → entrySet + 增強(qiáng)for 或 map.forEach()
需要在遍歷時(shí)刪除 → 迭代器 或 removeIf()
Java 8+環(huán)境 → 多用 forEach + Lambda（代碼簡(jiǎn)潔）

性能考慮：

大數(shù)據(jù)量List → ArrayList用普通for最快，LinkedList用迭代器
Map遍歷 → 一定用entrySet，別用keySet+get

記憶口訣：

List遍歷：普通for要索引，增強(qiáng)for最方便，要?jiǎng)h就用迭代器
Map遍歷：entrySet是王道，keySet效率低，Java8 forEach潮

這樣清楚了嗎？實(shí)際寫(xiě)代碼時(shí)多試試，自然就熟練了！

到此這篇關(guān)于Java存儲(chǔ)數(shù)據(jù)：數(shù)組與集合的文章就介紹到這了,更多相關(guān)java存儲(chǔ)數(shù)據(jù)內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线