动态数组----线性表的实现

Java数组的特点： 1>. 数组的长度一旦确定则不可更改

                               2>. 数组只能存储同一类型的数据

                               3>. 数组中每个存储空间地址是连续且相等的

                               4>. 数组提供角标的方式访问元素

Java数组的缺点： 1>. 长度不可变，如果容量不够只能扩容，而扩容实质是创建新的数组 

                               2>. 增删数组的元素操作复杂

                               3>. 数组只有length这个属性，没有其他的方法

因此我们可以引入动态数组。

线性表的定义：

 如图：1>. a1 是 a2 的直接前驱

            2>. a3 是 a2 的直接后继

            3>. 除了第1个元素a1 之外，其他元素都有唯一的直接前驱

            4>. 除了第n个元素an 之外，其他元素都有唯一的直接后继

            5>. n表示线性表的长度，当n=0时，称为空表

我们通过定义一个List接口，接口中写入增删改查等方法，通过实现类来实现。这样就可以实现线性表。

自定义List接口的实现：

public interface List<E> extends Iterable<E> {
    //默认在队尾添加元素
    public void add(E element);
    //在指定角标处添加元素
    public void add(int index, E element);
    //删除指定元素
    public void remove(E element);
    //删除指定角标处的元素 并返回
    public E remove(int index);
    //获取指定角标处的元素
    public E get(int index);
    //修改指定角标处的元素的值为element 并返回原先的值
    public E set(int index, E element);
    //获取线性表中元素的个数
    public int size();
    //查看元素第一次出现的角标位置
    public int indexOf(E element);
    //判断线性表是否包含指定元素
    public boolean contains(E element);
    //判断线性表是否为空
    public boolean isEmpty();
    //清空线性表中的元素
    public void clear();
    //对线性表中的元素进行排序 按照比较器的内容进行排序
    public void sort(Comparator<E> c);
    //获取子线性表 原线性表中[fromIndex, toIndex]这个部分的元素
    public List<E> subList(int fromIndex, int toIndex);
}

 我们定义一个ArrayList类来实现List接口 实现线性表：

public class ArrayList<E> implements List<E> {

    private E[] data; //定义存放数据的线性表

    private int size; //线性表中的有效元素的个数

    private static int DEFAULT_CAPACITY = 10; //线性表的默认长度

    //定义无参的构造方法
    public ArrayList(){
        data = (E[]) new Object[DEFAULT_CAPACITY]; //初始化线性表 默认长度为DEFAULT_CAPACITY
        size = 0;
    }

    //定义指定默认线性表长度的带参构造
    public ArrayList(int capacity){
        if(capacity <= 0){
            throw new IllegalArgumentException("capacity must >0");
        }
        DEFAULT_CAPACITY = capacity;
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    //定义
    public  ArrayList(E[] arr){
        if(arr == null || arr.length == 0){
            throw new IllegalArgumentException("arr is not null");
        }
        data = (E[]) new Object[DEFAULT_CAPACITY];
        for(int i = 0; i < arr.length; i++){
            add(arr[i]);
        }
    }

    //向表尾添加元素
    @Override
    public void add(E element) {
        add(size, element);
    }

    //向指定位置添加元素
    @Override
    public void add(int index, E element) {
        //判断索引是否正确
        if(index < 0 || index > size){
            throw new IllegalArgumentException("add index out of range");
        }
        //判断是否需要扩容 当有效元素个数等于线性表长度时 表示线性表已满 就要扩容
        //扩容为原线性表长度的两倍
        if(size == data.length){
            resize(2 * data.length);
        }
        //后移元素
        for (int i = size - 1; i >= index; i--){
            data[i + 1] = data[i];
        }
        //将指定元素插入到线性表中指定位置
        data[index] = element;
        size++;
    }

    //移除线性表中指定元素
    @Override
    public void remove(E element) {
        int index = indexOf(element);
        remove(index);
    }

    //移除线性表中指定位置的元素
    @Override
    public E remove(int index) {
        //判断索引是否正确
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("remove index out of bound");
        }
        //取出要删除的index位置的元素
        E ele = data[index];
        //前移index之后的元素
        for(int i = index + 1; i < size; i++){
            data[i - 1] = data[i];
        }
        size--;
        //判断是否需要缩容 当有效元素个数小于等于线性表长度的四分之一时 进行缩容 但是线性表长度始终不能小于默认长度
        //缩容为原线性表长度的一半
        if(size <= data.length / 4 && data.length > DEFAULT_CAPACITY){
            resize(data.length / 2);
        }
        return ele;
    }

