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

一、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},
        {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	-	所有集合的根接口
list	arraylist, linkedlist, vector, stack	有序，可重复
set	hashset, linkedhashset, treeset	无序，不可重复
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;
// 创建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);  // 添加到尾部
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接口的实现类作为堆栈。

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.push(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; i < 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中数组和集合的基本用法：

数组：
- 固定大小，类型相同，连续内存
- 支持一维、二维及更高维度
- 使用arrays类进行排序、搜索、复制等操作
集合框架：
- list：有序可重复，常用实现有arraylist和linkedlist
- set：无序不可重复，常用实现有hashset和treeset
- map：键值对存储，常用实现有hashmap和treemap
- queue/deque：队列和双端队列接口
- 使用collections工具类进行排序、反转等操作

数组和集合各有优缺点：

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

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

到此这篇关于java中的数组与集合的文章就介绍到这了,更多相关java数组与集合内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！


验证码：

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

2025年07月08日 • Java •我要评论