静态数组类的封装（泛型）

泛型是指“任意”种类型

这里的任意不包含8种基本数据类型，是能类对象
但是我们可以使用每种数据类型对应的包装类
boolean->Boolean
byte ->Byte
char->Character
short->Short
int->Integer
long->Long
float->Float
double->Double

如过想要定义数组的泛型，可以在定义类的时候，加上一个<>,里面加上我们想要的类型，比如

public class ArrayF<E>

然后，跟之前定义int类型数组的方法一样，我们只要把方法里对应类型改为相应的类型即可。另外要注意的是，我们在进行数组内容比较的时候，由于我们是对数组内容进行比较，我们最好采用equals的方法进行比较，避免发生错误。

具体实现代码和之前的差不多，略微做了修改：

public class ArrayF<E>{
    // 成员变量
    private E[] data;
    private int size;

    // 有参构造,传入数组的容量capacity
    public ArrayF(int capacity){
        data = (E[])new Object[capacity];  // 强制类型转换
        size=0;
    }

    // 无参构造，默认容量是10
    public ArrayF(){
        this(10);
    }

    // 获取数组的元素个数
    public int getSize(){
        return size;
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

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

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

    // 在数组的第一个位置添加元素e
    public void addFirst(E e){
        add(0,e);
    }

    // 向指定index的位置添加元素e
    public void add(int index,E e){
        if(size == data.length){
            throw new IllegalArgumentException("Add Failed. Array is full.");
        }

        if(index<0 || index>size){
            throw new IllegalArgumentException("Add Failed. Require index>=0 and index<=size.");
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }

    // 获取index指定位置的元素
    public E get(int index){
        if(index<0|| index>=size){
            throw new IllegalArgumentException("Get Failed. Index is illegal.");
        }
        return data[index];
    }

    // 修改index索引位置的元素为e
    public void set(int index,E e){
        if(index<0|| index>=size){
            throw new IllegalArgumentException("Get Failed. Index is illegal.");
        }
        data[index]=e;
    }

    // 查找数组中是否包含元素e
    public boolean contains(E e){
        for (int i = 0; i < size; i++) {
            if(data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    // 查找元素e的索引，否则返回-1
    public int find(E e){
        for (int i = 0; i < size ; i++) {
            if(data[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    // 删除指定索引index的位置,并返回删除的元素
    public E remove(int index){
        if(index<0|| index>=size){
            throw new IllegalArgumentException("Remove Failed. Index is illegal.");
        }
        E ret=data[index];
        for (int i = index+1; i <size ; i++) {
            data[i-1]=data[i];
        }
        size--;
        return ret;
    }

    //从数组中删除第一个元素，并返回
    public E removeFirst(int index){
        return remove(0);
    }

    //从数组中删除最后一个元素，并返回
    public E removeLast(int index){
        return remove(size-1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index=find(e);
        if(index!=-1){
            remove(index);
        }
    }

    // 重新数组的toString的方法
    @Override
    public String toString() {
        StringBuilder res=new StringBuilder();
        res.append(String.format("Array: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();
    }

    public static void main(String[] args) {
        Array arr = new Array(20);
        for (int i = 0; i < 10; i++) {
            arr.addLast(i);
        }
        System.out.println(arr);
        arr.add(0,100);
        System.out.println(arr);
        arr.remove(2);
        System.out.println(arr);
        arr.removeElement(100);
        System.out.println(arr);
    }
}