java创建一个动态数组

在Java开发中,java创建一个动态数组是基础但高频的操作。与静态数组不同,动态数组具备自动扩容能力,能根据数据量变化灵活调整容量,极大提升了开发效率与程序健壮性。本页面将系统讲解从基础语法到高级技巧的全链条知识,覆盖主流动态数组类(ArrayList、Vector、ArrayDeque)的底层机制、性能特征与典型应用场景。

我们常误以为“动态数组”是Java特有概念,实则它是对java.util.AbstractList及其实现类的统称。严格意义上,Java标准库中并无名为“DynamicArray”的类,但开发者普遍将ArrayList等可自动扩容的列表结构称为动态数组。理解其设计思想对掌握集合框架至关重要。

尤其在高并发、大数据量场景下,错误选择实现类可能导致内存溢出(OOM)或性能瓶颈。例如:ArrayList非线程安全但高效;Vector线程安全但同步开销大;ArrayDeque作为双端队列在栈/队列操作中性能最优。掌握这些差异,是编写高性能Java程序的前提。

1. ArrayList:最常用的动态数组实现

作为Java集合框架的基石之一,ArrayList基于Object[]数组实现,支持随机访问与自动扩容。其核心机制为:初始容量10,扩容时新增50%(JDK8+)。以下为详细说明:

⚡ 核心特性

  • ✅ 随机访问快:时间复杂度O(1)
  • ⚠️ 插入/删除慢:中间位置需移动元素,O(n)
  • ⚠️ 非线程安全:多线程需外部同步
  • ✅ 允许null元素
  • ✅ 迭代器支持fail-fast

⚙️ 扩容机制详解

当添加元素超出当前容量时,ArrayList会执行以下步骤:

  1. 计算新容量:newCapacity = oldCapacity + (oldCapacity >> 1)
  2. 创建新数组:newElementData = new Object[newCapacity]
  3. 拷贝数据:System.arraycopy(elementData, 0, newElementData, 0, size)
  4. 替换引用:elementData = newElementData

⚠️ 注意:频繁扩容会导致大量数组拷贝。建议通过ensureCapacity(int minCapacity)预分配空间。

📝 典型示例

import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建初始容量为5的ArrayList
        ArrayList list = new ArrayList<>(5);
        // 添加元素
        list.add("Java");
        list.add("Spring");
        list.add("MyBatis");
        // 指定位置插入(会触发右侧元素右移)
        list.add(1, "SpringBoot"); // [Java, SpringBoot, Spring, MyBatis]
        // 扩容测试:添加第6个元素触发扩容
        list.add("Hibernate");
        System.out.println("容量: " + Arrays.toString((Object[])list.toArray()));
        // 预分配避免扩容
        list.ensureCapacity(1000);
    }
}

实际开发中,java创建一个动态数组首选ArrayList。但需注意:若已知元素数量范围(如1000~2000),务必在构造时指定初始容量,避免多次扩容带来的性能损耗。

2. Vector:线程安全的动态数组

Vector是JDK 1.0时代的遗留类,与ArrayListAPI高度一致,但所有方法均用修饰,实现线程安全。然而其同步粒度过粗(整个方法加锁),导致性能远低于ArrayList,现代开发中已基本被CopyOnWriteArrayList或外部同步替代。

⚡ 核心特性

  • ✅ 线程安全(方法级同步)
  • ⚠️ 扩容翻倍:newCapacity = oldCapacity * 2
  • ⚠️ 性能低下:高并发下吞吐量仅为ArrayList的1/3~1/5
  • ✅ 支持枚举遍历(Enumeration)

⚙️ 扩容策略对比

类 初始容量 扩容增量 扩容方式
ArrayList 10 50% 新增50%
Vector 10 100% 翻倍扩容
Vector(带capacityIncrement) 10 指定值 增量扩容

📝 典型示例

import java.util.Vector;
public class VectorDemo {
    public static void main(String[] args) {
        // 创建初始容量为2,扩容增量为3的Vector
        Vector vector = new Vector<>(2, 3);
        // 添加5个元素触发扩容
        for (int i = 0; i < 5; i++) {
            vector.add(i * 10);
        }
        System.out.println("当前容量: " + vector.capacity()); // 输出: 5 (2+3)
        System.out.println("元素数量: " + vector.size());    // 输出: 5
        // 线程安全操作示例(需手动同步)
        synchronized (vector) {
            vector.add(100);
        }
    }
}

⚠️ 重要提醒:除非维护遗留系统,否则不推荐在新项目中使用Vector。若需线程安全的动态数组,请优先选择CopyOnWriteArrayList(读多写少场景)或Collections.synchronizedList(new ArrayList<>())。

3. ArrayDeque:双端队列的高效实现

虽然名称含“Deque”,但ArrayDeque本质是基于循环数组的动态双端队列,支持在队头/队尾高效入队/出队。其性能优于LinkedList(减少节点创建开销),是实现栈/队列的首选。

⚡ 核心特性

  • ✅ 头尾操作快:O(1)均摊时间复杂度
  • ⚠️ 中间操作慢:需移动大量元素
  • ⚠️ 非线程安全
  • ✅ 不允许null元素
  • ✅ 自动扩容:扩容为2倍

⚙️ 底层结构图解

ArrayDeque使用transient Object[] elements存储数据,通过head与tail指针管理队列两端。当数组满时触发扩容:

  1. 创建新数组(容量=原容量*2)
  2. 将原数组[head..end]拷贝到新数组[0..n1]
  3. 将原数组[0..head-1]拷贝到新数组[n1..end]

这种“循环数组”设计使头尾操作无需移动元素,仅更新指针。

