手写ArrayList

定义接口:

/**
 * List是线性结构的接口
 * 里面定义了该线性结构的一些通用操作
 * 并支持泛型
 * 继承自Iterable（可迭代接口） 主要用于遍历数据结构
 * 其次还有让我们的类可以被foreach循环使用
 * 不是所有的数据结构都可以像我们数组一样通过角标来访问元素
 */
public interface List<E> extends Iterable<E> {
    /**
     * 在线性结构的末尾添加一个元素element
     * @param element
     */
    public void add(E element);

    /**
     * 在线性结构指定角标（index）出添加一个元素element
     * @param index
     * @param element
     */
    public void add(int index,E element);

    /**
     * 在线性结构中删除指定元素element
     * @param element
     */
    public void remove(E element);

    /**
     * 在线性结构中删除指定角标index，并返回
     * @param index
     * @return
     */
    public E remove(int index);

    /**
     *在线性结构中获取指定角标处index的元素
     * @param index
     * @return
     */
    public E get(int index);

    /**
     *在线性结构中修改指定角标处index的元素为新元素element
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element);

    /**
     *获取线性结构中有效元素的个数
     * @return
     */
    public int size();

    /**
     * 获取指定元素element在线性结构中的角标
     * @param element
     * @return
     */
    public int indexOf(E element);

    /**
     * 查看线性表中是否包含指定元素element
     * @param element
     * @return
     */
    public boolean contains(E element);

    /**
     * 查看线性结构是否为空
     * @return
     */
    public boolean isEmpty();

    /**
     * 清空线性结构
     */
    public void clear();

    /**
     * 对线性结构按照比较器comparator的定义来进行排序
     * @param comparator
     */
    public void sort(Comparator<E> comparator);

    /**
     * 获取线性结构中从指定fromIndex角标开始到toIndex角标结尾的所有元素
     * (0 <= fromIndex < toIndex < size)
     * [fromIndex,toIndex)
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public List<E> sublist(int fromIndex,int toIndex);

}

实现类:

public class ArrayList<E> implements List<E> {
    //存储元素的容器
    private E[] data;
    //元素的有效个数
    private int size;
    //默认容量大小
    private static int DEFAULT_CAPACITY = 10;

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

    /**
     * 创建一个容量为指定值capacity的线性表
     *
     * @param capacity
     */

    public ArrayList(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException("initial capacity must > 0");
        }
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 将一个现有的数组封装成一个线性表
     *
     * @param arr
     */
    public ArrayList(E[] arr) {
        if (arr == null) {
            throw new IllegalArgumentException("initial arr can not be null");
        }
        data = (E[]) new Object[arr.length];
        size = 0;
        for (E e : arr) {
            add(e);
        }
    }
	
	//默认在末尾添加元素
    @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 must 0 <= index <= size");
        }
        //是否满了
        if (size == data.length) {
            //扩容
            resize(data.length * 2);
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }

    /**
     * 扩容
     *
     * @param newLength
     */
    private void resize(int newLength) {

        E[] newData = (E[]) new Object[newLength];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    /**
     * 删除指定元素
     *
     * @param element
     */
    @Override
    public void remove(E element) {
        int index = 0;
        while ((index = indexOf(element)) != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index must 0 < index and size < index");
        }
        E ret = data[index];
        for (int i = index; i <= size - 2; i++) {
            data[i] = data[i + 1];
        }
        size--;
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index outof range");
        }
        return data[index];
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index outof range");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @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> comparator) {
        if (comparator == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }
        //插入排序 O(n^2)
        for (int i = 1; i < size; i++) {
            E e = data[i];
            int j;
            for (j = i; j > 0 && (comparator.compare(data[j - 1], e)) > 0; j--) {
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }


    @Override
    public String toString() {
        //"[1,2,3,5,6,7,8,9]" Arrays.toString()
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        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();
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null){
            return false;
        }
        if( obj == this){
            return true;
        }
        if(obj instanceof ArrayList){
            ArrayList<E> other = (ArrayList<E>) obj;
            if(this.size == other.size){
                for (int i = 0; i < this.size; i++) {
                    if(!this.data[i].equals(other.data[i])){
                        return false;
                    }
                }
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }


    @Override
    public List sublist(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex >= toIndex) {
            throw new IllegalArgumentException("sublist index outof range");
        }
        ArrayList<E> list = new ArrayList<>();
        for (int i = fromIndex; i < toIndex; i++) {
            list.add(data[i]);
        }
        return list;
    }

    //返回迭代器对象
    @Override
    public Iterator iterator() {
        return new ArrayListIterator();
    }
    private class ArrayListIterator implements Iterator<E>{
        private int cur = 0;
        @Override
        public boolean hasNext() {
            return cur < size;
        }

        @Override
        public E next() {
            return data[cur++];
        }
    }

    public void swap(int i ,int j){
        E tem = data[i];
        data[i] = data[j];
        data[j] = tem;
    }
}