首页 > 软件编程 > java > Java ArrayList与顺序表

Java中ArrayList与顺序表示例详解

2025-12-04 11:14:12 作者：Dylan的码园

顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构,这篇文章主要介绍了Java中ArrayList与顺序表的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下

前言

这篇文章来和大家分享一下java集合框架与最基础的ArrayList的使用.老话说,读书百遍其义自见.这是我第二次学习一些新的心得与理解.我将从java集合框架到顺序表再到官方的arraylist进行分享~

一、java集合框架

Java 集合框架是 Java 中用于存储和操作一组对象的体系，核心分为 Collection（单列集合）和Map（双列集合）

核心接口与分类

Collection（单列集合）
- 是所有单列集合的根接口，定义了集合的基本操作（增删改查、遍历等）。
- 子接口：List（有序可重复）、Set（无序不可重复）、Queue（队列）。
Map（双列集合）
- 存储键值对（Key-Value），Key 唯一、Value 可重复。
- 子接口：SortedMap（键有序）。
有小伙伴说哎哎哎这都是啥?不用大家都记住,以后我会在数据结构这个合集和大家一点一点掰扯~ 咱们现在就只需要知道存储和操作数据的体系,我们在数据结构中学的一些结构与方法被java官方封装好啦,通过一些接口连接成了上面的集合结构.咱们今天就先看看ArrayList

ArrayList

ArrayList是 Java 集合框架中List接口的动态数组实现类
- 底层结构：基于动态数组（默认初始容量为 10，当元素满时自动扩容）。
- 有序性：元素按插入顺序存储，支持通过索引（get(int index)）快速访问。
- 可重复性：允许存储重复元素、null值。
- 线程不安全：多线程环境下操作会有并发问题（需手动加锁或用CopyOnWriteArrayList替代）。

我们接下来会详细介绍一下它~

二、顺序表

在数据结构中，顺序表是用连续的存储单元存储元素的线性表，而 Java 中的ArrayList就是顺序表的具体实现，下面从数据结构方面介绍：

数据结构中的顺序表

定义：用一段地址连续的存储单元（如数组）依次存储线性表的元素，元素的逻辑顺序与物理存储顺序一致。
核心特点：
- 支持随机访问：通过索引直接定位元素，时间复杂度O(1)。
- 存储连续：插入 / 删除中间元素时，需移动后续元素，时间复杂度O(n)。
- 容量固定（原生顺序表）：数组容量一旦确定无法动态调整（但ArrayList做了动态扩容优化）。

三、常用代码手动实现

这一部分的逻辑是较为简单的,小伙伴们如果是第一次接触,非常建议大家上手实现一下~
我就都分成一个一个小的代码块了大家在学习的时候也可以分成基本成员变量,成员方法,**辅助方法(在成员方法中被调用的小方法)**进行学习

基本方法

import java.util.Arrays;

public class MyArrayList implements IList{

    //基本成员方法

     public int [] element ;
     public int usedSide;
     public static final int DEFAULT_CAPACITY =10;

     public MyArrayList(){
        this.element = new int[DEFAULT_CAPACITY];
     }



    @Override
    public void add(int data) {
         //判断是不是满  -- 扩容后进行添加元素
        if (isFull()){
            grow();
        }
        this.element[this.usedSide] = data;
        usedSide++;

    }

    public boolean isFull(){
         return usedSide == this.element.length;
    }

    public void grow(){
        this.element = Arrays.copyOf(this.element,
                 2*element.length);
    }
    public void checkPosAdd(int pos,String mag) {
        if (pos < 0 || pos > usedSide) {
            throw new posIllegalityException(mag);
        }
    }

    @Override
    public void add(int pos, int data) {
         //判断满没有
        if (isFull()){
            grow();
        }
        // 下表是不是合法的
        checkPosAdd(pos,"pos位置不合法");
        //交换数据
        for (int i = usedSide-1;i >= pos;i--){
            element[i] = element[i+1];
        }
        element[pos] = data;
        usedSide++;
    }

    @Override
    public boolean contains(int toFind) {

         for (int i = 0 ;i < usedSide ; i ++){
             if (this.element[i] == toFind){
                 return true;
             }
         }
        return false;
    }