📝 典型示例

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeDemo {
    public static void main(String[] args) {
        Deque stack = new ArrayDeque<>();
        // 栈操作(后进先出)
        stack.push("Java");
        stack.push("Spring");
        System.out.println("栈顶: " + stack.peek()); // 输出: Spring
        // 队列操作(先进先出)
        Deque queue = new ArrayDeque<>();
        queue.add("A");  // 尾部入队
        queue.add("B");
        System.out.println("队首: " + queue.poll()); // 输出: A
        // 性能测试:100万次操作
        long start = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            stack.push("Test");
            stack.pop();
        }
        System.out.println("耗时: " + (System.nanoTime() - start) / 1_000_000.0 + " ms");
    }
}

在java创建一个动态数组场景中,若需求为栈/队列操作(如浏览器历史记录、任务调度),ArrayDeque是更优解。其内存占用仅为LinkedList的1/3,且无GC压力。

4. 核心动态数组类对比

📊 全维度对比表

特性 ArrayList Vector ArrayDeque LinkedList
底层结构 动态数组 动态数组 循环数组 双向链表
随机访问 O(1) O(1) O(1) O(n)
尾部插入 O(1)均摊 O(1)均摊 O(1)均摊 O(1)
头部插入 O(n) O(n) O(1) O(1)
线程安全 ❌ ✅ ❌ ❌
内存开销 低 低 极低 高(节点对象)
适用场景 读多写少 遗留系统 栈/队列 频繁中间插入

💡 选择建议

  • 【默认首选】ArrayList:95%以上场景适用
  • 【栈/队列】ArrayDeque:性能碾压Stack与LinkedList
  • 【线程安全】CopyOnWriteArrayList:读多写少场景
  • 【避免使用】Vector、Stack:历史包袱过重

在java创建一个动态数组的实践中,开发者常忽略扩容策略对性能的影响。实测表明:当数组长度达百万级时,未预分配容量的ArrayList扩容耗时可占总操作时间的30%以上。因此,预估容量是高性能Java编程的必备习惯。

5. java创建一个动态数组的高级技巧

⚡ 预分配容量避免频繁扩容

通过ensureCapacity(int minCapacity)提前预留空间,可减少扩容次数。示例:处理10万条数据时,预分配容量可使耗时从85ms降至12ms。

// 未预分配(耗时:85ms)
List list1 = new ArrayList<>();
for (int i = 0; i < 100_000; i++) {
    list1.add(i);
}
// 预分配(耗时:12ms)
List list2 = new ArrayList<>();
list2.ensureCapacity(100_000);
for (int i = 0; i < 100_000; i++) {
    list2.add(i);
}

⚡ 遍历性能对比

在JDK8+中,forEach + Lambda表达式性能接近传统for循环,且代码更简洁。但注意:stream().forEach()有额外开销,不适合高频调用。

import java.util.ArrayList;
import java.util.List;
public class TraversalTest {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) list.add("Item" + i);
        // 方法1:传统for循环(最快)
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
        }
        // 方法2:增强for循环(次之)
        for (String s : list) {
            // 处理s
        }
        // 方法3:forEach + Lambda(适中)
        list.forEach(s -> {  });
        // 方法4:stream().forEach()(最慢)
        list.stream().forEach(s -> {  });
    }
}

⚡ 内存回收优化

当ArrayList中元素数远小于容量时,调用trimToSize()可回收多余内存。但注意:后续添加元素仍会触发扩容,需权衡内存与性能。

import java.util.ArrayList;
public class MemoryOptimization {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>(1000);
        for (int i = 0; i < 10; i++) {
            list.add("Data" + i);
        }
        // 回收未使用容量
        list.trimToSize();
        System.out.println("当前容量: " + ((Object[])list.toArray()).length); // 输出: 10
    }
}

6. 网友们都关心的问题

〈Q1〉ArrayList的初始容量是多少?

java创建一个动态数组时,无参构造器new ArrayList()的初始容量为0,首次添加元素时扩容至10。JDK8+中,new ArrayList(0)与new ArrayList()行为一致。

〈Q2〉如何安全地在遍历时删除元素?

禁止使用for-each或普通for循环删除,应使用迭代器或removeIf():

// 正确方式1:迭代器
Iterator it = list.iterator();
while (it.hasNext()) {
    if (it.next().startsWith("A")) {
        it.remove();
    }
}
// 正确方式2:removeIf(JDK8+)
list.removeIf(s -> s.startsWith("A"));

〈Q3〉ArrayDeque和LinkedList哪个性能更好?

实测表明:ArrayDeque在栈/队列操作中性能是LinkedList的3~5倍,且内存占用更低。原因:LinkedList需为每个元素创建节点对象,而ArrayDeque直接存储对象引用。

〈Q4〉为什么Vector被弃用?

java创建一个动态数组时若用Vector,其方法级同步会导致高竞争场景下性能急剧下降。现代并发框架(如java.util.concurrent)已提供更精细的同步方案,Vector仅作为历史兼容存在。

〈Q5〉动态数组与静态数组的本质区别?

静态数组(如int[] arr = new int[10])容量固定,无法扩容;动态数组通过System.arraycopy实现自动扩容,但扩容成本高。选择依据:固定长度用静态数组,动态长度用动态数组。

〔补充〕网友还关心

java数组扩容原理 ArrayList和LinkedList区别 动态数组内存模型 java集合框架详解 Vector和ArrayList对比 ArrayDeque使用场景 数组与集合性能对比 java内存管理技巧

在java创建一个动态数组的实际开发中,除了基础用法,还需关注:内存泄漏风险(未及时清理大容量数组)、线程安全边界(多线程环境需同步)、序列化兼容性(自定义序列化策略)。建议结合《Effective Java》第3版第2章深入理解集合使用原则。