JAVA-顺序表ArrayList(实现ArrayList)

已于 2025-01-06 17:16:41 修改
阅读量1.1k 收藏 30
点赞数 11
文章标签： java 开发语言
于 2024-11-10 23:33:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Lizhihao_/article/details/143645953
版权

1.线性表

线性表 （ linear list ） 是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构(从内存看来)并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

1.1 什么是List

在集合框架中，List是一个接口，继承自Collection。

Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：

Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：

站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删 改查以及变量等操作。

1.2 List常用方法

List常用方法：

List所有方法：

1.3 List的使用

注意：List是个接口，并不能直接用来实例化。

如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和LinkedList都实现了List接口

2. 顺序表

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

2.1 ArrayList简介

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

【说明】

1. ArrayList是以泛型方式实现的，使用时必须要先实例化

2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问

3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的

4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者 CopyOnWriteArrayList

6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.2 ArrayList的使用 

2.2.1 ArrayList的构造方法

ArrayList有三个构造方法

无参的构造方法 ：

参数为int的构造方法：

泛型参数构造方法:

由于这个方法：套了很多方法不好讲解，我就对参数和最终使用做讲解

 使用：

ArrayList推荐写法：

public static void main(String[] args) {
    // ArrayList创建，推荐写法
    // 构造一个空的列表
    List<Integer> list1 = new ArrayList<>();
    
    // 构造一个具有10个容量的列表
    List<Integer> list2 = new ArrayList<>(10);
    list2.add(1);
    list2.add(2);
    list2.add(3);
    // list2.add("hello");  // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
    
    // list3构造好之后，与list中的元素一致
    ArrayList<Integer> list3 = new ArrayList<>(list2);
    
    // 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
    List list4 = new ArrayList();
    list4.add("111");
    list4.add(100);
 }

 2.2.2 ArrayList常见方法

2.2.2.1 add或者addAll

一共有3种方法：

2.2.2.2  remove

 

2.2.2.3 get和set

这个很简单就不多说了

 

 2.2.2.4 contains

 判断是否有这个参数

2.2.2.5 indexOf和lastIndexOf

2.2.2.6 subList

注意：java中凡是区间都是左闭右开[ , )  也就是说上面代码只能截取到1和2下标 

2.2.2.7 clear

清空顺序表

2.3 ArrayList的遍历

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //直接sout打印
        System.out.println("===sout===");
        System.out.println(list);
        // 使用下标+for遍历
        System.out.println("===for===");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        // 借助foreach遍历
        System.out.println("===foreach===");
        for (Integer integer : list) {
            System.out.print(integer + " ");
        }
        System.out.println();
        //迭代器
        System.out.println("===Iterator===");
        Iterator<Integer> it1 = list.iterator();
        while (it1.hasNext()) {
            System.out.print(it1.next() + " ");
        }
        System.out.println();

        System.out.println("===ListIterator===");
        //专门给List用的迭代器
        ListIterator<Integer> it2 = list.listIterator();
        while(it2.hasNext()){
            System.out.print(it2.next() + " ");
        }
        System.out.println();
        System.out.println("===ListIterator 倒着打印===");
        ListIterator<Integer> it3 = list.listIterator(list.size());
        while (it3.hasPrevious()) {
            System.out.print(it3.previous() + " ");
        }
        System.out.println();
        
    }

这里面迭代器可能大家看不懂我给大家说明一下：

那hasprevious其实是判断前面是否还有？是true否false

previous向前移一位，sout并打印

2.4 ArratList扩容机制

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。以下是ArrayList源码中扩容方式：

