01玩转数据结构_02_不要小瞧数组

数组基础：

package cn.zcb.demo01;

public class Test {
    public static void main(String[] args) {
        //数组创建 和 初始化的两种方式
        //1
        int [] arr = new int[10];
        for (int i=0;i<arr.length ;i++){
            arr[i] = i;
        }
        //2
        int [] scores = new int[] {10,20,30,40};

        //下面是两种打印方式
        //1
        for (int i=0;i<scores.length;i++){
            System.out.println(scores[i]);
        }
        //2
        for (int score:scores){
            System.out.println(score);
        }


    }
}
/* 输出结果
10
20
30
40
10
20
30
40
* */

索引的语义：

所以可以有语义，也可以没有语义，

有语义，例如0 代表学号，

没有语义，例如0 只是代表第一个而已。

数组最大的优点是：快速查询。所以，对于数组我们最好应用在“索引有语义”的情况。我们知道我们要查的是什么。

但是并非所有的有语义的索引都适合用于数组！

例如身份证号33333333333332442444444222！

这个时候，也可以使用数组处理“索引没有语义”的情况。

下面制作属于我们自己的数组类：

   

package cn.zcb.demo01;

public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }
}

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;  
    }
}

向我们自己的数组中添加元素（在数组末加）：

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }

    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
    }



}

向我们自己的数组中添加元素（在数组指定位置添加）：

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }

    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,int num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");
        
        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }
}

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }

    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,int num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }
}

而且，给数组头添加元素也可以直接复用 给指定位置添加元素的 函数！！！

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }

    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(int num){
        insert(0,num); 
    }
    
    
    
    //向 指定数组位置添加一个新元素
    public void insert(int idx,int num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }
}

 

在我们自己的数组中查询和修改操作：

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(int num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,int num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }
//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,int num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public int getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！")
        }
        return this.data[idx];
    }



}

在我们自己的数组中 包含，搜索，和删除  操作：

