（一）基本数据结构--数组

一、数组的实现与扩展

数组作为最常见的数据结构之一，其作用不言而喻。我将自定义一个数组类以满足使用需求。

二、实现内容

• 数组的增删改查
  增删改查具体实现方法见代码

• 数组的泛型实现
  泛型实现为在Array类后加实现
  所以当新建泛型数组时候应为
  E[] data=(E[]) new Object[capacity];
  应使用强制类型转换实现而不能用
  ***E[] data=new E[capacity]; ***

• 动态数组的实现
  动态数组的容量改变由resize方法实现
  同时为了节省占用空间，在remove里面加入了resize（data.length/2）方法来对容量进行调整

三、具体代码实现

import java.util.Objects;

public class Array<E> {

    private E[] data;
    private int size;

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

    public Array() {
        this(10);
        // this.data =new int[10];
    }

    public E[] getData() {
        return data;
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return this.size == 0;
    }

    public void addLast(E e) {

        if (size == data.length) {
            throw new IllegalArgumentException("数组已满");
        }

        data[size] = e;
        size++;
    }

    public void addIndex(E e, int index) {



        if (index < 0 || index > size) {
            throw new IllegalArgumentException("size is wrong");
        }

        if (size == data.length) {
            resize(2*size);
        }

        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    public void addFirst(E e) {
        addIndex(e, 0);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("数组的大小是：%d,容量是%d,数组具体为[", size, data.length));
        for (int i = 0; i <= size - 1; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }

    public boolean contains(E e) {

        for (int i = 0; i < size; i++) {
            if (data[i].equals(e))
                return true;
        }
        return false;
    }

    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if ((data[i].equals(e)))
                return i;
        }
        return -1;
    }
//动态数组的实现方法 重定义容量
    public void resize(int newcapacity) {
        if (newcapacity<size){
            throw new IllegalArgumentException("请重新输入容量");
        }
        E[] temp = (E[]) new Object[newcapacity];
        for (int i = 0; i < size; i++) {
            temp[i]=data[i];
        }
        data=temp;
    }

    public E remove(int index){
        if (index<0||index>size){
            throw new  IllegalArgumentException("index is wrong");
        }
        E ret =data[index];
        for (int i=index;i<size-1;i++){
            data[i]=data[i+1];
        }
        data[size-1]=null;
        size--;
       //缩小数组大小 减少占用空间
        if (size<=data.length/2){
            resize(data.length/2);
        }
        return ret;
    }
}

测试类

public class Main {
    public static void main(String[] args) {

        Array<Integer> arr=new Array<>(10);
        for (int i=0;i<10;i++){
            arr.addLast(i);
        }
        System.out.println(arr.toString());

        arr.addIndex(10,2);
        System.out.println(arr.toString());

        arr.addFirst(35);
        System.out.println(arr.toString());

        arr.remove(1);
        System.out.println(arr.toString());
        arr.remove(0);
        System.out.println(arr.toString());
        arr.remove(2);
        System.out.println(arr.toString());
    }
}
运行结果：
数组的大小是：10,容量是10,数组具体为[0,1,2,3,4,5,6,7,8,9]
数组的大小是：11,容量是20,数组具体为[0,1,10,2,3,4,5,6,7,8,9]
数组的大小是：12,容量是20,数组具体为[35,0,1,10,2,3,4,5,6,7,8,9]
数组的大小是：11,容量是20,数组具体为[35,1,10,2,3,4,5,6,7,8,9]
数组的大小是：10,容量是10,数组具体为[1,10,2,3,4,5,6,7,8,9]
数组的大小是：9,容量是10,数组具体为[1,10,3,4,5,6,7,8,9]