JAVA中ArrayList与顺序表举例详解_Java

前言

在 java 的集合框架中，arraylist 是最常用的数据结构之一，它以动态数组为底层实现，提供了灵活的元素存取与自动扩容机制。而在数据结构课程中，顺序表（sequential list）作为线性表的一种典型实现，同样以数组为存储基础。两者在原理上有诸多相似之处，但在实现策略、内存管理、扩容机制以及时间复杂度控制等方面却各有差异。本文将从底层原理出发，深入分析 arraylist 的实现细节，并将其与顺序表进行对比，以帮助读者更好地理解二者的联系与区别，从而在实际开发与算法设计中更合理地选择合适的数据结构。

一、什么是线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

二、顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。(即逻辑上连续，物理上也连续的数据结构)

2.1 顺序表接口的实现

2.2 arraylist简介

在集合框架中，arraylist是一个普通的类，实现了list接口，具体框架图如下：

总结：

arraylist是以泛型方式实现的，使用时必须要先实例化
arraylist实现了randomaccess接口，表明arraylist支持随机访问
arraylist实现了cloneable接口，表明arraylist是可以clone的
arraylist实现了serializable接口，表明arraylist是支持序列化的
和vector不同，arraylist不是线程安全的，在单线程下可以使用，在多线程中可以选择vector或者copyonwritearraylist
arraylist底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.3 arraylist的构造

package demo2;

import java.util.arraylist;

public class test {
    public static void main(string[] args) {
        arraylist<integer> list = new arraylist<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        system.out.println(list);
        arraylist<integer> list2 = new arraylist<>(list);
        list2.set(2,50);
        system.out.println(list2);
        arraylist<string> list3 = new arraylist<>(2);
        list3.add("hhh");
        list3.add("ddd");
        list3.add("aaa");
        system.out.println(list3);

    }
}

2.4 arraylist常见操作

arraylist虽然提供的方法比较多，但是常用方法如下所示，需要用到其他方法时，同学们自行查看arraylist的帮助文档。

package demo3;

import demo1.myarraylist;

import java.util.arraylist;
import java.util.list;

public class test {
    public static void main(string[] args) {
        arraylist<string> list = new arraylist<>();
        arraylist<string> list2 = new arraylist<>(list);
        list2.add("hhh");
        list2.add("hhh");
        list2.add("hhh");
        list.add("dzj");
        list.add("hzp");
        list.add("xrx");
        list.add("xx");
        list.add("lyy");
        list.add("lwm");
        list.add(1,"sb");
        system.out.println(list);
        list.addall(4,list2);
        system.out.println(list);

        list.remove(1);
        system.out.println(list);

        system.out.println(list.get(6));
        list.set(6,"xxx");
        system.out.println(list);
        list.clear();
        system.out.println(list);
        list.addall(list2);
        system.out.println(list);
        system.out.println(list.contains("hh"));

        system.out.println(list.indexof("hhh"));
        system.out.println(list.lastindexof("hhh"));

        list.addall(list2);
        list.addall(list2);
        list.addall(list2);
        system.out.println(list);

        list.clear();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        system.out.println(list);
        list<string> sub=list.sublist(1,4);
        sub.set(0,"dzj");
        system.out.println(list);
        system.out.println(sub);

        list<string> newlist=new arraylist<>(list.sublist(1,4));
        system.out.println(newlist);
    }
}

其中对于sublist方法有一个小坑，请看如下代码：

			  list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        system.out.println(list);
        list<string> sub=list.sublist(1,4);
        sub.set(0,"dzj");
        system.out.println(list);
        system.out.println(sub);

也就是说sub和原来的list实际上用的是同一块空间，这和我们的正常认知有所不同，所以这通常是一种不安全的方式，请安全保险的方式如下：

list<string> newlist=new arraylist<>(list.sublist(1,4));
        system.out.println(newlist);

2.5 arraylist的遍历方式

arraylist 可以使用三方式遍历：for循环+下标、foreach、使用迭代器

package demo4;

import java.util.arraylist;
import java.util.iterator;