package cn.zcb.demo01;
public class MyArray {
    private int[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
        this.data  = new int[capacity];
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(int num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(int num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,int num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

//////////////////////删///////////////////////////////////////
    //删除第一个
    public int removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public int removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public int remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        int temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }

        this.size -- ;
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(int element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }     

//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,int num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public int getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

//////////////////////包含///////////////////////////////////////
    public boolean contains(int num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
//////////////////////寻找////////////////////////////////////
    public int find(int num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }


}

到目前为止，我们自己的数组类已经初具雏形了！

调试代码：

package cn.zcb.demo01;

public class Test {
    public static void main(String[] args) {
        MyArray arr = new MyArray(10);

        //数组的容量
        System.out.println(arr.getCapacity());

        //目前数组的大小
        System.out.println(arr.getSize());

        //在数组末尾加一个数
        arr.addLast(18);

        //在 0 索引加入 7
        arr.insert(0,7);

        System.out.println(arr.getSize());

        //查看数组内容  会调用重写之后的toString()
        System.out.println(arr);

        //在数组的头部 加-10
        arr.addFirst(-10);
        System.out.println(arr);

        System.out.println(arr.contains(7));
        System.out.println(arr.contains(101));

        //删除指定位置的元素
        int res =  arr.remove(0); //删除索引为0 的元素
        System.out.println(res);
        System.out.println(arr); //再次打印 arr


    }
}

改善我们自己的数组之---使用泛型：

 目前我们自己写的数组类最大的问题就是它只能存放int 数据类型，这肯定是不行的。 

package cn.zcb.demo01;

public class MyArray<T> {
    private T[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
//        this.data  = new int[capacity];
//        this.data  = new T[capacity];  //不支持这样
        this.data =  (T[]) new Object[capacity];  //先new 出个 Object[]  类的，然后转为 T[]
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(T num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(T num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,T num){
        if(this.size == this.data.length){
            throw new IllegalArgumentException("数组已经放满了");
        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

//////////////////////删///////////////////////////////////////
    //删除第一个
    public T removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public T removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public T remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        T temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }

        this.size -- ;
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(T element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }

//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,T num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public T getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

//////////////////////包含///////////////////////////////////////
    public boolean contains(T num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
//////////////////////寻找////////////////////////////////////
    public int find(T num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }

}

package cn.zcb.demo01;

public class Person {

    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(){
        this("张三",18);  //默认赋值 张三 18
    }


}

package cn.zcb.demo01;

public class Test {


    public static void main(String[] args) {
        MyArray<Integer> arrInt = new MyArray<Integer>(11);
        arrInt.addLast(10);
        arrInt.addLast(11);
        arrInt.addLast(12);
        System.out.println(arrInt);

        MyArray<Character> arrChar = new MyArray<Character>(11);
        arrChar.addLast('1');
        arrChar.addLast('a');
        arrChar.addLast('b');
        arrChar.addLast('c');
        System.out.println(arrChar);

        //自定义类型  Person
        Person p1 = new Person("tom",18);
        Person p2 = new Person("egon",20);
        Person p3 = new Person("alex",30);

        MyArray<Person> arrPerson = new MyArray<>();  // <>  中的类型是可以省略的。
        arrPerson.addLast(p1);
        arrPerson.addLast(p2);
        arrPerson.addLast(p3);
        System.out.println(arrPerson);
    }
}
/* 输出结果
Array:size = 3,capacity = 11
[10, 11, 12]
Array:size = 4,capacity = 11
[1, a, b, c]
Array:size = 3,capacity = 10
[cn.zcb.demo01.Person@17a7cec2, cn.zcb.demo01.Person@65b3120a, cn.zcb.demo01.Person@6f539caf]
* */

改善我们自己的数组之---动态数组：

此时不够用了，

以上整个过程是封装在一个函数中。

原本的四个的数组，由于没有人指向它了，所以Java的垃圾回收机制会将它回收。

上面其实有个缺点是：如果一个数组太大的话，每一个都遍历复制到一个新的地方，这确实是在性能上有所缺陷。这个问题将在下面讨论。

而且，删除的时候，也是用的这个思路。这样就可以实现动态数组了。

package cn.zcb.demo01;

public class MyArray<T> {
    private T[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
//        this.data  = new int[capacity];
//        this.data  = new T[capacity];  //不支持这样
        this.data =  (T[]) new Object[capacity];  //先new 出个 Object[]  类的，然后转为 T[]
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(T num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(T num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,T num){
        if(this.size == this.data.length){
//            throw new IllegalArgumentException("数组已经放满了");
            /*此时对其扩容*/
            resize(2*this.data.length);


        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

//////////////////////删///////////////////////////////////////
    //删除第一个
    public T removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public T removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public T remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        T temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }
        this.size -- ;

        //动态减少   当数组中的元素少于空间的一半的时候，就缩减空间。
        if(this.size == this.data.length / 2){
            System.out.println("size = "+this.size);

            resize(this.data.length/2);
        }
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(T element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }

//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,T num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public T getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

//////////////////////包含///////////////////////////////////////
    public boolean contains(T num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
//////////////////////寻找////////////////////////////////////
    public int find(T num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }
//////////////////////实现动态数组  resize()////////////////////////////////////
    private void resize(int new_capacity){  //之所以  用 private 是不让用户调用， 数组如果空间不足会自己扩展的。
        T[] new_data =(T[]) new Object[new_capacity];

        for (int i =0;i<this.size;i++){
            new_data[i] = this.data[i];
        }
        //
        this.data = new_data;  //此时新数组的size 不变 ， 新数组的length 也不用变
    }
}

package cn.zcb.demo01;
/* 动态增加测试
public class Test {


    public static void main(String[] args) {
        MyArray<Integer> arrInt = new MyArray<Integer>(4);
        arrInt.addLast(10);
        arrInt.addLast(11);
        arrInt.addLast(12);
        arrInt.addLast(13);
        System.out.println(arrInt);
        arrInt.addLast(14);
        System.out.println(arrInt);
    }
}
输出结果
Array:size = 4,capacity = 4
[10, 11, 12, 13]
Array:size = 5,capacity = 8
[10, 11, 12, 13, 14]
* */

//动态减少测试  n =4 时的减少
/*
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> arrInt = new MyArray<Integer>(4);
        arrInt.addLast(10);
        arrInt.addLast(11);
        arrInt.addLast(12);
        arrInt.addLast(13);
        System.out.println(arrInt);
        arrInt.remove(0); //删除
        arrInt.remove(0);
        System.out.println(arrInt);
    }
}

输出结果
Array:size = 4,capacity = 4
[10, 11, 12, 13]
size = 2
Array:size = 2,capacity = 2
[12, 13]
* */



//动态减少测试  n =5 时的减少

public class Test {
    public static void main(String[] args) {
        MyArray<Integer> arrInt = new MyArray<Integer>(5);
        arrInt.addLast(10);
        arrInt.addLast(11);
        arrInt.addLast(12);
        arrInt.addLast(13);
        arrInt.addLast(14);
        System.out.println(arrInt);
        arrInt.remove(0); //删除
        arrInt.remove(0);
        arrInt.remove(0);
        System.out.println(arrInt);
    }
}
/* 输出结果
Array:size = 5,capacity = 5
[10, 11, 12, 13, 14]
size = 2
Array:size = 2,capacity = 2
[13, 14]
* */

改善我们自己的数组之---简单的时间复杂度分析：

其实c1 和  c2 是很难精确得知的，它在不同语言不同平台都可能有差别！

时间复杂度为O(n) 的 一定比 时间复杂度为O(n^2) 的优吗？
不一定，例如上述的第二个和第三个，当n =10 时，第二个的T= 30000 第三个的T= 100

因此，针对任意一个输入，并不是O(n) 的算法，一定优于O(n^2) 的（此时O(n) 的系数起到大的作用！） 。

但，大O ，描述的其实是当n 趋近于无穷的时候的情况。  

 

resize 的时间复杂度分析：

虽然上述分析没有错误，但是，我们忽略了一个问题，就是并不是每次我们都需要进行resize操作。

可以如下分析：

但是同时进行addLast 和  removeLast 时候就出问题了：

这个问题叫做复杂度震荡！

是数组长度的1/4 的时候，再缩容，缩小1/2  。

这样就可以有效的防止了 复杂度震荡的问题了。

所以，在算法中有时“懒”一点反而可以提高代码的整体性能！！！

改善之后的代码：主要在remove()中:

package cn.zcb.demo01;

public class MyArray<T> {
    private T[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
//        this.data  = new int[capacity];
//        this.data  = new T[capacity];  //不支持这样
        this.data =  (T[]) new Object[capacity];  //先new 出个 Object[]  类的，然后转为 T[]
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

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

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(T num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(T num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,T num){
        if(this.size == this.data.length){
//            throw new IllegalArgumentException("数组已经放满了");
            /*此时对其扩容*/
            resize(2*this.data.length);


        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

//////////////////////删///////////////////////////////////////
    //删除第一个
    public T removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public T removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public T remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        T temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }
        this.size -- ;

        //动态减少   当数组中的元素少于空间的四分之一的时候，缩减空间为原来的一半（这样可以有效的防止 复杂度震荡问题）。
        if(this.size == this.data.length / 4 && this.data.length/2 != 0 ){  //第二个条件是防止 length =1 的时候
            resize(this.data.length/2);
        }
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(T element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }

//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,T num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public T getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

//////////////////////包含///////////////////////////////////////
    public boolean contains(T num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
//////////////////////寻找////////////////////////////////////
    public int find(T num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }
//////////////////////实现动态数组  resize()////////////////////////////////////
    private void resize(int new_capacity){  //之所以  用 private 是不让用户调用， 数组如果空间不足会自己扩展的。
        T[] new_data =(T[]) new Object[new_capacity];

        for (int i =0;i<this.size;i++){
            new_data[i] = this.data[i];
        }
        //
        this.data = new_data;  //此时新数组的size 不变 ， 新数组的length 也不用变
    }
}