Java中的數(shù)組與集合基本用法詳解

更新時間：2025年07月08日 11:21:12 作者：JosieBook

本文介紹了Java數(shù)組和集合框架的基礎(chǔ)知識,數(shù)組部分涵蓋了一維、二維及多維數(shù)組的聲明、初始化、訪問與遍歷方法,以及Arrays類的常用操作,對Java數(shù)組與集合相關(guān)知識感興趣的朋友一起看看吧

一、Java數(shù)組基礎(chǔ)

1.1 數(shù)組結(jié)構(gòu)概述

數(shù)組是Java中最基本的數(shù)據(jù)結(jié)構(gòu)之一，用于存儲相同類型的多個元素。數(shù)組具有以下特點：

固定大?。阂坏﹦?chuàng)建，大小不可改變
連續(xù)內(nèi)存空間：元素在內(nèi)存中是連續(xù)存儲的
索引訪問：通過從0開始的整數(shù)索引訪問元素

1.2 一維數(shù)組

1.2.1 聲明與初始化

// 聲明數(shù)組
int[] arr1;          // 推薦方式
int arr2[];          // 效果相同，但不推薦
// 靜態(tài)初始化
int[] arr3 = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie"};
// 動態(tài)初始化
int[] arr4 = new int[5];  // 默認(rèn)初始化為0
boolean[] flags = new boolean[3]; // 默認(rèn)初始化為false
String[] strArr = new String[4]; // 默認(rèn)初始化為null

1.2.2 訪問與修改元素

int[] numbers = {10, 20, 30, 40, 50};
// 訪問元素
System.out.println(numbers[0]); // 輸出: 10
System.out.println(numbers[numbers.length - 1]); // 輸出最后一個元素: 50
// 修改元素
numbers[2] = 300;
System.out.println(numbers[2]); // 輸出: 300

1.2.3 數(shù)組遍歷

// 使用for循環(huán)
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Element at index " + i + ": " + numbers[i]);
}
// 使用增強for循環(huán)
for (int num : numbers) {
    System.out.println("Number: " + num);
}

1.3 二維數(shù)組

1.3.1 聲明與初始化

// 聲明二維數(shù)組
int[][] matrix1;
int matrix2[][];
// 靜態(tài)初始化
int[][] matrix3 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// 動態(tài)初始化
int[][] matrix4 = new int[3][4]; // 3行4列
int[][] matrix5 = new int[2][];  // 只指定行數(shù)，列數(shù)可后續(xù)指定
matrix5[0] = new int[3];
matrix5[1] = new int[5];

1.3.2 訪問與遍歷

// 訪問元素
System.out.println(matrix3[1][2]); // 輸出: 6 (第2行第3列)
// 遍歷二維數(shù)組
for (int i = 0; i < matrix3.length; i++) {
    for (int j = 0; j < matrix3[i].length; j++) {
        System.out.print(matrix3[i][j] + " ");
    }
    System.out.println();
}
// 使用增強for循環(huán)
for (int[] row : matrix3) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

1.4 三維數(shù)組及更高維數(shù)組