public class test {
    public static void main(string[] args) {
        arraylist<integer> list = new arraylist<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        for (int i = 0; i < list.size(); i++) {
            system.out.print(list.get(i)+" ");
        }
        system.out.println();
        for (integer x : list) {
            system.out.print(x+" ");
        }
        system.out.println();
        iterator<integer> it = list.iterator();
        while(it.hasnext()){
            system.out.print(it.next()+" ");
        }

    }
}

2.6 arraylist的扩容机制

关于这一点只需要了解以下内容即可。
无参创建的 arraylist 初始并不开辟实际存储空间，只有在第一次添加元素时才分配默认容量（10个），后续扩容为1.5倍扩容。

具体的实现细节可以参照其源码，这一点大家自己感兴趣的可以自行查阅。

2.7 arraylist的应用

2.7.1 杨辉三角

杨辉三角

class solution {
    public list<list<integer>> generate(int numrows) {
        list<list<integer>> list=new arraylist<>();
        for (int i = 0; i < numrows; i++) {
            list.add(new arraylist<>());
        }
        for (int i = 0; i < numrows; i++) {
            for (int j = 0; j <=i; j++) {
                if(j==0||j==i){
                    list.get(i).add(1);
                }else{
                    int x = list.get(i-1).get(j);
                    int y = list.get(i-1).get(j-1);
                    list.get(i).add(x+y);
                }
            }
        }
        return list;
    }

}

2.7.2 简单的洗牌算法

package demo5;

public class card {
    int rank;
    string suit;

    public card(int rank, string suit){
        this.rank=rank;
        this.suit=suit;
    }

    @override
    public string tostring() {
        return "{" +
                 rank +
                ", " + suit + '\'' +
                '}';
    }
}

package demo5;

import java.util.arraylist;
import java.util.list;
import java.util.random;

public class carddemo {
    public static final string[] suits={"♠", "♥", "♣", "♦"};
    list<card> deck = new arraylist<>(52);
    public void createdeck(){
        for (int i = 0; i < suits.length; i++) {
            for (int j = 0; j < 13; j++) {
                card card = new card(j+1, suits[i]);
                deck.add(card);
            }
        }
    }

    public void swapcards(int i,int j){
        card temp = deck.get(i);
        deck.set(i, deck.get(j));
        deck.set(j, temp);
    }
    public  void shuffledeck(){
        random random=new random();
        int count = 1;
        for (int i = deck.size()-1; i >0 ;i--) {
            int j = random.nextint(deck.size()-count);
            swapcards(i,j);
            count++;
        }
    }
}

package demo5;

import java.util.arraylist;
import java.util.list;

public class test {
    public static void main(string[] args) {
        carddemo carddemo=new carddemo();
        carddemo.createdeck();
        system.out.println(carddemo.deck);
        carddemo.shuffledeck();
        system.out.println(carddemo.deck);


        list<list<card>> persons=new arraylist<>();
        persons.add(new arraylist<>());
        persons.add(new arraylist<>());
        persons.add(new arraylist<>());

        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < persons.size(); j++) {
                persons.get(j).add(carddemo.deck.get(i));
                carddemo.deck.remove(i);
            }
        }

        for(list<card> person:persons){
            system.out.println(person);
        }
        system.out.println(carddemo.deck);
    }
}

2.8 小结

1. arraylist底层使用连续的空间，任意位置插入或删除元素时，需要将该位置后序元素整体往前或者往后搬移，故时间复杂度为o(n)

2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

总结

通过对比可以发现，顺序表是理论基础，而 arraylist 是工程化实现。顺序表强调抽象数据类型的逻辑结构和基本操作原理，而 arraylist 则在此基础上进行了面向对象与动态内存管理的优化，具备更高的灵活性与可扩展性。理解 arraylist 的底层机制不仅有助于掌握其性能特征（如时间复杂度与扩容策略），也能加深对数组式线性存储结构的理解。无论是数据结构学习者还是 java 开发者，深入理解二者的内在联系，都能在实际编程中写出更高效、更稳定的代码。

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