开发者

Java中的数组与集合基本用法详解

开发者 https://www.devze.com 2025-07-09 10:28 出处：网络 作者： JosieBook
目录一、Java数组基础1.1 数组结构概述1.2 一维数组1.2.1 声明与初始化1.2.2 访问与修改元素1.2.3 数组遍历1.3 二维数组1.3.1 声明与初始化1.3.2 访问与遍历1.4 三维数组及更高维数组1.5 数组类(Arrays)1.5.1 常用方
相关专题：java中数组与集合Java数组
目录
  • 一、Java数组基础
    • 1.1 数组结构概述
    • 1.2 一维数组
      • 1.2.1 声明与初始化
      • 1.2.2 访问与修改元素
      • 1.2.3 数组遍历
    • 1.3 二维数组
      • 1.3.1 声明与初始化
      • 1.3.2 访问与遍历
    • 1.4 三维数组及更高维数组
      • 1.5 数组类(Arrays)
        • 1.5.1 常用方法
      • 1.6 复制数组
        • 1.6.1 系统复制方法
        • 1.6.2 手动复制
    • 二、Java集合框架
      • 2.1 集合框架概述
        • 2.2 列表类(List)
          • 2.2.1 ArrayList
          • 2.2.2 LinkedList
        • 2.3 集合类(Set)
          • 2.3.1 HashSet
          • 2.3.2 TreeSet
        • 2.4 映射类(Map)
          • 2.4.1 HashMap
          • 2.4.2 TreeMap
        • 2.5 队列类(Queue)
          • 2.5.1 PriorityQueue
          • 2.5.2 ArrayDeque
        • 2.6 堆栈类(Stack)
          • 2.7 集合工具类(Collections)
          • 三、完整案例代码
            • 3.1 数组操作完整示例
              • 3.2 集合操作完整示例
              • 四、数组与集合使用对比
                • 总结

                  一、Java数组基础

                  1.1 数组结构概述

                  数组是Java中最基本的数据结构之一，用于存储相同类型的多个元素。数组具有以下特点：

                  • 固定大小：一旦创建，大小不可改变
                  • 连续内存空间：元素在内存中是连续存储的
                  • 索引访问：通过从0开始的整数索引访问元素

                  1.2 一维数组

                  1.2.1 声明与初始化

                  // 声明数组
int[] arr1;          // 推荐方式
int arr2[];          // 效果相同，但不推荐
// 静态初始化
int[] arr3 = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie"};
// 动态初始化
int[] arr4 = new int[5];  // 默认初始化为0
boolean[] flags = new boolean[3]; // 默认初始化为false
String[] strArr = new String[4]; // 默认初始化为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 数组遍历

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

                  1.3 二维数组

                  1.3.1 声明与初始化

                  // 声明二维数组
int[][] matrix1;
int matrix2[][];
// 静态初始化
int[][] matrix3 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// 动态初始化
int[][] matrix4 = new int[3][4]; // 3行4列
int[][] matrix5 = new int[2][];  // 只指定行数，列数可后续指定
matrix5[0] = new int[3];
matrix5[1] = new int[5];

                  1.3.2 访问与遍历

                  // 访问元素
System.out.println(matrix3[1][2]); // 输出: 6 (第2行第3列)
// 遍历二维数组
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循环
for (int[] row : matrix3) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

                  1.4 三维数组及更高维数组

                  // 三维数组声明与初始化
int[][][] cube = new int[2][3][4]; // 2个3x4的矩阵
// 静态初始化
int[][][] cube2 = {
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
     php   {21, 22, 23, 24}
    }
};
// 访问三维数组元素
System.out.println(cube2[1][2][3]); // 输出: 24
// 遍历三维数组
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 数组类(Arrays)

                  Java提供了java.util.Arrays类来操作数组。

                  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]
// 二分查找(数组必须有序)
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
// 复制数组
int[] arrCopy = Arrays.copyOf(arr2, arr2.length);
int[] arrCopyRange = Arrays.copyOfRange(arr2, 1, 3);

                  1.6 复制数组

                  1.6.1 系统复制方法

                  // 使用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); // 只复制前3个元素
// 使用clone()
int[] clone = source.clone();

                  1.6.2 手动复制

                  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包中，提供了多种数据结构和算法。

                  2.1 集合框架概述

                  接口实现类特点
                  Collection-所有集合的根接口
                  ListArrayList, LinkedList, Vector, Stack有序，可重复
                  SetHashSet, LinkedHashSet, TreeSet无序，不可重复
                  QueuePriorityQueue, ArrayDeque队列接口
                  DequeArrayDeque, LinkedList双端队列
                  MapHashMap, LinkedHashMap, TreeMap, Hashtable键值对存储

                  2.2 列表类(List)

                  2.2.1 ArrayList

                  import java.util.ArrayList;
import java.util.List;
// 创建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();
// 转换为数组
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"); // 重复元素不会被添加
// 遍历
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);  // 添加到尾部
dequMvnNRe.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接口的实现类作为堆栈。

                  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]
// 反转
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 数组操作完整示例

                  import java.util.Arrays;