// 三維數(shù)組聲明與初始化
int[][][] cube = new int[2][3][4]; // 2個3x4的矩陣
// 靜態(tài)初始化
int[][][] cube2 = {
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    }
};
// 訪問三維數(shù)組元素
System.out.println(cube2[1][2][3]); // 輸出: 24
// 遍歷三維數(shù)組
for (int[][] matrix : cube2) {
    for (int[] row : matrix) {
        for (int num : row) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
    System.out.println("--- Next Matrix ---");
}

1.5 數(shù)組類(Arrays)

Java提供了java.util.Arrays類來操作數(shù)組。

1.5.1 常用方法

import java.util.Arrays;
int[] arr = {5, 2, 9, 1, 5, 6};
// 排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 5, 5, 6, 9]
// 二分查找(數(shù)組必須有序)
int index = Arrays.binarySearch(arr, 5);
System.out.println("5的索引: " + index); // 2或3(取決于第一個找到的5)
// 填充
Arrays.fill(arr, 0);
System.out.println(Arrays.toString(arr)); // [0, 0, 0, 0, 0, 0]
// 比較
int[] arr2 = {1, 2, 3};
int[] arr3 = {1, 2, 3};
System.out.println(Arrays.equals(arr2, arr3)); // true
// 復(fù)制數(shù)組
int[] arrCopy = Arrays.copyOf(arr2, arr2.length);
int[] arrCopyRange = Arrays.copyOfRange(arr2, 1, 3);

1.6 復(fù)制數(shù)組

1.6.1 系統(tǒng)復(fù)制方法

// 使用System.arraycopy()
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[5];
System.arraycopy(source, 0, destination, 0, source.length);
// 使用Arrays.copyOf()
int[] copy1 = Arrays.copyOf(source, source.length);
int[] copy2 = Arrays.copyOf(source, 3); // 只復(fù)制前3個元素
// 使用clone()
int[] clone = source.clone();

1.6.2 手動復(fù)制

int[] original = {10, 20, 30, 40, 50};
int[] manualCopy = new int[original.length];
for (int i = 0; i < original.length; i++) {
    manualCopy[i] = original[i];
}

二、Java集合框架

Java集合框架位于java.util包中，提供了多種數(shù)據(jù)結(jié)構(gòu)和算法。

2.1 集合框架概述

接口	實現(xiàn)類	特點
Collection	-	所有集合的根接口
List	ArrayList, LinkedList, Vector, Stack	有序，可重復(fù)
Set	HashSet, LinkedHashSet, TreeSet	無序，不可重復(fù)
Queue	PriorityQueue, ArrayDeque	隊列接口
Deque	ArrayDeque, LinkedList	雙端隊列
Map	HashMap, LinkedHashMap, TreeMap, Hashtable	鍵值對存儲

2.2 列表類(List)

2.2.1 ArrayList

import java.util.ArrayList;
import java.util.List;
// 創(chuàng)建ArrayList
List<String> names = new ArrayList<>();
// 添加元素
names.add("Alice");
names.add("Bob");
names.add(1, "Charlie"); // 在索引1處插入
// 訪問元素
System.out.println(names.get(0)); // Alice
// 遍歷
for (String name : names) {
    System.out.println(name);
}
// 刪除元素
names.remove(0); // 按索引刪除
names.remove("Bob"); // 按對象刪除
// 大小
System.out.println("Size: " + names.size());
// 檢查包含
System.out.println(names.contains("Charlie"));

2.2.2 LinkedList

import java.util.LinkedList;
LinkedList<Integer> numbers = new LinkedList<>();
// 添加元素
numbers.add(10);
numbers.addFirst(5); // 添加到頭部
numbers.addLast(15); // 添加到尾部
// 獲取元素
System.out.println("First: " + numbers.getFirst());
System.out.println("Last: " + numbers.getLast());
// 刪除元素
numbers.removeFirst();
numbers.removeLast();
// 轉(zhuǎn)換為數(shù)組
Integer[] arr = numbers.toArray(new Integer[0]);

2.3 集合類(Set)

2.3.1 HashSet

import java.util.HashSet;
import java.util.Set;
Set<String> uniqueNames = new HashSet<>();
// 添加元素
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice"); // 重復(fù)元素不會被添加
// 遍歷
for (String name : uniqueNames) {
    System.out.println(name);
}
// 檢查是否存在
System.out.println(uniqueNames.contains("Bob"));
// 刪除元素
uniqueNames.remove("Alice");

2.3.2 TreeSet

import java.util.TreeSet;
TreeSet<Integer> sortedNumbers = new TreeSet<>();
// 添加元素(自動排序)
sortedNumbers.add(5);
sortedNumbers.add(2);
sortedNumbers.add(8);
sortedNumbers.add(1);
// 遍歷(有序)
for (int num : sortedNumbers) {
    System.out.println(num); // 輸出: 1, 2, 5, 8
}
// 獲取子集
System.out.println(sortedNumbers.subSet(2, 6)); // [2, 5]

2.4 映射類(Map)

2.4.1 HashMap

import java.util.HashMap;
import java.util.Map;
Map<String, Integer> ageMap = new HashMap<>();
// 添加鍵值對
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
ageMap.put("Charlie", 25);
// 獲取值
System.out.println(ageMap.get("Alice")); // 25
// 遍歷
for (Map.Entry<String, Integer> entry : ageMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 檢查鍵是否存在
System.out.println(ageMap.containsKey("Bob"));
// 檢查值是否存在
System.out.println(ageMap.containsValue(30));
// 刪除條目
ageMap.remove("Charlie");

2.4.2 TreeMap

import java.util.TreeMap;
TreeMap<Integer, String> rankMap = new TreeMap<>();
// 添加鍵值對(按鍵排序)
rankMap.put(3, "Bronze");
rankMap.put(1, "Gold");
rankMap.put(2, "Silver");
// 遍歷(按鍵有序)
for (Map.Entry<Integer, String> entry : rankMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 獲取子映射
System.out.println(rankMap.subMap(1, 3)); // {1=Gold, 2=Silver}

2.5 隊列類(Queue)

2.5.1 PriorityQueue

import java.util.PriorityQueue;
import java.util.Queue;
Queue<String> priorityQueue = new PriorityQueue<>();
// 添加元素(按自然順序排序)
priorityQueue.add("Orange");
priorityQueue.add("Apple");
priorityQueue.add("Banana");
// 查看但不移除頭部
System.out.println(priorityQueue.peek()); // Apple
// 移除并返回頭部
System.out.println(priorityQueue.poll()); // Apple
System.out.println(priorityQueue.poll()); // Banana

2.5.2 ArrayDeque

import java.util.ArrayDeque;
import java.util.Deque;
Deque<Integer> deque = new ArrayDeque<>();
// 添加元素
deque.addFirst(1); // 添加到頭部
deque.addLast(3);  // 添加到尾部
deque.offerFirst(0); // 另一種添加到頭部的方式
deque.offerLast(4);  // 另一種添加到尾部的方式
// 查看元素
System.out.println(deque.peekFirst()); // 0
System.out.println(deque.peekLast());  // 4
// 移除元素
System.out.println(deque.pollFirst()); // 0
System.out.println(deque.pollLast());  // 4

2.6 堆棧類(Stack)

雖然Java有Stack類，但推薦使用Deque接口的實現(xiàn)類作為堆棧。

import java.util.ArrayDeque;
import java.util.Deque;
Deque<Integer> stack = new ArrayDeque<>();
// 壓棧
stack.push(10);
stack.push(20);
stack.push(30);
// 查看棧頂
System.out.println(stack.peek()); // 30
// 彈棧
System.out.println(stack.pop()); // 30
System.out.println(stack.pop()); // 20

2.7 集合工具類(Collections)

java.util.Collections提供了許多有用的集合操作方法。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
// 排序
Collections.sort(numbers);
System.out.println(numbers); // [1, 2, 5, 8]
// 反轉(zhuǎn)
Collections.reverse(numbers);
System.out.println(numbers); // [8, 5, 2, 1]
// 洗牌(隨機排序)
Collections.shuffle(numbers);
System.out.println(numbers);
// 最大值/最小值
System.out.println("Max: " + Collections.max(numbers));
System.out.println("Min: " + Collections.min(numbers));
// 不可變集合
List<Integer> immutableList = Collections.unmodifiableList(numbers);
// immutableList.add(10); // 拋出UnsupportedOperationException

三、完整案例代碼

3.1 數(shù)組操作完整示例

import java.util.Arrays;
public class ArrayDemo {
    public static void main(String[] args) {
        // 一維數(shù)組示例
        int[] oneDArray = {5, 2, 9, 1, 5, 6};
        System.out.println("原始數(shù)組: " + Arrays.toString(oneDArray));
        Arrays.sort(oneDArray);
        System.out.println("排序后: " + Arrays.toString(oneDArray));
        int index = Arrays.binarySearch(oneDArray, 5);
        System.out.println("5的索引: " + index);
        // 二維數(shù)組示例
        int[][] twoDArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("\n二維數(shù)組:");
        for (int[] row : twoDArray) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
        // 數(shù)組復(fù)制示例
        int[] copy = Arrays.copyOf(oneDArray, oneDArray.length);
        System.out.println("\n數(shù)組復(fù)制: " + Arrays.toString(copy));
        // 手動復(fù)制
        int[] manualCopy = new int[oneDArray.length];
        for (int i = 0; i < oneDArray.length; i++) {
            manualCopy[i] = oneDArray[i];
        }
        System.out.println("手動復(fù)制: " + Arrays.toString(manualCopy));
    }
}

3.2 集合操作完整示例

import java.util.*;
public class CollectionDemo {
    public static void main(String[] args) {
        // List示例 - ArrayList
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add(1, "David"); // 在索引1處插入
        System.out.println("ArrayList內(nèi)容:");
        for (String name : names) {
            System.out.println(name);
        }
        // List示例 - LinkedList
        LinkedList<Integer> numbers = new LinkedList<>();
        numbers.add(10);
        numbers.addFirst(5);
        numbers.addLast(15);
        System.out.println("\nLinkedList內(nèi)容:");
        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        // Set示例 - HashSet
        Set<String> uniqueNames = new HashSet<>();
        uniqueNames.add("Alice");
        uniqueNames.add("Bob");
        uniqueNames.add("Alice"); // 重復(fù)元素
        System.out.println("\nHashSet內(nèi)容(去重):");
        for (String name : uniqueNames) {
            System.out.println(name);
        }
        // Set示例 - TreeSet
        TreeSet<Integer> sortedNumbers = new TreeSet<>();
        sortedNumbers.add(5);
        sortedNumbers.add(2);
        sortedNumbers.add(8);
        sortedNumbers.add(1);
        System.out.println("\nTreeSet內(nèi)容(排序):");
        for (int num : sortedNumbers) {
            System.out.println(num);
        }
        // Map示例 - HashMap
        Map<String, Integer> ageMap = new HashMap<>();
        ageMap.put("Alice", 25);
        ageMap.put("Bob", 30);
        ageMap.put("Charlie", 25);
        System.out.println("\nHashMap內(nèi)容:");
        for (Map.Entry<String, Integer> entry : ageMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        // Map示例 - TreeMap
        TreeMap<Integer, String> rankMap = new TreeMap<>();
        rankMap.put(3, "Bronze");
        rankMap.put(1, "Gold");
        rankMap.put(2, "Silver");
        System.out.println("\nTreeMap內(nèi)容(按鍵排序):");
        for (Map.Entry<Integer, String> entry : rankMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        // Queue示例 - PriorityQueue
        Queue<String> priorityQueue = new PriorityQueue<>();
        priorityQueue.add("Orange");
        priorityQueue.add("Apple");
        priorityQueue.add("Banana");
        System.out.println("\nPriorityQueue內(nèi)容(按字母順序):");
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
        // 堆棧示例 - 使用Deque
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        System.out.println("\n堆棧內(nèi)容(LIFO):");
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
        // Collections工具類示例
        List<Integer> nums = new ArrayList<>();
        nums.add(5);
        nums.add(2);
        nums.add(8);
        nums.add(1);
        Collections.sort(nums);
        System.out.println("\n排序后的列表: " + nums);
        Collections.reverse(nums);
        System.out.println("反轉(zhuǎn)后的列表: " + nums);
        System.out.println("最大值: " + Collections.max(nums));
        System.out.println("最小值: " + Collections.min(nums));
    }
}

四、數(shù)組與集合使用對比

以下是數(shù)組和集合的使用場景、優(yōu)勢劣勢及代碼示例的完整表格：

數(shù)據(jù)結(jié)構(gòu)	使用場景	優(yōu)勢	劣勢	代碼示例
數(shù)組	1. 數(shù)據(jù)量固定且已知（如月份天數(shù)、配置參數(shù)） 2. 需要高效隨機訪問（如圖像處理像素數(shù)組） 3. 存儲基本數(shù)據(jù)類型（如`int[]`、`char[]`）	1. 內(nèi)存連續(xù)，訪問效率高（時間復(fù)雜度O(1)） 2. 無額外開銷，內(nèi)存占用少 3. 直接支持基本類型，無需裝箱/拆箱	1. 長度固定，無法動態(tài)擴展 2. 功能有限，缺乏排序、搜索等高級方法 3. 類型單一，所有元素必須相同類型	`java // 聲明并初始化整型數(shù)組 int[] numbers = {10, 20, 30}; // 訪問元素 int first = numbers[0]; // 輸出: 10 // 遍歷數(shù)組 for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); }`
集合（List）	1. 數(shù)據(jù)量動態(tài)變化（如用戶列表、日志記錄） 2. 需要頻繁插入/刪除元素（如任務(wù)隊列） 3. 存儲對象類型（如`String`、自定義類）	1. 動態(tài)擴容，無需預(yù)先指定大小 2. 功能豐富，提供`add()`、`remove()`、`sort()`等方法 3. 類型靈活，支持泛型（可存儲不同類型對象）	1. 內(nèi)存不連續(xù)，訪問效率略低（如`LinkedList`需遍歷） 2. 額外開銷，需存儲元數(shù)據(jù)（如容量、負(fù)載因子） 3. 僅支持對象，基本類型需自動裝箱（如`Integer`）	`java // 創(chuàng)建ArrayList并添加元素 List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); // 訪問元素 String firstName = names.get(0); // 輸出: Alice // 遍歷集合 for (String name : names) { System.out.println(name); } // 刪除元素 names.remove("Bob");`
集合（Set）	1. 需要去重（如標(biāo)簽系統(tǒng)、唯一ID集合） 2. 快速判斷元素是否存在（如黑名單過濾）	1. 自動去重，無需手動檢查 2. 查找效率高（如`HashSet`基于哈希表實現(xiàn)）	1. 無序存儲，無法通過索引訪問 2. 功能受限，不支持`get(index)`等操作	`java // 創(chuàng)建HashSet并添加元素 Set<String> tags = new HashSet<>(); tags.add("Java"); tags.add("Python"); tags.add("Java"); // 自動去重，集合大小為2 // 判斷元素是否存在 boolean hasJava = tags.contains("Java"); // 輸出: true`
集合（Map）	1. 鍵值對存儲（如字典、緩存系統(tǒng)） 2. 需要快速通過鍵查找值（如數(shù)據(jù)庫索引）	1. 高效查找（如`HashMap`時間復(fù)雜度O(1)） 2. 結(jié)構(gòu)靈活，支持自定義鍵類型	1. 鍵唯一，重復(fù)鍵會覆蓋值 2. 無序存儲（除非使用`TreeMap`）	`java // 創(chuàng)建HashMap并添加鍵值對 Map<String, Integer> scores = new HashMap<>(); scores.put("Alice", 90); scores.put("Bob", 85); // 通過鍵獲取值 int aliceScore = scores.get("Alice"); // 輸出: 90 // 遍歷鍵值對 for (Map.Entry<String, Integer> entry : scores.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); }`

總結(jié)

通過本文的學(xué)習(xí)，我們掌握了Java中數(shù)組和集合的基本用法：

數(shù)組：
- 固定大小，類型相同，連續(xù)內(nèi)存
- 支持一維、二維及更高維度
- 使用Arrays類進(jìn)行排序、搜索、復(fù)制等操作
集合框架：
- List：有序可重復(fù)，常用實現(xiàn)有ArrayList和LinkedList
- Set：無序不可重復(fù)，常用實現(xiàn)有HashSet和TreeSet
- Map：鍵值對存儲，常用實現(xiàn)有HashMap和TreeMap
- Queue/Deque：隊列和雙端隊列接口
- 使用Collections工具類進(jìn)行排序、反轉(zhuǎn)等操作

數(shù)組和集合各有優(yōu)缺點：

數(shù)組簡單高效，但大小固定
集合大小可變，提供更多功能，但稍有性能開銷

在實際開發(fā)中，應(yīng)根據(jù)具體需求選擇合適的數(shù)據(jù)結(jié)構(gòu)。對于固定大小的數(shù)據(jù)，數(shù)組是更好的選擇；對于需要動態(tài)增刪的數(shù)據(jù)，集合更為合適。

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

您可能感興趣的文章:

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