【数据结构】从顺序表到ArrayList类

1.线性表

1.1线性表的概念

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
如图所示：

2.顺序表

2.1顺序表的概念

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

2.2顺序表的实现

因为顺序表存储数据是在一段连续的物理地址依次存储的线性结构，我们一般采用数组的形式来进行存储，通过在数组中完成数据的增删查改的操作。
2.2.1数组的创建

public class MyArrayList {
//定义一个未被初始化的数组elem
    public int[] elem;
    //定义一个记录该数组存了多少容量
    public int size;
    //将该容量设置为一个常量，为了到后面调构造方法的时候初始化数组的大小
    public static final int DEFAULT_CAPACITY = 5;
    //调用构造函数的时候初始化数组的大小，而size成员变量不需要初始化，因为一开始未被初始化，默认初始化为0.
    public MyArrayList() {
        this.elem = new int[DEFAULT_CAPACITY];
    }
}

2.2.2提供一些接口

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();
     //判断是否空间满了
    boolean isFuul();
    boolean isEmpty();
}

2.2.3提供一些异常类
1.判断数组中是否为空的异常
2.判断下标是否合法的异常

//1.判断数组中是否为空的异常
public class EmptyException extends RuntimeException{
    public EmptyException() {
    }
    public EmptyException(String message) {
        super(message);
    }
}
//2.判断下标是否合法的异常
public class PosException extends RuntimeException{
    public PosException() {
    }
    public PosException(String message) {
        super(message);
    }
}

2.3接口的实现(对数组增删查改操作)

2.3.1 新增元素,(默认在数组最后新增)

 //往最后位置插入数据
    public void add(int data) {
        //判断空间是否满了，如果满了就扩容2倍
        if(isFuul()) {
            elem = Arrays.copyOf(elem,2*elem.length);
            System.out.println("扩容成功");
        }
        elem[size] = data;
        size++;
    }
    @Override
    public boolean isFuul() {
        return size == elem.length;
    }

2.3.2打印数组全部内容

//打印数组全部内容
    @Override
    public void display() {
        for (int i = 0; i < size; i++) {
            System.out.println(elem[i]);
        }
    }

2.3.3在 pos 位置新增元素

 // 在 pos 位置新增元素
    @Override
    public void add(int pos, int data) {
        //判断pos是否合法
        checkPosOfAdd(pos);
        //判断是否需要扩容
        if(isFuul()) {
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        //最后在pos位置插入新元素
        for(int i=size-1;i>=pos;i--) {
            elem[i+1] = elem[i];
        }
        elem[pos] = data;
        size++;
    }
    //判断pos是否合法的方法，在顺序表中插入数据的时候，插入的位置前面必须要有数据。
    private void checkPosOfAdd (int pos) {
        if(pos<0 || pos>size) {
            throw new PosException("pos的位置不合法:"+pos);
        }
    }

2.3.4判定是否包含某个元素

// 判定是否包含某个元素
    //直接遍历数组然后一一和目标元素比较，有就返回true，没有就返回false。
    @Override
    public boolean contains(int toFind) {
        for(int i=0;i< elem.length;i++) {
            if(toFind == elem[i]) {
                return true;
            }
        }
        return false;
    }

2.3.5查找某个元素对应的位置

// 查找某个元素对应的位置
    //直接遍历数组然后一一和目标元素比较，有就返回对应的下标，没有就返回-1。
    @Override
    public int indexOf(int toFind) {
        for(int i=0;i< elem.length;i++) {
            if(toFind == elem[i]) {
                return i;
            }
        }
        return -1;
    }

2.3.6 获取 pos 位置的元素 如果顺序表为空返回-1或者抛出异常，不为空返回pos位置的元素

// 获取 pos 位置的元素 如果顺序表为空返回-1或者抛出异常，不为空返回pos位置的元素
    @Override
    public int get(int pos) {
        //判断pos位置是否合法
        checkPosOfGet(pos);
        //判断这个顺序表是否为空
        if(isEmpty()) {
            throw new EmptyException("顺序表为空");
        }
        return elem[pos];
    }

2.3.7判断顺序表是否为空

 //判断顺序表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    //判断pos合不合法的方法
    private void checkPosOfGet (int pos) {
        if(pos<0 || pos>size) {
            throw new PosException("pos的位置不合法:"+pos);
        }
    }

2.3.8给 pos 位置的元素设为 value

 // 给 pos 位置的元素设为 value
    @Override
    public void set(int pos, int value) {
        //判断pos是否合法
        checkPosOfSet(pos);
        //判断顺序表是否为空
        if(isEmpty()) {
            throw new EmptyException("顺序表为空");
        }
        //修改pos位置的内容
        this.elem[pos] = value;
    }
    private void checkPosOfSet (int pos) {
        if (pos < 0 || pos > size) {
            throw new PosException("pos的位置不合法:" + pos);
        }
    }

2.3.9删除元素 如果顺序表中为空，则删不了，之后我们先找到我们要删的这个数。

//删除元素 如果顺序表中为空，则删不了，之后我们先找到我们要删的这个数。
    @Override
    public void remove(int toRemove) {
        //判断顺序表中是否为空
        if(isEmpty()) {
            throw new EmptyException("顺序表为空");
        }
        //找到我们需要删的这个数
        int indexof = indexOf(toRemove);
        for(int i = indexof;i<size-1;i++) {
            elem[i] = elem[i+1];
        }
        size--;
    }

2.3.10获取顺序表长度 直接返回size

// 获取顺序表长度 直接返回size
    @Override
    public int size() {
        return this.size;
    }

2.3.11清空顺序表

// 清空顺序表
    @Override
    public void clear() {
         size = 0;
    }

3.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底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

4. ArrayList使用

4.1ArrayList的构造

1.ArrayList() 无参构造：

List<Integer> list1 = new ArrayList<>();

2.ArrayList(int initialCapacity)指定顺序表初始容量:

List<Integer> list2 = new ArrayList<>(5);

3.ArrayList(Collection<? extends E> c) 利用其他 Collection 构建 ArrayList:相当于传入其他的ArrayList顺序表，使得这个顺序表的大小容量与数据类型和传入的顺序表是一致的。

List<Integer> list3 = new ArrayList<>(list2);

4.2 ArrayList的方法

4.2.1尾插法

public static void main(String[] args) {
        List<Integer> list2 = new ArrayList<>(5);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(5);
        System.out.println(list2);
    }

结果显示：

4.2.2将目标值插到指定index位置

 list2.add(1,6);
        System.out.println(list2);

结果显示：

4.2.3删除 index 位置元素

 list2.remove(2);
        System.out.println(list2);

结果显示：

4.2.4获取下标 index 位置元素

System.out.println(list2.get(3));

结果显示：

4.3 ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach。
1.for循环+下标：

 public static void main(String[] args) {
        List<Integer> list2 = new ArrayList<>(5);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(5);
        for (int i = 0; i < list2.size(); i++) {
            System.out.print(list2.get(i)+" ");
        }
    }

结果显示：

2.foreach：

public static void main(String[] args) {
        List<Integer> list2 = new ArrayList<>(5);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(5);
        System.out.println("foreach循环下：");
        for (Integer integer:list2) {
            System.out.print(integer+" ");
        }
    }

结果显示：

最后，ArrayList是一个动态类型的顺序表，不够空间会自动扩容。

好久没更新了，在这我向我的老铁们道个歉，从今天开始更新关于java的数据结构的内容，希望大家多多支持。🌹🌹🌹🌹🌹🌹🌹🌹🌹🌹🌹🌹🌹🌹