Object[] elementData;   // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  // 默认空间
private static final int DEFAULT_CAPACITY = 10;  // 默认容量大小
public boolean add(E e) {
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     elementData[size++] = e;
     return true;
 }
 private void ensureCapacityInternal(int minCapacity) {
     ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
         return Math.max(DEFAULT_CAPACITY, minCapacity);
     }
     return minCapacity;
 }
 private void ensureExplicitCapacity(int minCapacity) {
     modCount++;
 // overflow-conscious code
     if (minCapacity - elementData.length > 0)
         grow(minCapacity);
 }

 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

 private void grow(int minCapacity) {
 // 获取旧空间大小
    int oldCapacity = elementData.length;
 // 预计按照1.5倍方式扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
 // 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容

    if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
 // 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
    if (newCapacity - MAX_ARRAY_SIZE > 0)
         newCapacity = hugeCapacity(minCapacity);
 // 调用copyOf扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
 }
 private static int hugeCapacity(int minCapacity) {
 // 如果minCapacity小于0，抛出OutOfMemoryError异常
    if (minCapacity < 0)
        throw new OutOfMemoryError();

     return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
 }

【总结】

1. 检测是否真正需要扩容，如果是调用grow准备扩容

2. 预估需要库容的大小

  • 初步预估按照1.5倍大小扩容
  • 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
  • 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

3. 使用copyOf进行扩容

3. 实现顺序表

简单实现一下顺序表的大概

把要实现的方法都放在接口中：

public interface IList {
    // 新增元素,默认在数组最后新增
    void add(int data);
    // 在 pos 位置新增元素
    void add(int pos, int data);
    // 判定是否包含某个元素
    boolean contains(int toFind);
    // 查找某个元素对应的位置
    int indexOf(int toFind);
    // 获取 pos 位置的元素
    int get(int pos);
    // 给 pos 位置的元素设为 value -> 更新
    void set(int pos, int value);
    //删除第一次出现的关键字key
    void remove(int toRemove);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
    // 打印顺序表，
    // 注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    void display();
}

在用类去实现此接口，后面所有的方法都在此类中实现：

public class MyArrayList implements IList{
    private int[] array;//存放数据
    private int size;//用来记录元素个数

    //实现一个构造方法，默认初始化为大小为10
    public MyArrayList(){
        this.array = new int[10];
    }
}

size会默认为0，所有不用对他初始化

3.1 实现add

我们有size实现作为记录元素个数的下标，当刚好可以做为尾插的位置

 

但如果刚好满了，我们就需要扩容所以，可以用单独写一个方法判断一下

   @Override
    public void add(int data) {
        if(isFull()){
            //拷贝原有元素并，扩容两倍
            this.array = Arrays.copyOf(array,size * 2);
        }
        this.array[size] = data;
        this.size++;
    }

    @Override
    public boolean isFull() {
        if(array.length == size){
            return true;
        }
        return false;
    }

利用Arrays.copyOf进行扩容，他不仅可以拷贝原有的元素，还可以进行扩容操作。

 

那么在来做指定位置插入:

想要在指定位置插入，但是又不删除原位置的数据，就必须要移动

想要达到此效果，就需要从有效数据最后位置一个一个往后移动最终直接用给定的下标进行插入就可以了。

但是一旦有下标就需要进行判断下标是否合法：

    @Override
    public void add(int pos, int data) {
       try {
           checkPosOfAdd(pos);//检查pos是否合法
       }catch (PosNotLegalException e) {
           e.printStackTrace();
       }
        //移动原数组
        for (int i = size-1; i >= pos; i--) {
            this.array[i + 1] = this.array[i];
        }
        this.array[pos] = data;
        this.size++;

    }

    private void checkPosOfAdd(int pos) {
        if(pos > size || pos < 0) {
            throw new PosNotLegalException("位置不合法");
        }
    }

注意：

当pos == size的时候是没有超出数组范围的，所以判断pos合法性的时候 pos == size的位置可以不做判断

异常：

public class PosNotLegalException extends RuntimeException{
    public PosNotLegalException() {

    }

    public PosNotLegalException(String mag) {
        super(mag);
    }
}

3.2 实现contains

    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i < size; i++) {
            if(array[i] == toFind) {
                return true;
            }
        }
        return false;
    }

