java顺序表——ArrayList详解

最新推荐文章于 2024-03-28 00:48:27 发布
最新推荐文章于 2024-03-28 00:48:27 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： java 数据结构 顺序表 ArrayList 详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baixian110/article/details/130616039
版权

1.顺序表的概念

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

2.自己实现一个顺序表——MyArrayList

2.1 顺序表成员变量的定义

public class MyArrayList {

    public static int FEFAULT_MAX_SIZE = 10;//数组最大容量
    public int[] elem;//第一一个数组，用于存储数据
    public int useSize;//记录存储了多少数据
    }

2.2 顺序表成员方法的简单定义

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

2.3.顺序表的完整定义（实现）

import java.util.Arrays;

public class MyArrayList {

    public static int FEFAULT_MAX_SIZE = 10;//数组最大容量
    public int[] elem;//第一一个数组，用于存储数据
    public int useSize;//记录存储了多少数据

    //初始化（构造方法）
    public MyArrayList() {
        this.elem = new int[FEFAULT_MAX_SIZE];//开辟存储空间
        this.useSize = 0;//一开始没有存数据，所以usesize为0
    }

    //该数据结构所需要的所有的方法

    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() {
        for (int i = 0; i < this.useSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }

    //判满
    public boolean isFull() {
        if (this.useSize == FEFAULT_MAX_SIZE) {
            return true;
        } else
            return false;
    }

    //扩容
    public void addDfaultSize() {
        this.elem = Arrays.copyOf(elem, FEFAULT_MAX_SIZE * 2);
        FEFAULT_MAX_SIZE = FEFAULT_MAX_SIZE * 2;
    }


    //检查位置合法性
    public void checkAddIsValid(int pos){
        if (pos < 0 || pos > useSize + 1 ) {
            throw  new AddIndexOutException("Addd的pos值非法！");
        }
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        //如果满了就扩容
        if (this.isFull()) {
            this.addDfaultSize();
        }

        this.elem[useSize] = data;
        this.useSize++;
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        //判断插入位置的合法性
        try{
            checkAddIsValid(pos);
            //插入
            for (int i = useSize; i > pos ; i--) {
                this.elem[i] = this.elem[i-1];
            }
            useSize++;
        }catch (AddIndexOutException addIndexOutException){
            addIndexOutException.printStackTrace();
        }

    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < useSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < useSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;//数组么有-1下标
    }

    //检查Get位置合法性
    public void checkGetIsValid(int pos){
        if (pos < 0 || pos > useSize  ) {
            throw  new GetIndexOutException("Get的pos值非法！");
        }
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        try{
            checkGetIsValid(pos);

        }catch (GetIndexOutException getIndexOutException){
            getIndexOutException.printStackTrace();
        }
        return this.elem[pos];
    }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        try{
            checkGetIsValid(pos);
            this.elem[pos] = value;
        }catch (GetIndexOutException getIndexOutException){
            getIndexOutException.printStackTrace();
        }

    }

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        for (int i = 0; i < useSize; i++) {
            if (this.elem[i] == toRemove) {
                for (int j = i; j < useSize - 1; j++) {
                    this.elem[j] = this.elem[j + 1];
                }
                this.elem[useSize] = 0;
                useSize--;
                return;
            }
        }
    }

    // 获取顺序表长度
    public int size() {
        return this.useSize;
    }

    // 清空顺序表
    public void clear() {
        for (int i = 0; i < useSize; i++) {
            this.elem[i] = 0;
        }
        this.useSize = 0; 
    }
}

两个异常的定义与实现

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

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

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

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

3.java原生顺序表——ArratList

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
在这里插入图片描述
注意：

  1. ArrayList是以泛型方式实现的，使用时必须要先实例化
  2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的（可以把一个对象变成字符串称之为序列化，字符串变成对象叫反序列化）
  5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
  6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

3.1ArrayList的构造方法

//三种构造方法
ArrayList()// 无参构造
ArrayList(Collection<? extends E> c) //利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity) //指定顺序表初始容量
1.无参构造方法

在这里插入图片描述其中elementData是一个成员数组，类型是Object类，如下图
在这里插入图片描述DEFAULTCAPACITY_EMPTY_ELEMENTDATA
是一个Object数组类型的常量，并且为空在这里插入图片描述也就是说此时没有为elementData分配内存，也就是说当我们调用无参的构造方法实例化一个ArrayList对象时，开辟了一个空数组。如下代码

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();//实例化一个整型的ArrayList，调用无参的构造方法
        arrayList1.add(1);
    }
}

