【恋上数据结构与算法 第一季】动态数组ArrayList

---

持续学习&持续更新中…

---

线性表

数组

数组的随机访问

对象数组

null的处理

接口设计

public interface List<E> {

    int DEFAULT_CAPACITY = 10;
    int ELEMENT_NOT_FOUND = -1;

    int size();

    void add(E element); // 添加元素到最后面

    void add(int index, E element);

    boolean remove(E element);

    E remove(int index);

    E get(int index);

    E set(int index, E element);

    int indexOf(E element);

    boolean isEmpty();

    boolean contains(E element);

    void clear();
    
}

图示动态数组的设计

图示add

图示remove

图示扩容

代码实现

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

    private E[] elementData;
    private int size;

    public ArrayList(int capacity) {
        capacity = capacity < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capacity;
        elementData = (E[]) new Object[capacity];
    }

    public ArrayList() {
        this(DEFAULT_CAPACITY);
    }

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

    @Override
    public boolean add(E element) {
        add(size, element);
        return true;
    }

    @Override
    public void add(int index, E element) {
        if (null == element) {
        // 根据自己的需求，看能不能存null元素，该Array不支持存null元素
            System.out.println("不支持添加空元素");
            return;
        }
        rangeCheckForAdd(index);
        ensureArrayCapacity();
        for (int i = size; i > index; i--) {
            elementData[i] = elementData[i - 1];
        }
        elementData[index] = element;
        size++;
    }


    @Override
    public boolean remove(E element) {
        remove(indexOf(element));
        return true;
    }

    @Override
    public E remove(int index) {
        E e = get(index);
        for (int i = index; i < size - 1; i++) {
            elementData[i] = elementData[i + 1];
        }
        size--;
        elementData[size] = null;
        return e;
    }

    @Override
    public E get(int index) {
        rangeCheck(index);
        return elementData[index];
    }

    @Override
    public E set(int index, E element) {
        rangeCheck(index);
        E e = elementData[index];
        elementData[index] = element;
        return e;
    }

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

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

    @Override
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        size = 0;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Size:").append(size).append(" [");
        for (int i = 0; i < size; i++) {
            if (i != 0) sb.append(", ");
            sb.append(elementData[i]);
        }
        sb.append("]");
        return sb.toString();
    }

    private void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            arrayIndexOutOfBoundsException(index);
        }
    }

    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            arrayIndexOutOfBoundsException(index);
        }
    }

    private void arrayIndexOutOfBoundsException(int index) {
        throw new ArrayIndexOutOfBoundsException("index : " + index + " size : " + size);
    }

    private void ensureArrayCapacity() {
        if (elementData.length == size) {
            int capacity = elementData.length + (elementData.length >> 1);
            E[] newElementData = (E[]) new Object[capacity];
            for (int i = 0; i < size; i++) {
                newElementData[i] = elementData[i];
            }
            elementData = newElementData;
        }
    }

}

add的复杂度分析

动态数组的缩容

参考

小码哥李明杰老师课程: 恋上数据结构与算法 第一季.

---

本文完，感谢您的关注支持！

---