Java实现动态数组

Java实现动态数组

数组，线性结构，连续的存储空间，可存储大量同类型的数据，访问随机位置的元素效率高（索引），缺点，只能存储同类型数据，数组大小一旦确定不能修改，随机位置插入删除元素效率较低。

code一段代码，来完成一个最优的自定义数组

功能：查询数组容量，数组中实际元素个数，数组是否为空，是否包含指定元素，增（向指定位置添加元素，头部添加，末尾添加），删（删除指定位置上的元素并返回，删除指定值的元素），查（查询指定位置上的元素，查询指定元素的位置），改（修改指定位置上的元素的值，修改指定值的元素的值），类型支持，泛型设计，考虑数组的扩容和缩容，闲置对象的GC。

Java实现，代码如下：

package com.ljt.datastruct.day1;

/**
 * @Introductions 动态数组Java实现
 * @Author 寒山
 * @Date 2021/1/31 14:16
 * @Version 1.0
 */
public class ArrayList<E> {

    private E[] data; //容器
    private int size;   //容器中实际存放元素数量

    //初始化容器
    public ArrayList(int capacity) {
        data = (E[]) new Object[capacity];
    }

    public ArrayList() {
        this(10);
    }

    //查询数组容量
    public int getCapaCity() {
        return data.length;
    }

    //查询数组实际存放元素个数
    public int getSize() {
        return size;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //是否包含指定元素
    public boolean cantains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

    //向指定位置添加元素
    public void addElement(int index, E e) {
        //判断容器是否已满,如果实际存放元素个数等于数组容量，则容量扩大为原来的二倍
        if (size == data.length) {
            resize(data.length * 2);
        }
        //判断index合法性
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("非法索引");
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = e;
        size++;
    }

    //私有修改容量的方法
    private void resize(int size) {
        E[] newData = (E[]) new Object[size];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    //向头部添加元素
    public void addFirst(E e) {
        addElement(0, e);
    }

    //向末尾添加元素
    public void addLast(E e) {
        addElement(size, e);
    }

    //删除指定位置上的元素并返回
    public E removeElementByIndex(int index) {
        //判断index合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("非法索引");
        }
        E res = data[index];
        for (int i = index; i < size; i++) {
            data[i] = data[i + 1];
        }
        size--;
        data[size] = null;  //处理闲置对象
        //当实际存放元素个数少于数组容量的1/2时，容量缩小为原来的1/2
        if (size <= data.length / 2) {
            resize(data.length / 2);
        }
        return res;
    }

    //删除指定值的元素
    public void removeElementByValue(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                removeElementByIndex(i);
            }
        }
    }

    //查询指定位置上的元素
    public E valueOf(int index) {
        //判断index合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("非法索引");
        }
        return data[index];
    }

    //查询指定元素的位置,若不包含指定元素，则返回-1
    public int indexOf(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    //修改指定位置上的元素值
    public void setElementByIndex(int index, E e) {
        //判断index合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("非法索引");
        }
        data[index] = e;
    }

    //修改指定元素的值
    public void setElementByValue(E e1, E e2) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e1) {
                data[i] = e2;
            }
        }
    }

    //重写toString()
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("ArrayList:size = %d,capacity = %d\n", size, data.length);
        res.append("[");
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }
}