    //对线性表进行缩容 / 扩容
    private void resize(int newLength) {
        E[] newData = (E[]) new Object[newLength];
        for(int i = 0; i < size; i++){
            newData[i] = data[i];
        }
        data = newData;
    }

    //获取指定位置的元素
    @Override
    public E get(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        return data[index];
    }

    //修改指定位置元素的内容
    @Override
    public E set(int index, E element) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        E ele = data[index];
        data[index] = element;
        return ele;
    }

    //获取线性表有效元素的个数
    @Override
    public int size() {
        return size;
    }

    //获取线性表的容量
    public int capacity(){
        return data.length;
    }

    //获取线性表中指定元素的下标
    @Override
    public int indexOf(E element) {
        for (int i = 0; i < size; i++){
            if(data[i].equals(element)){
                return i;
            }
        }
        return -1;
    }

    //判断线性表中是否包含指定元素
    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    //判断线性表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //清空线性表中元素
    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    //对表进行排序
    @Override
    public void sort(Comparator<E> c) { //插入排序的思想
        if(c == null){ //判断比较器是否为空
            throw new IllegalArgumentException("comparator is not be null");
        }
        for (int i = 0; i < size; i++){
            E e = data[i];
            int j = 0;
            for(j = i; j >= 1 && c.compare(data[j - 1], e) > 0; j--){
                data[j] = data[j - 1]; //将满足条件的元素后移 将e插入到j位置
            }
            data[j] = e;
        }
    }

    //获取子列表 从fromIndex到toIndex 包括fromIndex，toIndex
    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        ArrayList<E> list = new ArrayList<E>();
        for (int i = fromIndex; i <= toIndex; i++){
            list.add(data[i]);
        }
        return list;
    }

    //判断当前表 与指定表是否相等
    @Override
    public boolean equals(Object o) {
        //1.先判空
        if(o == null){
            return false;
        }
        //2.判断是否是自己
        if(this == o){
            return true;
        }
        //3.判断类型
        if(o instanceof ArrayList){
            ArrayList other = (ArrayList) o;
            //判断元素个数是否相同
            if(size != other.size){
                return false;
            }
            //如果以上都相同 判断内容是否相同
            for (int i = 0; i < size; i++){
                if(!data[i].equals(other.data[i])){
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    //规定线性表输出的格式
    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        str.append("ArrayList: " + size + "/" + data.length + " [");
        if(isEmpty()){
            str.append(']');
        }
        for (int i = 0; i < size; i++){
            str.append(data[i]);
            if(i == size - 1){
                str.append(']');
            }else{
                str.append(',');
                str.append(' ');
            }
        }
        return str.toString();
    }

    //获取当前这个数据结构/容器 的 迭代器
    //通过迭代器对象 更方便挨个取出每一个元素
    //同时 实现了Iterable 可以让当前的数据结构/容器 被foreach循环遍历
    @Override
    public Iterator iterator() {
        return new ArrayListIterator();
    }

    //创建一个属于ArrayList的迭代器
    class ArrayListIterator implements Iterator<E> {

        private int cur = 0;

        @Override
        public boolean hasNext() { //判断是否有下一个元素
            return cur < size;
        }

        @Override
        public E next() { //返回当前元素 并指向下一个元素
            return data[cur++];
        }
    }
}