二次封装数组

在这里对数组进行封装，得到有特定功能的数组。其中capacity表示数组的容量，即数组长度，size表示实际存入数据的长度。

1.创建一个数组类Array，定义数组的容量、元素个数等

public class Array {
    private int[] arr;
    private int size;
    
    //有参构造函数，通过传入的数组容量capacity构造数组arr
    public Array(int capacity){
        arr = new int[capacity];
        size = 0;
    }
    
    //无参构造函数，将没有传递数组容量的数组设置默认容量为10
    public Array(){
        this(10);
    }
    //取得数组的容量及长度
    public int getCapacity(){
        return arr.length;
    }
    //取得数组中的元素个数
    public int getSize(){
        return size;
    }
    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }
    
}

2.完成数组的添加数据功能（头部添加、尾部添加、普通添加），并重写toString方法。

//在数组尾部添加新元素
    public void addLast(int e){
        /*if(size==arr.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        arr[size] = e;
        size++;*/
        add(size, e);
    }
    //在数组头部添加新元素
    public void addFirst(int e){
        /*if(size==arr.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        for(int i=size-1; i>=0; i--){
            arr[i+1] = arr[i];
        }
        arr[0]=e;
        size++;*/
        add(0, e);
    }
    //在索引为index处添加新元素
    public void add(int index, int e){
        if(size==arr.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--){
            arr[i+1] = arr[i];
        }
        arr[index] = e;
        size++;
    }
    //重写toString方法
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d, capacity = %d", size, arr.length));
        res.append("[");
        for(int i=0; i<size; i++){
            res.append(arr[i]);
            if(i != size-1){
                res.append(", ");
            }
        }
        res.append("]");
        return res.toString();
    }

3.完成查询元素和修改元素的功能

//查询元素
    public int getArr(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        return arr[index];
    }
    //修改元素
    public void setArr(int index, int e){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        arr[index] = e;
    }

4.完成数组是否包含元素、搜索元素、删除元素的功能。

//是否包含某元素
    public boolean contain(int e){
        for(int i=0; i<size; i++){
            if(arr[i]==e){
                return true;
            }
        }
        return false;
    }
    
    //搜索某元素，存在则返回索引，否则返回-1
    public int find(int e){
        for(int i=0; i<size; i++){
            if(arr[i]==e){
                return i;
            }
        }
        return -1;
    }
    //删除数组中索引为index的元素，并返回该元素
    public int remove(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        /*int ret = arr[index];
        for(int i=index+1; 1<size; i++)
            arr[i-1] = arr[i];
        size--;
        return ret;*/
        int ret = arr[index];
        for(int i = index + 1 ; i < size ; i ++)
            arr[i - 1] = arr[i];
        size --;
        return ret;
    }
    //删除数组的第一个元素
    public void removeFirst(){
        remove(0);
    }
    //删除数组的最后一个元素
    public void removeLast(){
        remove(size-1);
    }
    //从数组中删除指定元素
    public void removeElement(int e){
        int index = find(e);
        if(index==-1){
            throw new IllegalArgumentException("Remove filed.The Element dose not exist");
        }
        remove(index);
    }

5.使用泛型，让我们的数据结构可以放置“任何”数据类型，但不可以是基本数据类型，只能是类对象。

public class Array<E> {
    private E[] arr;
    private int size;
    
    //有参构造函数，通过传入的数组容量capacity构造数组arr
    public Array(int capacity){
        arr = (E[])new Object[capacity];
        size = 0;
    }
    
    //无参构造函数，将没有传递数组容量的数组设置默认容量为10
    public Array(){
        this(10);
    }
    //取得数组的容量及长度
    public int getCapacity(){
        return arr.length;
    }
    //取得数组中的元素个数
    public int getSize(){
        return size;
    }
    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //在数组尾部添加新元素
    public void addLast(E e){
        /*if(size==arr.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        arr[size] = e;
        size++;*/
        add(size, e);
    }
    //在数组头部添加新元素
    public void addFirst(E e){
        /*if(size==arr.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        for(int i=size-1; i>=0; i--){
            arr[i+1] = arr[i];
        }
        arr[0]=e;
        size++;*/
        add(0, e);
    }
    //在索引为index处添加新元素
    public void add(int index, E e){
        if(size==arr.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--){
            arr[i+1] = arr[i];
        }
        arr[index] = e;
        size++;
    }
    //查询元素
    public E getArr(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        return arr[index];
    }
    //修改元素
    public void setArr(int index, E e){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        arr[index] = e;
    }
    //是否包含某元素
    public boolean contain(E e){
        for(int i=0; i<size; i++){
            if(arr[i]==e){
                return true;
            }
        }
        return false;
    }
    
    //搜索某元素，存在则返回索引，否则返回-1
    public int find(E e){
        for(int i=0; i<size; i++){
            if(arr[i]==e){
                return i;
            }
        }
        return -1;
    }
    //删除数组中索引为index的元素，并返回该元素
    public E remove(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        /*int ret = arr[index];
        for(int i=index+1; 1<size; i++)
            arr[i-1] = arr[i];
        size--;
        return ret;*/
        E ret = arr[index];
        for(int i = index + 1 ; i < size ; i ++)
            arr[i - 1] = arr[i];
        size --;
        return ret;
    }
    //删除数组的第一个元素
    public E removeFirst(){
        return remove(0);
    }
    //删除数组的最后一个元素
    public E removeLast(){
        return remove(size-1);
    }
    //从数组中删除指定元素
    public void removeElement(E e){
        int index = find(e);
        if(index==-1){
            throw new IllegalArgumentException("Remove filed.The Element dose not exist");
        }
        remove(index);
    }
    //重写toString方法
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d, capacity = %d", size, arr.length));
        res.append("[");
        for(int i=0; i<size; i++){
            res.append(arr[i]);
            if(i != size-1){
                res.append(", ");
            }
        }
        res.append("]");
        return res.toString();
    }
}

写成泛型，可以得到任何类对象的数组。

6.实现动态数组，即向数组中添加元素容量不够时自动扩容，删除元素时自动缩减容量。

编写动态扩容方法：

//动态扩容
    private void resize(int newCapacity){
        E[] newArr = (E[])new Object[newCapacity];
        for(int i = 0; i<size; i++){
            newArr[i] = arr[i];
        }
        arr = newArr;
    }

在添加元素和删除元素中分别实现：

//在索引为index处添加新元素
    public void add(int index, E e){

        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
        }
        
        if(size==arr.length){
            resize(2*arr.length);
        }
        
        for(int i=size-1; i >= index; i--){
            arr[i+1] = arr[i];
        }
        arr[index] = e;
        size++;
    }

//删除数组中索引为index的元素，并返回该元素
    public E remove(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");}
        E ret = arr[index];
        for(int i = index + 1 ; i < size ; i ++)
            arr[i - 1] = arr[i];
        size --;
        arr[size] = null; // loitering objects != memory leak

        if(size == arr.length / 2)
            resize(arr.length / 2);
        return ret;
    }