那么在arrayList1.add(1);这一句里面又做了什么呢
下图是调用add方法后的代码执行过程

取自比特鹏哥

实际上在第一次add的时候才会为ArrayList底层分配内存，且大小为10
而且通过对于add方法的考察会知道ArrayList中的元素个数如果超出，需要扩容是按1.5倍的最大容量扩容的

2.ArrayList(Collection<? extends E> c)构造方法
ArrayList(Collection<? extends E> c) //利用其他 Collection 构建 ArrayList

先来解释一下形参Collection<? extends E> c，首先Conllection是java内置的一个原生接口,表示集合，而Collection<? extends E>表明c是一个泛型而且是一个实现connection接口的类，例如下图
在这里插入图片描述List、Set、ArrayList、LinkedList等都实现了connection接口，并且这个c指定的泛型参数一定是E或者E的子类,E是Element的缩写，一般在集合中使用，表示集合中的元素类型。而Connection表示集合。所以这个代码的意思就是定义了泛型c，ArrayList构造方法的形参是一个实现Connecion接口（也就是必须是一个集合）的类型，并且里面的泛型形参指代的是集合元素类型（是E本身或者E的子类）

例如下面这样

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
        arrayList1.add(1);
        ArrayList<Integer> arrayList12 = new ArrayList<Integer>(arrayList1);
    }
}

为什么arrayList1可以作为实参传入。
因为arrayList的类型是ArrayList，其中ArrayList类实现了Connection接口，并且泛型的类型实参Integer，表面ArrayList集合中的元素类型为Integer,符合形参定义。

ArrayList<Integer> arrayList12 = new ArrayList<Integer>(arrayList1);

这个实例化就是调用带参数的构造方法，将传入的集合的所有元素复制一份，作为自己的集合元素并开辟相应的内存空间

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
        arrayList1.add(1);
        System.out.println(arrayList1);
        ArrayList<Integer> arrayList2 = new ArrayList<Integer>(arrayList1);
        System.out.println(arrayList2);
        arrayList2.add(2);
        System.out.println(arrayList2);
    }
}

在这里插入图片描述

3.ArrayList(int initialCapacity)构造方法

这是一个指定顺序表初始容量的构造方法，细节就不多说了

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
        arrayList1.add(1);
        System.out.println(arrayList1);
        ArrayList<Integer> arrayList2 = new ArrayList<Integer>(arrayList1);
        System.out.println(arrayList2);
        arrayList2.add(2);
        System.out.println(arrayList2);
        ArrayList<Integer> arrayList3 = new ArrayList<Integer>(2);
        arrayList3.add(1);
        arrayList3.add(2);
        System.out.println(arrayList3);
    }
}

在这里插入图片描述

3.2ArrayList常见操作

1.插入操作

尾插 e

`boolean add(E e)`

将 e 插入到 index 位置（指定位置插入）

`void add(int index, E element)`

尾插 c 中的元素(直接插入一个集合)

`boolean addAll(Collection<? extends E> c)`

将c插入到index位置（插入一个集合）

boolean addAll(int index, Collection<? extends E> c)

如下面这个例子

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(1);//尾插入1
        System.out.println(arrayList1);
        arrayList1.add(1, 2);//下标为1为位置插入2
        System.out.println(arrayList1);
        ArrayList<Integer> arrayList2 = new ArrayList<>();
        arrayList2.addAll(arrayList1);//arrayList2尾插arrayList1的全部元素
        System.out.println(arrayList2);
        arrayList2.addAll(1, arrayList1);//从arrayList2下标为2的位置插入arrayList1的全部元素
        System.out.println(arrayList2);
    }
}
2.删除操作

删除 index 位置元素

E remove(int index)

删除遇到的第一个 o

boolean remove(Object o)

注意当我们元素类型是Integer时，代码remove(0)会识别将0识别为Int，而不是Integer类型，remove(0)中的这个0会认为是indexd的实参而不是Object实参，所以我们在删除存有Integer类型的元素时，需要进行装箱操作。
例如：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println(arrayList1);
        arrayList1.remove(new Integer(0));
        System.out.println(arrayList1);
        arrayList1.remove(0);
        System.out.println(arrayList1);
    }
}

在这里插入图片描述

3.获取操作

