二次封裝數組

時間  2019-12-02
標籤 二次 封裝 數組 欄目 軟件設計 简体版
原文   原文鏈接

在這裏對數組進行封裝，獲得有特定功能的數組。其中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方法。app

//在數組尾部添加新元素
    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.完成查詢元素和修改元素的功能ide

//查詢元素
    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.使用泛型，讓咱們的數據結構能夠放置「任何」數據類型，但不能夠是基本數據類型，只能是類對象。ui

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();
    }
}

寫成泛型，能夠獲得任何類對象的數組。this

 

6.實現動態數組，即向數組中添加元素容量不夠時自動擴容，刪除元素時自動縮減容量。spa

編寫動態擴容方法：code

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

在添加元素和刪除元素中分別實現：orm

//在索引爲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;
    }
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程