不要小瞧数组

 

public class Array01{
    
    private int[] data;
    private int size; // 记录数组中实际存在的元素个数

    // 构造函数，传入数组的容量capacity构造Array01
    public Array01(int capacity){
        data = new int[capacity];
        size = 0;
    }

    // 无参数的构造函数，默认数组的容量capacity = 30
    public Array01(){
        this(30); // 调用data.Array01(capacity)
    }

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

    // 获取数组中的实际存储元素个数
    public int getSize(){
        return size;
    }

    // 判断数组实际元素个数是否为空
    public boolean isEmpty(){
        /*
        
        /if(0 == size){
            return true;
        }

        return false;
        
        */

        return 0 == size;
    }

    // 在index索引的位置插入一个新元素e
    public void add(int index, int e){
        // 1.判断index是否合法，非法时抛出异常
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed.Index is illegal.");
        }

        // 2.判断数组是否为满，满时先扩容数组容量
        if(data.length == size){
            resize(2 * data.length);
        }
        
        // 3.插入元素，并修改记录元素个数的size值
        for(int i = size - 1; i >= index; i--){
            data[i + 1] = data[i];
        }
        
        data[index] = e;

        size++;
    }

    // 向数组头部添加一个元素
    public void addFirst(int e){
        add(0,e);
    }
    
    // 向数组尾部添加一个元素
    public void addLast(int e){
        add(size,e);
    }
    
    // 获取index索引位置的元素
    public int 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, int e){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        }
        data[index] = e;
    
    }

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

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(int e){
        for(int i = 0; i < size; i++){
            if(e == data[i]){
                return i;
            }
        }
        return -1;
    }

    // 从数组中删除index位置的元素, 返回删除的元素
    public int remove(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }

        int res = data[index]; 

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

        size--;
        
        if(data.length / 4 == size && 0 != data.length / 2){
            resize(data.length / 2);
        }

        return res;
    }

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

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

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

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

    // 对数组的容量变成newCapacity大小
    private void resize(int newCapacity){
        int[] newData = new int[newCapacity];
        for(int i = 0; i < size; i++){
            newData[i] = data[i];
        }
        data = newData;
    }

     public static void main(String[] args) {

        Array01 arr = new Array01();
        System.out.print("\n\t 创建一个新的数组 \t\n");
        for(int i = 0 ; i < 15 ; i++)
            arr.addLast(i);
        System.out.println(arr);

        System.out.print("\n\t 添加一个元素 \t\n");
        arr.add(1, 100);
        System.out.println(arr);
        
        System.out.print("\n\t 在数组所有元素前添加一个元素 \t\n");
        arr.addFirst(-1);
        System.out.println(arr);

        System.out.print("\n\t 删除索引为2所在位置上的一个元素 \t\n");
        arr.remove(2);
        System.out.println(arr);
        

        System.out.print("\n\t 删除指定值为7的元素 \t\n");
        arr.removeElement(7);
        System.out.println(arr);
        
        System.out.print("\n\t 删除数组起始位置上的元素 \t\n");
        arr.removeFirst();
        System.out.println(arr);
        
    }
}

 

 

 

运行结果：