获取下标 index 位置元素

E get(int index)

例如

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println(arrayList1);
        System.out.println(arrayList1.get(0));
    }
}

在这里插入图片描述

4.更新操作

将下标 index 位置元素设置为 element

E set(int index, E element) 

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println(arrayList1);
        System.out.println(arrayList1.set(0,1));
        System.out.println(arrayList1);
    }
}

在这里插入图片描述

5.清空操作
void clear() //清空

例子

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println(arrayList1);
        arrayList1.clear();
        System.out.println(arrayList1);
    }
}

在这里插入图片描述

6.其他操作

判断 o 是否在线性表中

boolean contains(Object o)

返回第一个 o 所在下标

int indexOf(Object o)

返回最后一个 o 的下标

int lastIndexOf(Object o)

截取部分 list

List<E> subList(int fromIndex, int toIndex)

例子

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(0);
        System.out.println(arrayList1);
        System.out.println(arrayList1.contains(new Integer(0)));
        System.out.println(arrayList1.indexOf(new Integer(0)));
        System.out.println(arrayList1.lastIndexOf(new Integer(0)));
        List <Integer> arrayList2 = arrayList1.subList(0, 2);//必须用List类型承接，同时下标范围依旧是左闭右开
        System.out.println(arrayList2);
    }
}

在这里插入图片描述
但是
subList方法需要注意一下，看下面这个代码

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(0);
        System.out.println(arrayList1);
        List <Integer> subList = arrayList1.subList(0, 2);
        System.out.println(subList);
        subList.set(0, 1);//更新subList下标为0的元素值为1
        System.out.println(subList);
        System.out.println(arrayList1);//arrayList下标为0的元素也会变化
    }
}

在这里插入图片描述
这是因为subList与arrayList共用一个value数组，注意subList方法并不是通过copy实现的，所以这不是浅拷贝。

3.3ArrayList的遍历

ArrayList有三种常见的遍历方式
第一种for循环+下标，这就不过多赘述了。
第二种是用for each

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        for (Integer x:arrayList1) {
            System.out.print(x+" ");
        }
    }
}

在这里插入图片描述
第三种是使用迭代器