public class ArrayDemo {
    public static void main(String[] args) {
        // 一维数组示例
        int[] oneDArray = {5, 2, 9, 1, 5, 6};
        System.out.println("原始数组: " + Arrays.toString(oneDArray));
        Arrays.sort(oneDArray);
        System.out.println("排序后: " + Arrays.toString(oneDArray));
        int index = Arrays.binarySearch(oneDArray, 5);
        System.out.println("5的索引: " + index);
        // 二维数组示例
        int[][] twoDArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("\n二维数组:");
        for (int[] row : twoDArray) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
        // 数组复制示例
        int[] copy = Arrays.copyOf(oneDArray, oneDArray.length);
        System.out.println("\n数组复制: " + Arrays.toString(copy));
        // 手动复制
        int[] manualCopy = new int[oneDArray.length];
        for (int i = 0; i < oneDArray.length; i++) {
            manualCopy[i] = oneDArray[i];
        }
        System.out.println("手动复制: " + 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内容:");
        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内容:");
        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"); // 重复元素
        System.out.println("\nHashSet内容(去重):");
        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内容(排序):");
        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内容:");
        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内容(按键排序):");
        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内容(按字母顺序):");
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
        // 堆栈示例 - 使用Deque
        Deque<Integer> stack = new ArrayDeque<>();
        stack.pushttp://www.devze.comh(10);
        stack.push(20);
        stack.push(30);
        System.out.println("\n堆栈内容(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("反转后的列表: " + nums);
        System.out.println("最大值: " + Collections.max(nums));
        System.out.println("最小值: " + Collections.min(nums));
    }
}

                  四、数组与集合使用对比

                  以下是数组和集合的使用场景、优势劣势及代码示例的完整表格：

                  数据结构使用场景优势劣势代码示例
                  数组1. 数据量固定且已知（如月份天数、配置参数）

                  2. 需要高效随机访问（如图像处理像素数组）

                  3. 存储基本数据类型（如int[]、char[]）

                  		1. 内存连续，访问效率高（时间复杂度O(1)）

                  2. 无额外开销，内存占用少

                  3. 直接支持基本类型，无需装箱/拆箱

                  		1. 长度固定，无法动态扩展

                  2. 功能有限，缺乏排序、搜索等高级方法

                  3. 类型单一，所有元素必须相同类型

                  		java // 声明并初始化整型数组 int[] numbers = {10, 20, 30}; // 访问元素 int first = numbers[0]; // 输出: 10 // 遍历数组 for (int i = 0; pythoni < numbers.length; i++) { System.out.println(numbers[i]); }
                  集合（List）1. 数据量动态变化（如用户列表、日志记录）

                  2. 需要频繁插入/删除元素（如任务队列）

                  3. 存储对象类型（如String、自定义类）

                  		1. 动态扩容，无需预先指定大小

                  2. 功能丰富，提供add()、remove()、sort()等方法

                  3. 类型灵活，支持泛型（可存储不同类型对象）

                  		1. 内存不连续，访问效率略低（如LinkedList需遍历）

                  2. 额外开销，需存储元数据（如容量、负载因子）

                  3. 仅支持对象，基本类型需自动装箱（如Integer）

                  		java // 创建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. 需要去重（如标签系统、唯一ID集合）

                  2. 快速判断元素是否存在（如黑名单过滤）

                  		1. 自动去重，无需手动检查

                  2. 查找效率高（如HashSet基于哈希表实现）

                  		1. 无序存储，无法通过索引访问

                  2. 功能受限，不支持get(index)等操作

                  		java // 创建HashSet并添加元素 Set<String> tags = new HashSet<>(); tags.add("Java"); tags.add("python"); tags.add("Java"); // 自动去重，集合大小为2 // 判断元素是否存在 boolean hasJava = tags.contains("Java"); // 输出: true
                  集合（Map）1. 键值对存储（如字典、缓存系统）

                  2. 需要快速通过键查找值（如数据库索引）

                  		1. 高效查找（如HashMap时间复杂度O(1)）

                  2. 结构灵活，支持自定义键类型

                  		1. 键唯一，重复键会覆盖值

                  2. 无序存储（除非使用TreeMap）

                  		java // 创建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()); }

                  总结

                  通过本文的学习，我们掌握了Java中数组和集合的基本用法：

                  1. 数组：

                    • 固定大小，类型相同，连续内存
                    • 支持一维、二维及更高维度
                    • 使用Arrays类进行排序、搜索、复制等操作

                  2. 集合框架：

                    • List：有序可重复，常用实现有ArrayList和LinkedList
                    • Set：无序不可重复，常用实现有HashSet和TreeSet
                    • Map：键值对存储，常用实现有HashMap和TreeMap
                    • Queue/Deque：队列和双端队列接口
                    • 使用Collections工具类进行排序、反转等操作

                  数组和集合各有优缺点：

                  • 数组简单高效，但大小固定
                  • 集合大小可变，提供更多功能，但稍有性能开销

                  在实际开发中，应根据具体需求选择合适的数据结构。对于固定大小的数据，数组是更好的选择；对于需要动态增删的数据，集合更为合适。

                  到此这篇关于Java中的数组与集合的文章就介绍到这了,更多相关Java数组与集合内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

                  0

                  上一篇:

                  :下一篇

                  更多 开发 相关资讯：

                  精彩评论

                  暂无评论...
                  登录 注册
                  Qedev.com
                  验证码 换一张
                  取 消

                  关注公众号

                  热门标签

                  图文推荐

                  使用gopacket解析协议层中的相关数据方式

                  使用gopacket解析协议层中的相关数据方式
                  Qt使用QSqlDatabase连接MySQL实现增删改查功能

                  Qt使用QSqlDatabase连接MySQL实现增删改查功能
                  C++ Log4cpp跨平台日志库的使用小结

                  C++ Log4cpp跨平台日志库的使用小结
                  C++任意进制转换的代码实现与优化技巧

                  C++任意进制转换的代码实现与优化技巧
                  C#下如何实现Server-Sent Event(SSE)

                  C#下如何实现Server-Sent Event(SSE)
                  基于WPF自定义分页控件的示例代码

                  基于WPF自定义分页控件的示例代码
                  Java常用加密算法详解与示例代码

                  Java常用加密算法详解与示例代码
                  Java实现读取Excel数据并写入到Word

                  Java实现读取Excel数据并写入到Word

                  开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

                  法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

                  Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9