使用java实现动态数组（有注释，适合Java初学者阅读理解数据的操作）

java实现动态数组

数组的概念

    在Java语言中数组是被用来存储元素（对象）的一种常用的容器，说白了就是放元素的，并且提供了一系列的方法供使用者使用数组中的元素。但是Java原生的数组不是动态的，数组大小  在数组初始化的时候必须要初始化，也就是说大小是固定的，当然Java为我们提供了集合来补充了数组的缺点，今天我们要说的是自己实现一个类似于ArrayList集合的工具类来帮助我们理  解Java中的数组和ArrayList（这是我自己理解的，官方的概念可以自行百度哈，有不正确的地  方希望多多包涵啦）。

让我们来看代码 （注释很详细）

package com.example.demo.array;

import java.util.Objects;

/**
 * my array util
 */
public class MyArray<T> {
    private T[] array;
    private int size;

    public MyArray() {
        this(10);
    }

    public MyArray(int capacity) {
        this.size = 0;
        this.array = (T[])new Object[capacity];
    }

    /**
     * get array size.
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * get array capacity.
     *
     * @return
     */
    public int getCapacity() {
        return array.length;
    }

    /**
     * add 操作.
     *
     * @param index
     * @param ele
     */
    public void add(int index, T ele) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Require index>=0 and index <=size");
        // 如果size(从0开始递增，没增加一个元素size++) 等于数据的长度(length从初始化的时候就是定的，再次扩容后增加为上一次length的2倍)的话，进行扩容
        System.out.println(index+"::"+array.length);
        if(size==array.length)
            resize(2*array.length);
        /**
         * 把index位置后面以及后面的元素都想后移一位.
         */
        for (int i = size - 1; i >= index; i--) {
            array[i + 1] = array[i];
        }
        array[index] = ele;
        size++;
    }

    /**
     * 首部添加.
     *
     * @param ele
     */
    public void addFirst(T ele) {
        this.add(0, ele);
    }

    /**
     * 尾部添加.
     *
     * @param ele
     */
    public void addLast(T ele) {
        this.add(size, ele);
    }

    /**
     * Get a array element.
     *
     * @param index
     * @return
     */
    public T get(int index) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed. index is Illegal");
        return array[index];
    }

    /**
     * replace a array element by index.
     *
     * @param index
     * @param ele
     */
    public void set(int index, T ele) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Set failed. index is Illegal");
        array[index] = ele;
    }



    /**
     * 是否包含.
     *
     * @param value
     * @return true or false
     */
    public boolean contains(T value) {
        for (int i = 0; i < size; i++) {
            if (array[i].equals(value))
                return true;
        }
        return false;
    }

    /**
     * 查找。
     *
     * @param value 需要查找的元素
     * @return 返回查找到的索引
     */
    public int find(T value) {
        for (int i = 0; i < size; i++) {
            if (array[i].equals(value))
                return i;
        }
        return -1;
    }

    /** 删除数据中其中一个元素
     * @param index
     * @return
     */
    public T remove(int index) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed.index Illegal");
        T ret = array[index];
        //从index开始后面的所有元素都向前移动一个位置
        for (int i = index; i < size; i++) {
            array[i] = array[i + 1];
        }
        size--;
        // 便于垃圾回收，把引用置位空
        array[size]=null;
        return ret;
    }

    /**
     * 移除数组中的第一个元素，调用remove方法即可
     * @return
     */
    public T removeFirst() {
        return remove(0);
    }

    /**
     * 移除最后一个，也是调用remove方法
     * @return
     */
    public T removeLast() {
        return remove(size - 1);
    }

    /**
     * remove，removeFirst，removeLast都是根据数据下标索引来进行移除，removeElement 根据元素是否在数据中存在进行移除（只会移除第一个找到的元素）
     * @param e
     * @return
     */
    public boolean removeElement(T e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
            return true;
        }
        return false;
    }

    /**
     * 对数组进行扩容（简单扩容，可以看下ArrayList的扩容的，使用Arrays.copyOf()方法进行扩容）
     * @param newCapacity 新的容量
     */
    private void resize(int newCapacity){
        T[] newArray = (T[])new Object[newCapacity];
        for (int i=0;i<size;i++){
            newArray[i]=array[i];
        }
        array = newArray;
    }
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array:size = %d,capacity = %d\n", size, array.length));
        builder.append('[');
        for (int i = 0; i < size; i++) {
            builder.append(array[i]);
            if (i != size - 1) {
                builder.append(',');
            }
        }
        builder.append(']');
        return builder.toString();
    }
    public static void main(String[] args) {
        MyArray<Integer> array = new MyArray<>();
        for (int i = 0; i < 10; i++) {
            array.addLast(i);
        }
        System.out.println(array);
        array.add(1, 100);
        System.out.println(array);
        array.addFirst(-1);
        System.out.println(array);
        array.set(0,-2);
        System.out.println(array);
        Integer element = array.get(0);
        System.out.println(element);
    }
}

   

以上就是我使用Java代码实现动态数组的代码，亲测可用，自己动手实现一遍，可以加深对数据，arrayList的理解和使用能力，有问题欢迎给我留言，或者加作者QQ（958302506）来探讨