java顺序表——ArrayList详解_java arraylist

1.顺序表的概念

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

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

2.1 顺序表成员变量的定义

public class MyArrayList {

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

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() { }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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; 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

两个异常的定义与实现

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

    public AddIndexOutException(String message) {
        super(message);
    }
}
1
2
3
4
5
6
7
8

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

    public GetIndexOutException(String message) {
        super(message);
    }
}
1
2
3
4
5
6
7
8

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
2
3
4

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);
    }
}
1
2
3
4
5
6
7
8

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

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

2.ArrayList(Collection<? extends E> c)构造方法

ArrayList(Collection<? extends E> c) //利用其他 Collection 构建 ArrayList
1

先来解释一下形参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);
    }
}
1
2
3
4
5
6
7
8
9

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

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

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

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.2ArrayList常见操作

1.插入操作

尾插 e

`boolean add(E e)` 
1

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

`void add(int index, E element)` 
1

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

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

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

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

如下面这个例子

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.删除操作

删除 index 位置元素

E remove(int index) 
1

删除遇到的第一个 o

boolean remove(Object o) 
1

注意当我们元素类型是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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.获取操作

获取下标 index 位置元素

E get(int index) 
1

例如

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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

4.更新操作

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

E set(int index, E element) 
1

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5.清空操作

void clear() //清空
1

例子

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

6.其他操作

判断 o 是否在线性表中

boolean contains(Object o) 
1

返回第一个 o 所在下标

int indexOf(Object o) 
1

返回最后一个 o 的下标

int lastIndexOf(Object o) 
1

截取部分 list

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

例子

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

但是
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的元素也会变化
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这是因为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+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

第三种是使用迭代器

```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里面栈的头指针的含义
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

关于迭代器，可以去看这篇博客
https://blog.csdn.net/rbx508780/article/details/126980386

3.4ArrayList的扩容机制

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

ArrayList的扩容机制这样的：

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

2. 预估需要库容的大小

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

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

5. 使用copyOf进行扩容