【数据结构与算法】1、java中的数组并使用泛型改进数组二次封装

在java中，数组里的元素是同一种类型，内存中存储连续，有下标。

一、java中数组的初始化及遍历

初始化方式一
元素类型[] 数组名 = new 元素类型[元素个数];
int[] array = new array[10];

初始化方式二
元素类型[] 数组名 = new 元素类型[]{元素1，元素2，...}
int[] array = new int[]{1,2,3}
int[] array = {1,2,3}

由此可见数组的长度是固定的，两种遍历数组示例：

    int[] arr = {1,2,3,4};
    for(int i=0; i<arr.length; i++) {
        System.out.println(arr[i]);
    }
    
    for (int item : arr) {
        System.out.println(item);
    }

二、实现自己的数组，可以添加删除元素

现在先实现一个自己的数组，可以有基本的添加、删除操作：

public class MyArray {
    private int[] data; // 用来存放元素
    private int size;  // 数组的实际长度

    public MyArray(int capacity) {
        data = new int[capacity];
        size = 0;
    }
    
    public MyArray() {
        data = new int[10];
        size = 0;
    }

    public int getSize() {
        return size;
    }
    // 获取指定位置上的元素
    public int getByIndex(int index) {
        if(index > size) {
            throw new IllegalArgumentException("超出范围");
        }
        return data[index];
    }

    // 在指定位置上插入元素
    public void add(int index, int e) {
        if(size == data.length) {
            throw new IllegalArgumentException("添加失败，数组已满");
        }
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size ++;
    }

    // 在数组末尾添加元素
    public void append(int e) {
        add(size, e);
    }

    // 在指定index上删除元素
    public void 4(int index) {
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        size--;
    }
}

三、当数组已满时可动态扩容

在上面add(int index, int e)函数中，如果数组容量已用满时再插入元素就会报错，那么现在我把通过扩容来替代报错。扩容函数如下：

     // 参数：扩容/缩容 后的容量大小
    private void resize(int newCapacity) {
        int[] newData = new int[newCapacity];
        for(int i = 0; i < size; i ++) {
            newData[i] = data[i];
        }
        data = newData;
    }

有了resize()函数，那么就可以把数组改成动态数组，

    // 在指定位置上插入元素
    public void add(int index, int e) {
        if(size == data.length) {
            resize(2 * size); // 扩容
        }
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size ++;
    }
    
    // 在指定index上删除元素
    public void del(int index) {
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        size--;
        if(size == data.length / 2 && data.length / 2 != 0) {
            resize(size); // 缩容
        }
    }

四、支持泛型

再进一步改进，使数组支持泛型，把int该为E，由于java不支持直接生命E[]的数组，要绕个弯先声明为Object类型再强制转换成E类型,
data = (E[]) new Object[capacity];

全部代码如下：

public class MyArray<E> {
    private E[] data; // 用来存放元素
    private int size;  // 数组的实际长度

    public MyArray(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    public MyArray() {
        data = (E[]) new Object[10];
        size = 0;
    }

    public int getSize() {
        return size;
    }
    // 获取指定位置上的元素
    public E getByIndex(int index) {
        if(index > size) {
            throw new IllegalArgumentException("超出范围");
        }
        return data[index];
    }

    // 在指定位置上插入元素
    public void add(int index, E e) {
        if(size == data.length) {
            resize(2 * size); // 扩容
        }
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size ++;
    }

    // 在数组末尾添加元素
    public void append(E e) {
        add(size, e);
    }

    // 在指定index上删除元素
    public void del(int index) {
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("index参数错误");
        }
        for(int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        size--;
        if(size == data.length / 2 && data.length / 2 != 0) {
            resize(size); // 缩容
        }
    }

    // 参数：扩容/缩容 后的容量大小
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for(int i = 0; i < size; i ++) {
            newData[i] = data[i];
        }
        data = newData;
    }
}