数据结构之动态数组

一、仿ArrayList代码实现

package array;

import LinkedList.interfaces.List;

import java.util.Collection;
import java.util.Iterator;

public class ArrayList<T> implements List<T> {
    private Object[] elements;
    private static final int DEFAULT_CAPACITY = 10;
    private static final int OBJECT_NOT_FOUND = -1;
    private int size;

    public ArrayList(){
        elements = new Object[DEFAULT_CAPACITY];
    }

    public ArrayList(int capacity){
        if (capacity > 0) elements = new Object[capacity];
        else elements = new Object[DEFAULT_CAPACITY];
    }

    public ArrayList(Collection<T> collection){
        if (collection == null){
            throw new NullPointerException();
        }
        elements = collection.toArray();
    }

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

    /**
     * 获取指定索引处的元素
     * @param i 索引
     * @return T
     */
    @Override
    @SuppressWarnings("unchecked")
    public T get(int i) {
        if (indexToCheck(i)) {
            throw new IndexOutOfBoundsException("index: " + i);
        }
        return (T) elements[i];
    }

    /**
     * @MethodName: indexToCheck
     * @date: 2020/8/8 17:37
     * @author 索半斤
     * @Description: 判断索引是否合法
     */
    private boolean indexToCheck(int index) {
        return index < 0 || index >= size;
    }

    /**
     * @MethodName: isEmpty
     * @date: 2020/8/8 17:37
     * @author 索半斤
     * @Description: 判断集合是否为空
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * @MethodName: contains
     * @date: 2020/8/8 17:38
     * @author 索半斤
     * @Description: 判断集合中是否含有某个元素
     */
    @Override
    public boolean contains(T e) {
        return indexOf(e) >= 0;
    }

    /**
     * @MethodName: indexOf
     * @date: 2020/8/8 17:39
     * @author 索半斤
     * @Description: 获取元素索引
     */
    @Override
    public int indexOf(T e) {
        elementsAndValueCheck(e);
        int tempIndex = 0;
        for (Object element : elements) {
            if (element == e || e.equals(element)) {
                return tempIndex;
            }
            tempIndex++;
        }
        return OBJECT_NOT_FOUND;
    }


    /**
     * @MethodName: add
     * @date: 2020/8/8 17:44
     * @author 索半斤
     * @Description: 指定位置添加元素
     */
    @Override
    public boolean add(int i, T e) {
        if (e == null) {
            throw new NullPointerException("Value is Null");
        }
        if (checkCapacity()) {
            addCapacity();
        }
        for (int j = size; j >= i+1 ; j--) {
            elements[j] = elements[j-1];
        }
        elements[i] = e;
        size++;
        return true;
    }

    /**
     * @MethodName: checkCapacity
     * @date: 2020/8/8 17:44
     * @author 索半斤
     * @Description: 判断数组容量
     */
    private boolean checkCapacity() {
        return size >= (elements.length / 2);
    }

    /**
     * @MethodName: addCapacity
     * @date: 2020/8/8 17:44
     * @author 索半斤
     * @Description: 扩容
     */
    private void addCapacity() {
        Object[] newElements = new Object[(elements.length + elements.length / 2)];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
    }

    /**
     * @MethodName: add
     * @date: 2020/8/8 17:45
     * @author 索半斤
     * @Description: 添加元素
     */
    @Override
    public boolean add(T e) {
        if (e == null){
            throw new NullPointerException("Value is Null");
        }
        add(size, e);
        return true;
    }

    /**
     * @MethodName: addBefore
     * @date: 2020/8/8 18:13
     * @author 索半斤
     * @Description: 在指定元素之前添加
     */
    @Override
    public boolean addBefore(T obj, T e) {
        if (size == 0){
            throw new IndexOutOfBoundsException();
        }
        if (obj == null) throw new NullPointerException();
        if (e == null) throw new NullPointerException();
        int index = indexOf(obj);
        if (index == OBJECT_NOT_FOUND) return false;
        add(index, e);
        return true;
    }

    /**
     * @MethodName: addAfter
     * @date: 2020/8/8 18:13
     * @author 索半斤
     * @Description: 在某元素之后添加
     */
    @Override
    public boolean addAfter(T obj, T e) {
        if (size == 0){
            throw new IndexOutOfBoundsException();
        }
        if (obj == null) throw new NullPointerException();
        if (e == null) throw new NullPointerException();
        for (int i = 0; i < size; i++) {
            if (obj == elements[i] || obj.equals(elements[i])){
                add(i+1, e);
                break;
            }
        }
        return true;
    }


    /**
     * @MethodName: remove
     * @date: 2020/8/8 18:30
     * @author 索半斤
     * @Description: 按照索引移除元素
     */
    @Override
    @SuppressWarnings("unchecked")
    public T remove(int i) {
        if (size == 0 || indexToCheck(i)) {
            throw new IndexOutOfBoundsException("index: " + i);
        }
        T oldObject = (T) elements[i];
        for (int j = i; j <= size - 2; j++) {
            elements[j] = elements[j + 1];
        }
        size--;
        return oldObject;
    }

    /**
     * @MethodName: remove
     * @date: 2020/8/8 18:31
     * @author 索半斤
     * @Description: 按照元素移除元素
     */
    @Override
    public boolean remove(T e) {
        elementsAndValueCheck(e);
        int tempIndex = 0;
        for (Object element : elements) {
            if (element == e || e.equals(element)) {
                return remove(tempIndex) != null;
            }
            tempIndex++;
        }
        size--;
        return false;
    }

    /**
     * @MethodName: replace
     * @date: 2020/8/8 18:31
     * @author 索半斤
     * @Description: 替换指定索引位置的元素
     */
    @Override
    @SuppressWarnings("unchecked")
    public T replace(int i, T e) {
        if(indexToCheck(i)){
            throw new IndexOutOfBoundsException();
        }
        if (e == null) throw new NullPointerException();
        T oldObject = (T) elements[i];
        elements[i] = e;
        return oldObject;
    }

    /**
     * @MethodName: clear
     * @date: 2020/8/8 18:32
     * @author 索半斤
     * @Description: 清空元素
     */
    @Override
    public boolean clear() {
        if (size == 0) return true;
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
        return true;
    }

    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{
        private int index = 0;
        @Override
        public boolean hasNext() {
            return index != size;
        }

        @Override
        @SuppressWarnings("unchecked")
        public T next() {
            T object = (T) elements[index];
            index++;
            return object;
        }
    }

    /**
     * @MethodName: toArray 
     * @date: 2020/8/8 18:33
     * @author 索半斤
     * @Description: 转换为数组
     */
    @SuppressWarnings("unchecked")
    public T[] toArray(){
        Object[] objects = new Object[size];
        for (int i = 0; i < size; i++) {
            objects[i] = elements[i];
        }
        return (T[])objects;
    }

    private void elementsAndValueCheck(T e) {
        if (size == 0) {
            throw new IndexOutOfBoundsException();
        }
        if (e == null) {
            throw new NullPointerException("value is null");
        }
    }

}