注：本篇文章较基础，主要介绍顺序表的实现，以及对java自带ArrayList的一些简单使用，适合需要简单了解顺序表的同学。
目录
一、顺序表定义
顺序表是一种在逻辑上，物理上（即地址）都连续的存储单元存储数据元素的一种数据结构，一般是使用数组来实现。
如图：
在物理地址上，每个数据元素都占了len个大小的空间，当知道第一个元素的地址后，第k个元素的地址就是 location+(k-1)*len。
那么根据定义，可以得到顺序表的两个特点：
1️⃣ 顺序表在地址存储上是连续的。
2️⃣ 顺序表中元素是同一种数据类型。
不多bb，直接开始介绍顺序表的实现☻。
二、自定义顺序表
1.创建一个MyArrayList类
public class MyArrayList {
private int[] elem;
private int usedSize;//记录当前表内元素个数
private static final int DEFAULT_SIZE = 4;//默认容量
public MyArrayList() {
this.elem = new int[DEFAULT_SIZE];
}
}2.disPlay()
作用：打印顺序表。
本质上就是遍历一下数组，然后逐一打印。
但我们要留意的是，如果表为空的时候，应该怎么办。
RT:
private boolean isEmpty() {
if (this.usedSize==0)
return true;
return false;
}public void display() {
if(isEmpty()){//判断是否为空表，返回boolean
System.out.println("空表");
return;
}
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elem[i] + " ");
}
System.out.println();
}3.Add（）
作用：在数组末尾添加元素。
首先，我们回直接想到，让 this.elem[this.usedSize] = data;但执行这行代码的前期是数组没有满，即usedSize ！= DEFAULT_SIZE，所以我们先写一个判断表满的函数。
public boolean isFull() {
return (size() == this.elem.length);
}那么，接下来就很简单了，如果满了就扩容。
注：对于扩容，如果每次扩的比较小，而实际对该表的Add使用次数较多的话，就会频繁扩容，降低效率，但扩的大的话，也同样会带来空间上的浪费，所以应当基于实际，选择合适的扩容范围。
RT:
// 新增元素,默认在数组最后新增
public void add(int data) {
if (isFull()) {
this.elem =
Arrays.copyOf(this.elem, 2 * this.elem.length);
}
this.elem[this.usedSize] = data;
this.usedSize++;
}4.Add(int pos，int data)
作用：在指定的位置（默认为前），添加元素。
仔细想想，这个函数与Add（）函数类似，同样只要this.elem[this.usedSize] = data;即可完成，
不同的是，我们要先判满，然后判断pos的值是否合法。
那就先实现下pos是否合法函数。
private boolean checkPosInAdd(int pos) {
if (pos < 0 || pos >= this.usedSize) {
return false;
}
return true;//合法
}RT:
public void add(int pos, int data) {
if (!checkPosInAdd(pos)) {
throw new PosOutInedx("下标不合法");
}
if (isFull()) {
this.elem =
Arrays.copyOf(this.elem, 2 * this.elem.length);
}
for (int i = this.usedSize; i > pos; i--) {
this.elem[i] = this.elem[i - 1];
}
this.elem[pos] = data;
this.usedSize++;
}5.contain（int toFind）
作用：判定表内是否包含给定元素。
不难想到，只要一遍遍历即可查找到，如果给定表为有序，还可以用二分。
RT:
public boolean contains(int toFind) {
if (isEmpty()) {
return false;
}
for (int i = 0; i < this.usedSize; i++) {
if (this.elem[i] == toFind) {
return true;
}
}
return false;
}6.indexOf（int toFind）
作用：返回给定数据在表内的下标。
我们已经会了第五个函数，这个自然轻松拿捏。同样是遍历，然后return index;
RT:
public int indexOf(int toFind) {
if (isEmpty()) {
System.out.println("空");
return -1;
}
for (int i = 0; i < this.usedSize; i++) {
if (this.elem[i] == toFind) {
return i;
}
}
return -1;
}7.get(int pos)
作用：获取pos位置的元素。
RT:
public int get(int pos) {
if (isEmpty()) {
throw new PosOutInedx("空表");
}
if(!checkPosInAdd(pos)){
throw new PosOutInedx("pos不合法");
}
return this.elem[pos];
}看到这里了，各位应该可以感受到数据结构的严谨了吧，我们无论些什么函数，都一定考虑合法问题、扩容问题...... 只有我们做好了这些铺垫，我们就能大大减少Bug的数量。
8. set（int pos，int value）
作用：将表内pos位置的值更新为value。
这时，相信大家第一时间可以想到，pos是否合法，表是否为空了吧？
RT:
public void set(int pos, int value) {
if(isEmpty()){
throw new PosOutInedx("空表");//自定义异常
}
if (!checkPosInAdd(pos)) {
throw new PosOutInedx("pos不合法");
}
this.elem[pos] = value;
}9.remove(int key)
作用：删除第一次出现的key。
首先，判断是否为空表，然后可以调用indexOf（key); 直接得到key的下标index，这时，要判断index是否合法，不合法也就是表内没有这个元素，那么什么都不做，直接return。合法就从index遍历到表尾，依次覆盖。
RT:
public void remove(int key) {
if(isEmpty()){
throw new PosOutInedx("空表");
}
int index = indexOf(key);
if(index == -1){
System.out.println("没这个元素捏");
return;
}
for (int i = index; i < this.usedSize - 1; i++) {
this.elem[i] = this.elem[i + 1];
}
this.usedSize--;
}10.size()
作用：求表长。
RT:
public int size() {
return this.usedSize;
}11.clear()
作用：清空。
RT:
public void clear() {
this.usedSize = 0;
}因为MyArrayList的函数都是基于usedSize值执行操作的，所以这里将usedSize置为0后，就达到了清空的效果。
三、ArrayList的使用
1.构造方法
ArrayList()
源码展示：
这其中 DEFAULTCAPACITY_EMPTY_ELEMENTDATA就是一个Object数组。
ArrayList(int )
源码：
ArrayList(Collection<? extends E> c)
这个构造方法用于，你想让构造的ArrayList用来接收继承与Collection接口的类，而这个类中的数据是继承与E的。
2.add()
当使用ArrayList（）构造顺序表后，实际上并没有开辟任何空间，只有当你第一次调用了add(int)后，类内部才会自行调用函数，开辟（grow）一个可以存放10个数据的空间。
3.常用操作，举🌰
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//1.add(E e)
list.add(1);
list.add(2);
list.add(3);
System.out.println("1、 "+list);
//2.add(int index,E e) 【index<=list.size()】
list.add(2,4);//在下标为3前插入e
System.out.println("2、 "+list);
//3.addAll(Collection<? extends E> c)
LinkedList<Integer> list2 = new LinkedList<>();
list2.add(4);
list2.add(5);
list.addAll(list2);
System.out.println("3、 "+list);
//4.remove(int index) 删除下标为index的元素
list.remove(1);
System.out.println("4、 "+list);
}运行结果：
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//1.add(E e)
list.add(1);
list.add(2);
list.add(3);
System.out.println("初始打印: "+list);
//5.remove(Object o) 删除遇到的第一个o
list.remove(2);
System.out.println("5、 "+list);
//6.get(int index) 获取下标为index的元素
System.out.println("6、 "+list.get(1));
//7.set(int index,E element) 将下标为index的元素，更新为element
list.set(0,3);
System.out.println("7、 "+list);
//8.contains(Object o) 是否包含
System.out.println("8、 "+list.contains(3));
//9.indexOf(Object o) 返回第一个 o 所在下标
// lastIndexOf(Object o) 返回最后一个o所在下标
System.out.println("9、 "+list.indexOf(2));
//10.subList(int fromIndex, int toIndex) 截取部分list
System.out.println("10、 "+list.subList(0,1));//左开右闭
}执行结果:
总结
提示：这里对文章进行总结：
例如：以上就是本文的全部内容，作者水平有限，如有错误，请谅解。
1051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
