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

2025-07-08 18:50
文章标签 java 数组 详解 用法 基本 集合

本文主要是介绍Java中的数组与集合基本用法详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Java中的数组与集合基本用法详解》本文介绍了Java数组和集合框架的基础知识,数组部分涵盖了一维、二维及多维数组的声明、初始化、访问与遍历方法,以及Arrays类的常用操作,对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},
     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<>();
China编程// 添加键值对(按键排序)
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.chinasem.cnh(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数组与集合内容请搜索编程China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持China编程(www.chinasem.cn)！

这篇关于Java中的数组与集合基本用法详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155329。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
MySQL数据库双机热备的配置方法详解

MySQL数据库双机热备的配置方法详解

《MySQL数据库双机热备的配置方法详解》在企业级应用中,数据库的高可用性和数据的安全性是至关重要的,MySQL作为最流行的开源关系型数据库管理系统之一,提供了多种方式来实现高可用性,其中双机热备（M... 目录1. 环境准备1.1 安装mysql1.2 配置MySQL1.2.1 主服务器配置1.2.2 从
阅读更多...
C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
Linux kill正在执行的后台任务 kill进程组使用详解

Linux kill正在执行的后台任务 kill进程组使用详解

《Linuxkill正在执行的后台任务kill进程组使用详解》文章介绍了两个脚本的功能和区别,以及执行这些脚本时遇到的进程管理问题,通过查看进程树、使用`kill`命令和`lsof`命令,分析了子... 目录零. 用到的命令一. 待执行的脚本二. 执行含子进程的脚本，并kill2.1 进程查看2.2 遇到的
阅读更多...
MyBatis常用XML语法详解

MyBatis常用XML语法详解

《MyBatis常用XML语法详解》文章介绍了MyBatis常用XML语法,包括结果映射、查询语句、插入语句、更新语句、删除语句、动态SQL标签以及ehcache.xml文件的使用,感兴趣的朋友跟随小... 目录1、定义结果映射2、查询语句3、插入语句4、更新语句5、删除语句6、动态 SQL 标签7、ehc
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
JDK21对虚拟线程的几种用法实践指南

JDK21对虚拟线程的几种用法实践指南

《JDK21对虚拟线程的几种用法实践指南》虚拟线程是Java中的一种轻量级线程,由JVM管理,特别适合于I/O密集型任务,：本文主要介绍JDK21对虚拟线程的几种用法,文中通过代码介绍的非常详细,... 目录一、参考官方文档二、什么是虚拟线程三、几种用法1、Thread.ofVirtual().start(
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2