Java——动态数组&泛型

1.数组定义好后内存固定，这时我们可以定义一个动态数组进行扩容；

    动态数组属性：

        底层存储数据的数组

        已存入的元素个数

        数组的实时长度；

   方法：grow,扩容

              get,获取元素

              set,替换元素

              add,增加元素

              remove,移除元素        

2.泛型：动态数组中存储的数据的类型不确定，获取数据时也不知道到底是什么类型，而泛型是一种类型模板，当作一个不确定的类型来使用。

格式: 在类名的后面加上一个< >，括号中写一个通配符(通常是一个单词或者字母)

泛型的使用:

定义了泛型的类中可以使用泛型通配符替代参数类 返回值类型 或者局部对象的类型

定义了泛型的类在创建对象的时候需要将通配符指定成一个具体的类型

代码如下：

public class MyArray<E>{
    Object[] values;
    int size;
    int length;
    static final int initCap = 10;
    // 构造方法：
    public MyArray(){
        length = initCap;
        values = new Object[length];
        size = 0;
    }
    public MyArray(int initLength){
        if(initLength < 2){
            System.out.println ("输入的初始长度不能小于2,数组会使用默认的初始数据进行初始化");
                    length = initCap;
            values = new Object[length];
            size = 0;
        } else{
            length = initLength;// 使用传入的参数进行初始化
            values = new Object[length];
            size = 0;
        }
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    public void grow(int minLength){
        int oldLength = length;
        int newLength = minLength;// 1.5倍
        System.out.println (newLength);
        Object[] newValues = new Object[newLength];
// 将原数组中的元素i移动到新数组中
        for(int i = 0; i < oldLength; i++){
            newValues[i] = values[i];
        }
                values = newValues;
// 更新最新的数组长度
        length = newLength;
        System.out.println ("数组扩容完成，长度是：" + length);
    }
    public void add(E e){
// 扩容
        if(size == length){
            int newLength = length + (length >> 1);
            grow (newLength);
        }
        values[size] = e;
        size++;
    }




    public void addAll(E[] eArr){
// 需要添加的数组的长度
        int eArrLength = eArr.length;
// 目前数组的长度
        int valuesLength = values.length;
// 如果剩余的空间小于需要添加的数组的长度 需要扩容
        if(valuesLength - size < eArrLength){
// 一步扩容到位
            int minSize = eArrLength + size;// 最少需要的空间
            int minLength = valuesLength + (valuesLength >> 1);// 1.5倍扩容
            if(minSize < minLength){
// 1.5倍扩容
                grow (minLength);
            } else{
                grow (minSize);
            }
        }
        for(int i = 0; i < eArrLength; i++){
            values[size++] = eArr[i];
        }
    }
    // 根据传入的下标获取数组元素
    public E get(int index){
        if(index >= 0 && index < size){
            E e = (E) values[index];
            return e;
        }
        System.out.println ("传入的下标不在数组的范围内~");
        return null;
    }
    // 替换传入下标位置的元素
    public void set(int index, E e){
// 检查传入的下标是否在合法的区间内 （0~size-1)
        if(index >= 0 && index < size){
            values[index] = e;
        } else{
            System.out.println ("传入的下标不在数组的范围内~");
        }
    }
    // 根据下标移除元素 并且返回被移除的元素，后置数据前移填充
    public E remove(int index){
        if(index >= 0 && index < size){
            E oldE = (E) values[index];
            for(int i = index; i < size - 1; i++){
                values[i] = values[i + 1];
            }
            size--;
            return oldE;
        }
        System.out.println ("传入的下标不在数组的范围内~");
        return null;
    }
    public String toString(){
        String str = "{";
        for(int i = 0; i < size; i++){
            str += values[i] + ",";
        }
        str += "}";
        return str;
    }
 public static void main(String[] args){
        MyArray<String> myArray = new MyArray<> (20);
        myArray.add ("hello");
        //Student student = new Student ();
       // myArray.add (student);
        String str = myArray.get (0);
        for(int i = 0; i < 10; i++){
            myArray.add ("" + i);
        }
        String[] newarr = new String[15];
        for(int i = 0; i < newarr.length; i++){
            newarr[i] = "hello" + i;
        }
        myArray.addAll (newarr);
        System.out.println (myArray.toString ());
    }
}