3.3 实现indexOf 

    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i < size; i++) {
            if(array[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

3.4 实现get

    @Override
    public int get(int pos) {
        try {
            checkPosOfGetAndSet(pos);//检查pos位置是否合法
        }catch (PosNotLegalException e) {
            e.printStackTrace();
        }

        return this.array[pos];

    }
    private void checkPosOfGetAndSet(int pos) {
        if(pos >= size || pos < 0) {
            throw new PosNotLegalException("Get/Set位置不合法");
        }
    }

3.5 实现set

    @Override
    public void set(int pos, int value) {
        try {
            checkPosOfGetAndSet(pos);
        }catch (PosNotLegalException e) {
            e.printStackTrace();
        }
        array[pos] = value;
    }

3.6 实现remove

直接用indexOf判断是否有这个数据,有就从pos后面的数据一个个向前移动，但是最后的那个元素还是会在原位置上，不用担心size-1就可以做到删除了，再次add数据就会覆盖到他

    @Override
    public void remove(int toRemove) {
        int pos = indexOf(toRemove);
        if(pos == -1) {
            System.out.println("没有要删除的数字");
            return;
        }


        for (int i = pos; i < size; i++) {
            array[i] = array[i+1];
        }
        this.array[size] = 0;
        this.size--;
    }

 3.7 实现size

    @Override
    public int size() {
        return this.size;
    }

3.8 实现clear

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            this.array[i] = 0;
//            this.array[i] = null;   如果顺序表是指针类型需要全部置为空
//        因为，只要没有引用这篇空间的引用，才会释放
        }
        this.size = 0;
    }

3.9 实现display

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

4.ArrayList的缺陷

通过源码知道，ArrayList底层使用数组来存储元素

由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。链表适合

JAVA-链表-优快云博客

Lizhihao＿
关注
数据结构(Java)--List&Arraylist（顺序表）
2302_81017910的博客
07-20 1062
List接口是Java集合框架中的一种接口，它代表了一个有序的、可重复的元素序列。List接口继承自Collection接口，定义了一些用于操作列表的方法。常见的List实现类有ArrayList和LinkedList。ArrayList是基于动态数组实现的，它支持快速随机访问和随机插入/删除操作，但插入/删除操作涉及数组元素的移动，性能相对较低。LinkedList则是基于双向链表实现的，它支持快速插入/删除操作，但访问元素需要从头部或尾部开始遍历链表，性能相对较低。
Java-----顺序表
2301_80251684的博客
07-20 928
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：【说明】1. ArrayList是以泛型方式实现的，使用时必须要先实例化2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的。
用java自己实现的arrayList
07-18
用java自己实现的arrayList，比较详细，有助于初学者理解arrayList的基本概念和基础用法
深入Java集合学习系列：ArrayList的实现原理
xishizhang的专栏
05-25 641
1. ArrayList概述：    ArrayList是List接口的可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。    每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量...
Java集合之ArrayList（含源码解析 超详细）
最新发布
rc1596919047的博客
02-19 1312
ArrayList的底层是数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加ArrayList实例的容量。这可以减少递增式再分配的数量。ArrayList继承于AbstructList，实现了List，RandomAccess，Cloneable，Java.io.Serializable这些接口。RandomAccess是一个标志接口，表明实现这个接口的List集合是支持快速随机访问的。
ArrayList集合
熊猫拿铁
11-26 1021
ArrayList集合 底层是数组结构实现，查询快、增删慢，长度可以变化 1.ArrayList类常用方法 1.1构造方法 方法名 说明 public ArrayList() 创建一个空的集合对象 1.2成员方法 方法名 说明 public boolean remove(Object o) 删除指定的元素，返回删除是否成功 public E ...
java实现ArrayList
ccuaman的博客
12-09 205
java实现ArrayList 认识ArrayList ArrayList继承自AbstractList 并实现List接口。 1.ArrayList是一个可变数组，与Java中数组相比，它的容量是动态增长的，它继承自AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 2.ArrayList继承Abstr...
Java实现自己的ArrayList
hjlooper的博客
07-06 302
java实现了ArrayList的基本操作
基础知识----Java ArrayList遍历输出顺序会和添加的顺序不一致吗？
火锅机器猫的博客
11-09 1875
基础知识----Java ArrayList遍历输出顺序会和添加的顺序不一致吗？
java提高篇(二一)-----ArrayList.pdf
12-02
ArrayList是Java集合框架中常用的列表实现之一，它继承自AbstractList并实现了List接口。ArrayList的主要特点是使用一个动态增长的数组来存储元素，因此它的操作主要围绕数组展开。 一、ArrayList概述 ArrayList是...
用java实现一个ArrayList
无名丶任性
08-04 782
通过查看ArrayList底层代码发现ArrayList有以下属性： ArayList: 1、ArrayList如果初始化的时候没有指定容量则默认大小为10，如果容量不够则按照“newCapacity=oldCapaCity+(oldCapaCity >> 1)”算法进行扩容（原容量的1.5倍进行扩容）； 2、ArrayList线程不安全，若要实现线程安全可以使用synchronized关键字或Collections.synchronizedList()方法初始化，如下 List lis
ArrayList 实现（Java）
weixin_43520256的博客
03-06 411
接口代码: //int 类型的 List 实现 //int 用作下标。Integer 用于元素 public interface List { boolean add(Integer e); void add(int index,Integer e); //根据下标删除 Integer remove(int index); //删除第一个遇到的 boolean remove(Integer element); Integer get(int ind
Java代码实现ArrayList
1 Byte 的博客
09-26 1567
ArrayList结构图 Java代码实现ArrayList 注意点：注意数组下标越界问题 public class MyArrayList<E> { // 数组长度 private int size; // 数组已存数据的大小 private int index; // 声明数组 private E dadaArr[]; // 构造函数完成初始化 public MyArrayList(int size){ t
java ArrayList 的实现
润寒-Meteor
03-28 375
ArrayList 的实现package com.meteor.algorithm;import java.util.Iterator; import java.util.NoSuchElementException;/** * arrayList实现 * Created by Meteor on 2016/3/21. */ public class MyArrayList<T> implem
Java-ArrayList的实现
weixin_50869378的博客
08-06 184
我们在使用数组这种数据类型的时候会遇到一个问题，就是这个数组在一开始的时候就要确定一定的长度，这使得数组的容量有限，一旦后续需要存储的数据个数超过了数组长度，就无法再存储了。 为了在实际应用中，有一个可以不限制长度的数组，我们要自己实现一个ArrayList。实现ArrayList的方法是通过对数组和相关参数进行封装，来起到自动扩容的作用。具体来说，就是当数组没有被填满的时候，后续的数据和普通数组一样存入，当要数组被填满的时候，我们就new一个新的，更长的数组，将原来的数组内容以此复制到新的数组内，并存入新
实现java的arraylist_Java实现ArrayList
weixin_34035088的博客
02-20 124
说明都在注释:package adt.array;import java.util.Iterator;import java.util.NoSuchElementException;/**** @author 数据结构与算法分析* @param AnyType T 任何类型*/public class MyArrayList implements Iterable{//集合初识长度privat...
数据结构---ArrayList（Java实现）
X_H学Java的博客
06-11 5200
线性表是数据结构很重要的知识，本文对ArrayList进行全方面剖析，举例介绍基本方法的使用，解析底层扩容机制，并对其进行模拟实现
java中自己实现一个ArrayList
wanghuiwei888的博客
12-22 1117
import java.util.Arrays; import java.util.Iterator; public class MyList implements Iterable{  /*   * 设计一种容器:可以不初始化长度,长度可以自动拓展   */  private int length = 10;//定义初始化容量大小的变量  private Object[]
java arraylist的实现_Java中ArrayList实现原理
weixin_29596423的博客
02-27 176
简述：ArrayList可以理解为动态数组，与Java中的数组相比，它的容量能动态增长。超出限制时会增加50%容量，用System.arraycopy()复制到新的数组中，因此最好能给出数组大小的预估值；容量大小也可以在程序中通过ensureCapacity(int minCapacity)方法来调整；默认第一次插入元素时创建大小为10的数组(注意，是在插入元素时，而不是new ArrayList...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值