    @Override
    public int indexOf(int toFind) {
        for (int i = 0 ;i < usedSide ; i ++){
            if (this.element[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int get(int pos) {
         if (isEmpty()){
             throw new emptyIllegalityException
                     ("空列表异常");
         }
         checkPos(pos,"get方法的pos越界异常");
         return element[pos];
    }

    //检查越界异常
    public void checkPos(int pos,String mag){
         if (pos < 0 || pos >= usedSide){
             throw new posIllegalityException(mag); //调用异常
         }
    }


    public boolean isEmpty(){
         return this.usedSide == 0;
    }



    @Override
    public void set(int pos, int value) {
         checkPos(pos, "upset方法pos位置违法");
         //是不是空
        if(isEmpty()){
            throw new emptyIllegalityException("set方法空指针异常");
        }
         this.element[pos] = value;


    }


    @Override
    public void remove(int toRemove) {
         //判断是不是空
        if (isEmpty()){
            throw new emptyIllegalityException("空链表异常");
        }

        int pos = indexOf(toRemove);
        if (pos < 0){
            throw new posIllegalityException("删除位置异常");
        }
        //核心逻辑进行
        for (int i = pos; pos < usedSide-1 ;i++ ){
            //在进行add会将最后那个覆盖
            this.element[i] = element[i+1];
        }
        usedSide--;



    }

    @Override
    public int size() {
     //判断是不是空
        if(isEmpty()){
            throw new emptyIllegalityException("set方法空指针异常");
        }
        return this.usedSide;

    }

    @Override
    public void clear() {
         for (int i = 0;i < usedSide ;i++){
             this.element[i] = 0;
             //是引用类型是就要给到null
         }
         usedSide =0;
    }

    @Override
    public void display() {
         for (int i = 0 ; i < usedSide ;i++){
             System.out.println(element[i]+" ");
         }
        System.out.println();
    }
}

异常类

在上面会有一点异常的处理,在这两个类中啦,要是对异常不太清楚了,也可以看看我的计算机异常文章,可以对你有帮助~

public class posIllegalityException extends RuntimeException {
    //构造方法

    public posIllegalityException() {
    }

    public posIllegalityException(String message) {
        super(message);
    }
}

public class emptyIllegalityException extends RuntimeException {
    public emptyIllegalityException() {
    }

    public emptyIllegalityException(String message) {
        super(message);
    }
}

四、Arraylist使用

我们看一下java官方包中的方法

构造方法

官方提供了三个构造方法,分别是无参数,指定容量,给予已有集合的,我们一个一个看.

无参构造方法 ArrayList()

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

核心细节：
- 初始化时，底层数组elementData会被赋值为空数组. （DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个静态空数组常量）.
- 延迟初始化：第一次调用add()方法时，才会将数组扩容至默认初始容量 10.
- 目的：避免创建空 ArrayList 时占用不必要的内存（空数组仅占极小空间）。

指定初始容量的构造方法 ArrayList(int initialCapacity)

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // 另一个静态空数组常量
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

核心细节：
- 参数initialCapacity是期望的初始容量，需≥0。
- 分三种情况：
  - initialCapacity > 0：直接创建一个容量为initialCapacity的Object[]数组。
  - initialCapacity == 0:底层数组赋值为EMPTY_ELEMENTDATA（与无参构造的DEFAULTCAPACITY_EMPTY_ELEMENTDATA是不同的空数组常量，用于区分 “用户指定容量 0” 和 “默认空数组”）。
  -initialCapacity < 0：抛出IllegalArgumentException非法参数异常。
适用场景：已知集合大致大小，提前指定容量可避免后续多次扩容，提升性能。

基于已有的集合的构造方法ArrayList(Collection<? extends E> c)

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray()可能返回的不是Object[]类型（如某些自定义集合），需转换
        if (elementData.getClass() != Object[].class) {
            elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
    } else {
        // 集合c为空，赋值为空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

参数c是一个实现了Collection接口的集合（如LinkedList、HashSet等），用于初始化 ArrayList。

官方常用方法

需要注意的就是每个方法的返回类型+方法名+形参
一定要动手操作一下

五、Arraylist的遍历

直接打印

System.out.println(list);

for循环

 for(int i = 0; i <= list.size()-1; i++{
        Integer ii = list.get(i);
       System.out.print(" "+ ii);
 }

    for (int x :list){
            System.out.print(x + " ");
        }

迭代器

介绍

在 Java 集合框架中，迭代器（Iterator） 是用于遍历集合元素的统一接口，它提供了一种不依赖集合底层结构的遍历方式，核心作用是 “解耦集合与遍历逻辑”。

方法

接口位置：java.util.Iterator
核心方法：
- boolean hasNext()：判断是否还有下一个元素（无元素时返回false）。
- E next()：返回下一个元素（无元素时抛出NoSuchElementException）。

迭代器
     Iterator<Integer> it = list.iterator();
     while (it.hasNext()) {
          System.out.println(it.next()+ " ");
      }

        //迭代器
        ListIterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
//指定位置后开始
        ListIterator<Integer> it2 = list.listIterator(1);
        while (it2.hasNext()){
            System.out.print(it2.next()+ " ");
        }
        System.out.println();
//指定位置前开始
        ListIterator<Integer> it3 = list.listIterator(list.size());
        while (it3.hasPrevious()){   //返回值bool
            System.out.print(it3.previous()+ " ");
        }

总结

到这里我的分享就先结束了~,希望对你有帮助
我是dylan 下次见~
- 无限进步

到此这篇关于Java中ArrayList与顺序表示的文章就介绍到这了,更多相关Java ArrayList与顺序表内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！