【数据结构】【线性表】动态数组

1 前言

数组是一种顺序存储的线性表,所有元素的内存地址是连续的，在很多编程语言中,数组都有个致命的缺点，无法动态修改容量实际开发中,我们更希望数组的容量是可以动态改变的。在此，我们实现一个动态数组。

2 动态数组接口设计

/**
 * @Description: 线性表接口
 * @Auther: zhurongsheng
 * @Date: 2020/4/22 23:26
 */
public interface ZrsList<E> {

    /**
     * 元素数量
     */
    int size();

    /**
     * 是否为空
     */
    boolean isEmpty();

    /**
     * 是否包含
     */
    boolean contains(E element);

    /**
     * 添加元素
     */
    void add(E element);

    /**
     * 返回index位置对应的元素
     */
    E get(int index);

    /**
     * 设置index位置的元素，返回原来的元素
     */
    E set(int index, E element);

    /**
     * 在index位置添加元素
     */
    void add(int index, E element);

    /**
     * 删除index对应的元素
     */
    E remove(int index);

    /**
     * 查看元素的位置
     */
    int indexOf(E element);

    /**
     * 清除所有元素
     */
    void clear();
}

3 ZrsArrayList

/**
 * @Description: 动态数组
 * @Auther: zhurongsheng
 * @Date: 2020/4/22 23:25
 */
public class ZrsArrayList<E> implements ZrsList<E> {


    private int size;

    private Object[] elements;

    private static final int DEFAULT_CAPACITY = 10;


    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


    public ZrsArrayList(int capaticy) {
        if (capaticy == 0) {
            this.elements = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        } else if (capaticy > 0) {
            this.elements = new Object[capaticy];
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    capaticy);
        }
    }

    public ZrsArrayList() {
        this(DEFAULT_CAPACITY);
    }


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

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

    @Override
    public boolean contains(E element) {
        for (Object o : elements) {
            if (o.equals(element)) return true;
        }
        return false;
    }

    @Override
    public void add(E element) {
        ensureCapacityInternal(size + 1);
        elements[size++] = element;
    }

    private void ensureCapacityInternal(int minCapacity) {

        //如果最小值大于数组长度则需要扩容
        if (minCapacity - elements.length > 0) {
            if (elements == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                minCapacity = DEFAULT_CAPACITY;
            }
            int oldCapacity = elements.length;
            //扩容oldCapacity容量的1/2
            int newCapacity = minCapacity + (oldCapacity >> 1);
            //防止溢出
            if (newCapacity - oldCapacity < 0) {
                newCapacity = minCapacity;
            }
            //扩容
            elements = Arrays.copyOf(elements, newCapacity);
        }
    }

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

    @Override
    public E set(int index, E element) {
        rangeCheck(index);
        Object oldValue = elements[index];
        elements[index] = element;
        return (E) oldValue;
    }

    @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);
        System.arraycopy(elements, index, elements, index + 1,
                size - index);
        elements[index] = element;
        size++;
    }

    @Override
    public E remove(int index) {
        rangeCheck(index);
        Object oldValue = elements[index];
        int moved = size - index - 1;
        if (moved > 0) {
            System.arraycopy(elements, index + 1, elements, index,
                    moved);
        }
        elements[--size] = null;
        return (E) oldValue;
    }

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

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


    private void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }


    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }


    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

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

        return sb.toString();
    }
}

4 测试类

/**
 * @Description: 测试类
 * @Auther: zhurongsheng
 * @Date: 2020/4/22 23:56
 */
public class ArrayListTest {


    public static void main(String[] args) {
        ZrsList<Integer> lists = new ZrsArrayList<>();
        for (int i = 0; i < 10; i++) {
            lists.add(i);
        }
        lists.remove(2);
        System.out.println(lists.toString());
        lists.add(2, 2);
        System.out.println(lists.toString());
        System.out.println("size:" + lists.size());
    }


}

5 结果