```java
import java.util.ArrayList;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        for (Integer x:arrayList1) {
            System.out.print(x+" ");
        }
        System.out.println();

        //创建一个arrayList1的迭代器
        ListIterator<Integer> it = arrayList1.listIterator();//it会指向集合受元素的前一个单位的位置
        while(it.hasNext()){//it.hasNext()判断it的下一个位置是否有元素，有返回true,没有返回false
            System.out.print(it.next()+" ");//回去it所指位置的下一个单位位置的元素内容并将next指向下一个元素
            //这个it有点像C里面栈的头指针的含义
        }
    }
}

在这里插入图片描述
关于迭代器，可以去看这篇博客
https://blog.csdn.net/rbx508780/article/details/126980386

3.4ArrayList的扩容机制

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

ArrayList的扩容机制这样的：

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

  2. 预估需要库容的大小

  3. 初步预估按照1.5倍大小扩容 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容

  4. 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

  5. 使用copyOf进行扩容

baixian110
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 集合框架 - ArrayList详解
zxwyhzy的博客
10-20 1162
ArrayList 介绍，常用操作，扩容机制
Java常用集合之ArrayList（深入源码）
m0_62609939的博客
03-18 1465
Java常用集合之ArrayList（深入源码）
Java：ArrayList详解
最新发布
2301_79783967的博客
03-28 599
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：不带参数 没有初始化，默认为空，只是一个数组引用常量数组，没有分配内存，长度是0 因此不带参数的构造并没有给数组大小 带参数初始化数组大小如果参数是0的情况下，就会是空数组如果是参数小于0就会抛出异常 另一个带一个参数的构造方法参数Collection是一个接口，只要是实现了该接口的都可以进行传递尖括号里的‘？’是通配符，尖括号里面可以写E或者E的子类举例： ArrayList实现了Collection接口，array
Java基础知识之ArrayList
tyloonulinuli的博客
12-07 1328
1.ArrayList集合快速入门 2.ArrayList对于泛型的支持 3.ArrayList常用API.遍历 4.ArrayList集合案例:遍历并删除元素 5.ArrayList集合案例:存储自定义类型 6.ArrayList集合案例:元素搜索
Java — “ArrayList＜Integer＞如何转化为int[ ]数组”
一切因为是码农
10-21 6234
问题引入： ArrayList转化为数组可以通过ArrayList的toArray()方法实现 这个方法有一个参数，该参数的类型必须为泛型 网上搜Arraylist和数组互相转换的方法时，举的例子都是String类型的。 比如： 但是我们将 String 换为 int 则会报错 这是因为ArrayList中规定的泛型是Integer，且int[]并不等同于Integer[]，不能直接转化到int[] 解决方法： 方法一：for循环赋值 int[] d = new int[list.size()];
[JAVA数据结构]顺序表ArrayList
weixin_67719939的博客
04-25 556
JAVA,ArrayList
java关键字ArrayList详解
07-04
ArrayList是Java中的一种常见的数据结构，它实现了List接口，是线程不安全的动态数组。它的容量可以自动增长，因此可以方便地插入、删除和查找数据，是Java集合框架中广泛使用的一种结构。 ArrayList的优势在于灵活...
Java源码篇之容器类——ArrayList
12-20
Java源码篇之容器类——ArrayList1、前言2、ArrayList的类关系3、ArrayList的源码一、类的属性二、add()方法三、get()方法四、remove()方法五、set()方法4、总结 1、前言 对于平常开发的时候遇到的ArrayList，在此做...
java——ArrayList-源码解析.docx
05-09
ArrayList是list接口下一个底层用数组实现的典型list类，也就是传说中的动态数组，用MSDN的说法就是array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。...
Java中Vector与ArrayList的区别详解
09-05
Java中的ArrayList和Vector都是列表（List）接口的实现类，它们在功能上相似，但在细节上存在一些重要的差异。这两个类都是基于数组实现的，但它们的性能特点、线程安全性和扩容策略有所不同。 1. **扩容策略**： ...
java基础——集合ArrayList ,LinkedList
01-21
目录前言数组与集合区别集合描述集合格式方法ArrayList实例1.add(E e)2.add(int index, E element)3.addAll(Collection c)4.clear() 与 isEmpty()5.contains(Object o)6.indexOf(Object o)7.iterator()8.remove(int ...
Java数据结构—ArrayList顺序表
Green_756的博客
08-07 574
数据结构、ArrayList顺序表
【数据结构】ArrayList和顺序表
qq_61862008的博客
11-12 401
数据结构——ArrayList
如何在Java中对ArrayList进行排序
一名可爱的技术搬运工
05-23 1325
默认情况下， ArrayList的元素是按照放入其中的顺序显示的。 通常，您可能需要对ArrayList进行排序以使其按字母顺序排序。 在此示例中，它显示了使用Collections.sort（'List'）对ArrayList进行排序。 import java.util.ArrayList; import java.util.Collections; import java.util.Li...
javaArrayList
wjc_hbu的博客
05-05 3385
我们知道，数组是静态的，只有当它的大小确定了才能给它初始化赋值，而且这个大小是不能被修改的，所以有时候你刚开始不确定你要输入数据的多少时，简单的数组不好实现（万一你输入的数据多于数组大小时，就会报错：数组溢出），为此java引用了" 数组列表".数组列表格式如下： ArrayList<参数类型> 变量名字= new ArrayList<参数类型可以没有>（容量大小也可以不...
查找ArrayList元素的下标
热门推荐
刘利新西安
01-10 1万+
package com.javacodegeeks.snippets.core; import java.util.ArrayList; public class SearchElementsInArrayList { public static void main(String[] args) { // Create an ArrayList and populate it wit
java arraylist 结构_Java自定义ArrayList(顺序存储结构)和性能分析
weixin_33352924的博客
02-13 183
1. 自定义ArrayList首先我们先看一个案例：假如一个球场的教练，安排球员(5个)上场模拟数据存储的案例，模拟上场球员的球衣号码的存储。(1)初始容量为5的线性列表，准备用来存储场上的5个球衣号码：[11,22,33,44,55](2)查询指定位置的球员球衣号码是多少，查询索引位置为2的球衣号码如：33；(3)根据球衣号码查询该球员在场上的索引位置，44在球衣号码的球员在场上的索引位置是3(...
单元测试——ArrayList
10-12
单元测试是一种软件测试方法，用于测试程序中的最小可测试单元——函数、方法或类。在引用中，我们展示了如何使用JUnit进行单元测试，以及如何使用ArrayList和自定义类进行测试。在测试中，我们可以使用断言来验证...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值