CH2 数组类2 - int型适用

数组，看似是最简单的数据结构，但是，大多数语言为我们提供的都是静态数组，用静态数组封装一个属于我们自己的动态数组，将是这一章讨论的重点。同时，我们也将探讨泛型，复杂度分析，乃至复杂度的震荡，等相关高级话题

创建基础数组 类

基础数组类包含 一个静态数组data[] 和 数组内有效个数size(size同时是第一个没有元素的index位置)

public class Array {

    //创建一个数组
    private int[] data;
    //size代表数组有多少个有效的元素
    //size也指向了第一个没有元素的索引位置
    private int size; 

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

    //默认构造函数，当用户不知道(不传入capacity时调用)数组容量时，用无参构造函数创建一个10的数组
    public Array() {
        this(10); //这个参数的语义时capacity，时IDEA提供的
    }

    //用户传入静态数组，然后生成Array类
    public Array(int[] args) {
        data = args;
        size = args.length;
    }

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

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

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

向数组尾部添加元素（方法）

	//下面是一个方法，没写完整类
    //向数组最后位置添加一个元素,在添加之前，要看数组是否还有空余位置
    public void addLast(int e) {
        if (size == data.length) {
            throw new IllegalArgumentException("AddLast failed. Array is Full.");//先抛个异常，以后再处理
        } else {
            data[size] = e;
            size ++;
        }
    }

向数组位置index的地方添加元素（方法）

    //在第index个位置添加一个新元素
    public void add(int index, int e) {
        if (size == data.length) {
            throw new IllegalArgumentException("AddElement failed. Array is Full.");//先抛个异常，以后再处理
        } else if (index < 0 || index > size) {
            //index>size 代表不是紧密地在最后添加，会有跳过的地方
            throw new IllegalArgumentException("AddElement failed. Require index < 0 || index > size.");//先抛个异常，以后再处理
        } else {
            //index之后的元素依次向后挪动，然后将e放到poz处，size增加1
            //要被处理i的开始位置是size-1结束位置是index
            for (int i = size-1; i >= index; i --) {
                data[i + 1] = data[i];
            }
            data[index] = e;
            size ++;
        }
    }

修改上上面向数组尾部添加元素（方法）

	//因为上一个方法是可以应用到上上个方法的
    public void addLast(int e) {
        add(size,e);
    }

向数组头部添加元素（方法）

	//复用add方法
    public void addFirst(int e) {
        add(0,e);
    }

重写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 ++) {//从第一个打印，打印到index=size-1（即最后一个内容）
            res.append(data[i]);
            if(i != size -1) {//如果不是最后一个内容，则后面加的，逗号
                res.append(", ");
            }
            res.append(']');//如果是最后一个则追加 】
        }
        return res.toString();
    }

使用上面的各种方法

	public class Main {

    public static void main(String[] args) {

        Array array = new Array(20);
        for (int i = 0; i < 10; i ++) {
            array.addLast(i);
        }
        System.out.println(array);

        array.add(1,100);
        System.out.println(array);

        array.addFirst(-1);
        System.out.println(array);
    }
}

获取 ，更新（方法）

	//获取index索引位置的元素
    public int get (int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("AddElement failed. Require index < 0 || index >= size.");//先抛个异常，以后再处理
        } else {
            return data[index];
        }
    }

    //更新index索引位置的元素
    public void set (int index,int e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("AddElement failed. Require index < 0 || index >= size.");//先抛个异常，以后再处理
        } else {
            data[index] = e;
        }
    }

查找是否包含某个元素，和索引位置（方法）

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

    //查找某个元素的索引
    public int find (int e) {
        for (int i = 0; i < size; i ++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }
    //查找某个元素e的所有索引
    public void findAll (int e) {
        StringBuilder ret;
        for (int i = 0; i < size; i ++) {
            if (data[i] == e) {
                remove(i);
            }
        }
    }

删除索引为index的某个元素,并且返回该元素的值（方法）

    //删除索引为index的某个元素,并且返回该元素的值
    public int remove (int index) {
        int ret = data[index];
        if (index < 0 || index > size) {
            //index>size 代表不是紧密地在最后添加，会有跳过的地方
            throw new IllegalArgumentException("AddElement failed. Require index < 0 || index > size.");//先抛个异常，以后再处理
        } else {
            //index之后的元素依次向前挪动，size减1
            //要被处理i的开始位置是size-1结束位置是index
            for (int i = index; i < size -1 ; i ++) {
                data[i] = data[i + 1];
            }
            size --;
        }
        return ret;
    }
    //从数组中删除第一个元素，复用remove
    public int removeFirst (int index) {
        return remove(0);
    }
    //从数组中删除最后一个元素，复用remove
    public int removeLast (int index) {
        return remove(size - 1);
    }
    //从数组中删除元素e(e存在的情况下) 复用find 和 remove
    public boolean removeElement (int e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
            return true;
        } else {
            return false;
        }
    }
    //从数组中删除所有元素e
    public void removeAllElement (int e) {
        for (int i = 0; i < size; i ++) {
            if (data[i] == e) {
                remove(i);
            }
        }
    }