4.ArrayList与顺序表

---

---

1.线性表

线性表是n个具有相同特性的数据元素的有限序列。线性表在逻辑上是线性结构，但在物理结构上并不一定连续，在物理上存储时，通常以数组和链式结构的形式存储。
常见的线性表有：顺序表、链表、栈、队列、字符串…

2.顺序表

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

2.1接口的实现

> public class SeqList {
// 打印顺序表
public void display() { }
// 新增元素,默认在数组最后新增
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() { }
}

具体代码如下：

package sqlist;

import java.util.Arrays;

public class MyArraylist {

    public int[] elem;
    public int usedSize;

    public MyArraylist() {
        this.elem = new int[10];
    }

    // 打印顺序表
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }

    /**判断数组是否满，要不要扩容？
     *
     * @return true 满，扩容；false 未满
     */
    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }
    // 新增元素,默认在数组最后新增
    public void add(int data) {
        if(isFull()) {
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

    private boolean checkPosInAdd(int pos) {
        if(pos<0 || pos>this.usedSize) {
            System.out.println("pos位置不合法");
            return false;
        }
        return true;
    }

    /** 在 pos 位置新增元素
     *
     * @param pos 注意pos位置的合法性
     * @param data
     */
    public void add(int pos, int data) {
        if(!checkPosInAdd(pos)) {
            System.out.println("pos位置不合法");
            return;
        }
        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++;
    }

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

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

    private boolean checkPosInGet(int pos) {
        if(pos<0 || pos>=this.usedSize) {
            return false;
        }
        return true;
    }
    private boolean isEmpty() {
        return this.usedSize == 0;
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        if (!checkPosInGet(pos)) {
            throw new MyArraylistIndexOutOfException("获取pos下标时，位置不合法");
        }
        if(isEmpty()) {
            throw new MyArraylistEmptyException("获取元素的时候，顺序表为空！");
        }
        return this.elem[pos];
    }
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        if(!checkPosInGet(pos)) {
            throw new MyArraylistIndexOutOfException("pos下标位置不合法");
        }
        this.elem[pos] = value;
    }
    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(isEmpty()) {
            throw new MyArraylistEmptyException("删除元素的时候，顺序表为空！");
        }
        if(contains(toRemove)) {
            int index = indexOf(toRemove);
            for (int i = index; i < this.usedSize; i++) {
                this.elem[i] = this.elem[i+1];
            }
            //elem[this.usedSize] = null;如果是引用类型需要将删除的空间进行回收
            this.usedSize--;
        }
        else {
            System.out.println("顺序表中没有该元素!");
        }
    }
    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }
    // 清空顺序表
    public void clear() {
        /*
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        如果是引用数据类型，需要一个一个置为空
        this.useSize = 0；
        */
        this.usedSize = 0;
    }

    public static void main(String[] args) {
        MyArraylist myArraylist = new MyArraylist();
        myArraylist.add(0,1);
        myArraylist.add(1,3);
        myArraylist.add(2,4);
        myArraylist.display();
        myArraylist.add(1,2);
        myArraylist.display();
        myArraylist.add(0,999);
        myArraylist.display();
        myArraylist.add(1999);
        myArraylist.display();
        myArraylist.set(0,1999);
        myArraylist.display();
        myArraylist.remove(1999);
        myArraylist.display();
        myArraylist.clear();
        System.out.println("===============");
        myArraylist.display();
        System.out.println("1");

    }
}

运行结果如图:

3.ArrayList的使用

3.1ArrayList的构造

package sqlist;

import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("1.无参构造");
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(1);
        arrayList1.add(2);
        arrayList1.add(3);
        System.out.println(arrayList1.size());
        System.out.println(arrayList1.get(1));;
        System.out.println(arrayList1);
        System.out.println("==================");
        System.out.println("2.利用其他collection构造arraylist");
        ArrayList<Integer> arrayList2 = new ArrayList<>(arrayList1);
        arrayList1.add(99);
        arrayList1.add(199);
        System.out.println(arrayList2);
        System.out.println("==================");
        System.out.println("3.指定顺序表初始容量");
        ArrayList<Integer> arrayList3 = new ArrayList<>(10);
    }

}

运行结果如图：

问题：无参构造方法的时候，数组的默认大小是多少？

答案：0，

第一次add的时候，我们底层的数组大小才变成了10，注意理解源码中的grow扩容机制，1.5倍扩容。

3.2 ArrayList的常见操作

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)	截取部分 list，区间左开右闭

注意1： 当使用remove（Object o）方法删除遇到的第一个o时，需要传的是一个对象。
例如要删除一个整数时，可以写为 arraylist.remove(new Interger（10）);
注意2：当使用List subList(int fromIndex, int toIndex)| 截取部分 list时，是在本身上截取的
此处并不是新建了一个对象，而是返回截取后起始位置的地址。

3.3ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("使用下标+for遍历");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        System.out.println("借助foreach遍历");
        for (Integer integer : list) {
            System.out.print(integer + " ");
        }
        System.out.println();
        System.out.println("使用迭代器遍历");
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }

运行结果如下：

4.思考：

1. 顺序表中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
   思考： 如何解决以上问题呢？

如果你需要频繁的查找数据的时候，顺序表的使用会多一点，如果你需要频繁的插入和删除数据，随用随取，那么顺序表就不合适了，就要用到我们接下来需要学习的 链表LinkedList