一起来学习ArrayList吧(●‘◡‘●)

实现ArrayList

线性表的定义：
零个或多个元素的有限序列

1. ai-1是ai的直接前驱
2. ai+1是i的直接后继
3. 除了第1个元素a1之外，其他元素都有唯一的直接前驱
4. 除了第n个元素an之外，其他元素都有唯一的直接后继

接口Interface

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);

    public E set(int index, E element);

    public int size();

    public int indexOf(E element);

    public boolean isEmpty();

    public boolean contains(E element);

    public void clear();

    public void sort(Comparator<E> c);

    public List<E> subList(int fromIndex, int toIndex);
}

ArrayList的实现

package Arraylist;
import 接口.List;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;

public class ArrayList<E> implements List<E> {
    private E[] data;//线性表存储元素的容器
    private int size;//线性表中元素的有效个数，也表示新来元素默认在尾部添加的角标
    private static int DEFAULT_CAPACITY = 10;//线性表默认容量

    //默认创建一个容量为DEFAULT_CAPACITY的线性表
    public ArrayList() {
        this(DEFAULT_CAPACITY);
    }

    //创建一个用户指定容量capacity的线性表
    public ArrayList(int capacity) {
        if (capacity < 0) {
            throw new IllegalArgumentException("initial capacity must >= 0");
        }
        data = (E[]) new Object[capacity];
        size = 0;
    }

    //将一个一维数组转换成线性表
    public ArrayList(E[] arr) {
        if (arr == null) {
            throw new IllegalArgumentException("initial arr can not be null");
        }
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
    }

    //在线性表的表尾添加一个元素element
    @Override
    public void add(E element) {
        add(size, element);
    }

    //在线性表中指定的index角标处添加一个元素element
    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("add index out of bounds");
        }
        //判断线性表是否已满
        if (size == data.length) {
            resize(data.length * 2);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = element;
        size++;

    }

    private void resize(int newLength) {
        //1.先创建一个新数组
        E[] newData = (E[]) new Object[newLength];
        //2.将原数组data的元素复制到新数组newData中
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    //删除线性表中指定的一个元素element O(n)
    @Override
    public void remove(E element) {
        //获取元素的位置
        int index = indexOf(element);//O(n)
        //判断元素的存在性，如果存在则根据角标删除元素
        if (index != -1) {
            remove(index);//O(n)
        }
    }

    //删除线性表中指定元素的角标处index的元素，并返回
    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("remove index out of bounds");
        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        //判断是否需要缩容,不需要缩绒的太厉害，至少保证一个最小值DEFAULT_CAPACITY
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    /*获取线性表中指定角标处index的元素
    * An = A1 + (n - 1)d
    *O(1)
    * */
    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of bounds");
        }
        return data[index];
    }

    /*在线性表中修改指定角标处index的元素为新的element,并返回原先的值
    * O(1)
    * */
    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("set index of bounds");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

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

    //获取线性表中数组的容量
    public int getCapacity() {
        return data.length;
    }
    //在线性表中查找指定元素的element角标，并返回
    //从左到右在第一次出现的的位置
    //如果元素不存在,则返回-1;

    @Override
    public int indexOf(E element) {
        for (int i = 0; i < size; i++) {
            if (element.equals(data[i])) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //在线性表中判断是否包含指定元素element
    @Override
    public boolean contains(E element) {

        return indexOf(element) != -1;
    }

    //清空线性表
    @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 can not be null");
        }
        int j = 0;
        E e = null;
        for (int i = 1; i < size; i++) {
            e = data[i];
            for (j = i; j > 0 && c.compare(data[j - 1], e) > 0; j--) {
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }

    //获取从fromIndex到toIndex区间的子线性表[fromIndex, toIndex]
    @Override
    public List<E> subList(int fromIndex, int toIndex) {

        if (fromIndex < 0) {
            throw new IndexOutOfBoundsException("fromIndex must >= 0");
        }
        if (toIndex >= size) {
            throw new IndexOutOfBoundsException("toIndex must < size");
        }
        if (fromIndex > toIndex) {
            throw new IndexOutOfBoundsException("formIndex must <= toIndex");
        }
        ArrayList<E> subList = new ArrayList<>();
        for (int i = fromIndex; i <= toIndex; i++) {
            subList.add(data[i]);//默认在表尾添加

        }

        return subList;
    }

    //比较两个线性表是否相等 长度相等，且内容相等
    @Override
    public boolean equals(Object obj) {
        //是否比的是自己
        if (this == obj) {
            return true;
        }
        //判断是否为空
        if (obj == null) {
            return false;
        }
        //判断obj是否和ArrayList是同一个类型
        if (getClass() != obj.getClass()) {
            return false;
        }
        //具体比较内容
        ArrayList other = (ArrayList) obj;
        //比的长度
        if (size != other.size) {
            return false;
        }
        //比的就是具体数组的内容
        return Arrays.equals(data, other.data);
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(String.format("ArrayList:%d/%d[", size, data.length));
        if (isEmpty()) {
            sb.append("]");
        } else {
            for (int i = 0; i < size; i++) {
                sb.append(data[i]);
                if (i != size - 1) {
                    sb.append(",");
                } else {
                    sb.append("]");
                }
            }
        }
        return sb.toString();
    }

    //获取ArrayList迭代器
    @Override
    public Iterator<E> iterator() {

        return new ArrayListIterator();
    }

    class ArrayListIterator implements Iterator<E> {
        private int cur = 0;

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

        //先把元素返回再后移
        @Override
        public E next() {
            return data[cur++];
        }
    }
}

测试

package test;

import Arraylist.ArrayList;
import java.util.Comparator;
import java.util.Random;
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println(list);
        Random random = new Random();

        for (int i = 0; i < 12; i++) {
            list.add(random.nextInt(30));
        }
        System.out.println(list);
        list.sort(new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);
    }
}

结果截图