在介绍顺序存储结构之前，我们先来看看动态数组的内容。
首先Java内置数组的特点：数组的长度一旦确定则不可更改、只能存储同一类型的数据、每个存储空间大小一致且地址连续、提供角标的方式访问元素。
Java内置数组的潜在问题：容量不够（只能定义一个新的数组进行一一赋值，达到扩容的目的）、指定位置插入或删除元素带来的不便（在尾端插入方便，如果在头或者中间插入元素，则要进行元素的移动）、数组对象只有length属性是否够用。
因此，能否用面向对象的思想，将数组进行再度封装，可以把数组的相关属性和行为封装在类中，类似字符串String类，然后创建其方法进行调用，这样就方便了很多。因此我们没有必要每次遇到一个问题就要重复那些操作步骤。
那么如何封装动态数组？——属性方面：int size 即数组的有效元素个数 ； int capacity 获取数组的最大容量data.length；E[] data 数组的存储容器（这里的E指的是泛型，因为我们在封装一个动态数组的时候，不能将其存储的数据类型限制，这样这个动态数组定义出来作用的范围会非常小，那我们所做的意义不大，只有外界想要存储什么类型的数据，将其类传进去即可。）
—— 行为方面：增、删、改、查等等操作。
为什么要先介绍动态数组呢？因为动态数组是顺序存储结构的具体实现，我们接下来要介绍的不管是线性表也好、栈结构也好、还是队列，它都是基于动态数组实现的。
现在进入正题，前方高能预警！
线性表
什么是线性表？—— 零个或多个数据元素的有限序列
若将线性表记为（a1,...,ai-1,ai,ai+1,...,an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。当i=1,2,...,n-1时，ai有且仅有一个直接后继，当i=2,3,...,n时，ai有且仅有一个直接前驱。
所以线性表元素的个数n（n>=0）,定义为线性表的长度，当n=0时，成为空表。
线性表首要的一个接口就是List,它是线性表的最终父类，我们首先来看一下它的接口的定义：
package 线性表;
public interface List<E> { //list是一个接口，存储的数据类型不能限定
/**
* 获取线性表中元素的个数(线性表的长度)
* @return 线性表中有效元素的个数
* */
public int getSize();
/**
* 判断线性表是否为空
* @return 是否为空的布尔类型值
* */
public boolean isEmpty();
/**
* 在线性表中指定的index角标处添加元素e
* @param index 指定的角标 0<=index<=size
* @param e 要插入的元素
* */
public void add(int index,E e);
/**
* 在线性表的表头位置插入一个元素
* @param e 要插入的元素 指定在角标0处
* */
public void addFirst(E e);
/**
* 在线性表的表尾位置插入一个元素
* @param e 要插入的元素 指定在角标size处
* */
public void addLast(E e);
/**
* 在线性表中获取指定index角标处的元素
* @param index 指定的角标 0<=index<size
* @return 该角标所对应的元素
* */
public E get(int index);
/**
* 获取线性表中表头的元素
* @return 表头元素 index=0
* */
public E getFirst();
/**
* 获取线性表中表尾的元素
* @return 表尾的元素 index=size-1
* */
public E getLast();
/**
* 修改线性表中指定index处的元素为新元素e
* @param index 指定的角标
* @param e 新元素
* */
public void set(int index,E e);
/**
* 判断线性表中是否包含指定元素e 默认从前往后找
* @param e 要判断是否存在的元素
* @return 元素的存在性布尔类型值
* */
public boolean contains(E e);
/**
* 在线性表中获取指定元素e的角标 默认从前往后找
* @param e 要查询的数据
* @return 数据在线性表中的角标
* */
public int find(E e);
/**
* 在线性表中删除指定角标处的元素 并返回
* @param index 指定的角标 0<=index<size
* @return 删除掉的老元素
* */
public E remove(int index);
/**
* 删除线性表中的表头元素
* @return 表头元素
* */
public E removeFirst();
/**
* 删除线性表中的表尾元素
* @return 表尾元素
* */
public E removeLast();
/**
* 在线性表中删除指定元素e
* */
public void removeElement(E e);
/**
* 清空线性表
* */
public void clear();
}
现在来说说线性表的顺序存储结构：指的是用一段地址连续的存储单元，依次存储线性表的数据元素。
其实说白了就是用数组实现的，List接口下有一个用数组实现的子类叫ArrayList，它实现了List接口中的所有方法，并且根据自己的性质和属性有自己特有的方法。下面是它与List接口之间的关系（类与接口之间是实现的关系，与类与类之间泛化关系类似）。
package 线性表;
/**
* 用顺序存储结构实现的List - 叫顺序线性表 - 也叫顺序表
* @author kddai
*
* @param <E>
*/
public class ArrayList<E> implements List<E>{
private static int DEFAULT_SIZE=10; //默认容量大小10
private E[] data; //存储数据元素的容器
private int size; //线性表的有效元素的个数 data.length表示线性表的最大容量
/**
* 创建一个容量默认为10的一个线性表
*/
@SuppressWarnings("unchecked")
public ArrayList() {
this(DEFAULT_SIZE);
}
/**
* 创建一个容量为指定capacity的一个线性表
*/
@SuppressWarnings("unchecked")
public ArrayList(int capacity) {
this.data=(E[]) new Object[capacity];
this.size=0;
}
/**
* 将一个数组封装成一个线性表
* @param arr
*/
public ArrayList(E[] arr) { //为了保证数据的稳定性
data=(E[]) new Object[arr.length]; 在内部创建一个新的数组
for(int i=0;i<arr.length;i++) { //将外部传入的数组对内部的数组一一赋值
data[i]=arr[i];
}
size=arr.length; //这样在外部再去修改传入的数组中的值，对内部的线性表的值是无影响的
}
@Override
public int getSize() { //获取线性表中有效元素的长度
return size;
}
@Override
public boolean isEmputy() { //判断该线性表是否为空表
return size==0;
}
private void resize(int newLen){ //扩容/缩容
//创建一个新的数组，新数组的长度由传入的参数控制，再将原来的数组里面的元素逐个赋值到新的数组里面
E[] newData = (E[]) new Object[newLen];
for(int i=0;i<size;i++) {
newData[i]=data[i];
}
data = newData; //最后将这个新的数组的地址给内部原来数组对象的引用，达到扩容/缩容的目的
}
@Override
public void add(int index, E e) { //在指定下标添加一个元素
if(index<0 || index>size) { //如果指定的角标不在该数组的合理范围内
//抛出异常，角标越界
throw new ArrayIndexOutOfBoundsException("角标越界");
}
if(size==data.length) { //如果能添加，且此时有效元素的个数达到线性表的存储的最大容量
resize(2*data.length); //调用函数进行扩容
}
for(int i=size-1;i>=index;i--) {//先将元素后移
data[i+1]=data[i];
}
data[index]=e; //再将指定的元素放入指定的下标位置
size++;
}
@Override
public void addFirst(E e) { //在线性表表头添加一个元素
add(0,e); //也就是指定位置添加元素，只不过这个指定位置一直是表头
}
@Override
public void addLast(E e) { //在尾部添加
add(size,e);
}
@Override
public E get(int index) { //获取指定角标的元素
if(index<0 || index>size-1) { //首先判断该角标是否越过有效元素的个数，或是数组最小下标位置
throw new ArrayIndexOutOfBoundsException("get函数角标越界");
}
return data[index]; //没有出错，则直接返回指定下标的元素
}
@Override
public E getFirst() { //获取头元素
return get(0); //就是获取指定头位置的下标的元素
}
@Override
public E getLast() { //获取尾元素
return get(size-1);//这里的尾元素不是数组最后一个元素，而是有效元素的最后一个位置的元素
}
@Override
public void set(int index, E e) { //更改某处的元素
//角标没有越界则直接替换即可
if(index<0 || index>size-1) {
throw new ArrayIndexOutOfBoundsException("get函数角标越界");
}
data[index]=e;
}
@Override
public boolean contains(E e) { //是否包含某元素
if(isEmputy()) { //首先判空，如果数组为空，肯定不包含
return false;
}
for(int i=0;i<size;i++) {//不为空，则遍历查找
if(data[i]==e) { //如果存在，则直接返回true，不再向下查找
return true;
}
}
return false;
}
@Override
public int find(E e) { //查找某元素，与是否包含某元素类似做法
if(isEmputy()) {
return -1;
}
for(int i=0;i<size;i++) {
if(data[i]==e) {
return i;
}
}
return -1;
}
@Override
public E remove(int index) { //删除某一位置的元素
if(index<0 || index>size-1) { //首先角标不能越界
throw new ArrayIndexOutOfBoundsException("删除的角标越界");
}
E e=get(index); //其次要将要删除的元素先提取出来
for(int i=index;i<size-1;i++) {//然后将该元素位置后面的元素向前移动
data[i]=data[i+1];
}
size--; //注意移动完了，你的有效元素也减少了一个喔！
//这里提点一下，其实内部数组中有效元素并没有减少，只是你有效元素位置指针指向了前一个位置，当前指向的元素和后一个元素是相同的，因为在移动元素的时候，是覆盖的移动，当下次再添加元素的时候，就将原来的覆盖了。
if(data.length>DEFAULT_SIZE&&size<=data.length/4) {
resize(data.length/2);
} //每次删除完记得判断一下，删除的太多，空间开的太大会浪费喔。所以要进行缩容
return e;//最后别忘了将删除的元素返回，以便检查删除的对不对
}
@Override
public E removeFirst() { //删除头元素
return remove(0);
}
@Override
public E removeLast() { //删除尾元素
return remove(size-1);
}
@Override
public void removeElement(E e) { //删除指定元素
int index = find(e); //先找到该元素对应的下标
if(index==-1) {
throw new IllegalArgumentException("删除元素不存在");
}
remove(index); //再根据下标删除就行啦
}
@Override
public void clear() { //清空
size=0; //这里直接将有效元素置空即可，管它原来数组里面存了多少呢，反正后面在添加的时候还是会覆盖
}
@Override
public boolean equals(Object obj) { //重写equals方法，如果两个线性表有效元素个数相同，元素也一样视为相等
if(obj==null) {
return false;
}
if(obj==this) {
return true;
}
if(obj instanceof ArrayList) { //这里先要判断传进来的对象是不是线性表，不是线性表就不用多此一举的去比较啦
ArrayList list = (ArrayList) obj; //还要将传进来的对象进行强转一下
if(this.getSize()==list.getSize()) { //这里如果两个线性表有效元素个数相同的话
for(int i=0;i<size;i++) { //再逐个去比较每个元素是否一样
if(data[i]!=list.data[i]) { //一旦有一个不一样。就没有比下去的意义啦
return false;
}
}
return true;
}
return false;
}
return false;
}
public String toString() { //tostring方法，打印线性表的内容，方便查看
StringBuilder sb = new StringBuilder();
sb.append("ArrayList:szie="+size+",capacity="+data.length+"\n");
if(isEmputy()) {
sb.append("[]");
}else {
sb.append('[');
for(int i=0;i<size;i++) {
sb.append(data[i]);
if(i==size-1) {
sb.append(']');
}else {
sb.append(',');
}
}
}
return sb.toString();
}
public int getCapacity(){ //获得该线性表当前的容量大小，也就是数组的大小
return data.length;
}
public void swap(int i,int j){ //交换两个元素，指定的是角标
if(i<0||i>size-1||j<0||j>size-1){
throw new ArrayIndexOutOfBoundsException("角标越界");
}
E temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
至于它的测试，我已经测试过了。如果你看到这不放心的话，可以考过去进行方法的测试，注意导包倒正确喔，这里写的内容太多了，其实之前我有介绍这个类，可参考下面链接的这篇文章，也是我写的，希望对你有所帮助，当然对我自己的帮助是最大的，嘻嘻(#^.^#)。
https://blog.csdn.net/weixin_45432742/article/details/100284589