动态数组的使用-2-泛型

在上一篇博客，我们讲了怎么用动态数组。这一篇我们讲泛型。

作用：当我们要将动态数组中的元素取出时我们只知道它属于Object类，不知道它的具体类型，用泛型就能将Object数组转化成String数组

使用，基于上一篇的代码，我们将他修改

在MyArray类后面加<E>,并在main方法创建对象时左边加入<要转化的数据类型>，右边加<>。

public class MyArray<E>

public static void main(String[] args){
        MyArray<String> myArray = new MyArray<>(20);
    }

在其他方法中在用到Object类型的代码将Object改为E

    public void addElement(E e){
        if(size == length){// 数组已经存满了 需要扩容的
            int newLength = length + (length >> 1);
            dilatation(newLength);
        }
        values[size] = e;
        size++;
    }

    public E get(int index){
// 检查传入的下标是否在合法的区间内 （0~size-1)
        if(index >= 0 && index < size){
            E e = (E)values[index];
            return e;
        }
        System.out.println ("传入的下标不在数组的范围内~");
        return null;
    }

在addArray方法中，我做了优化，上一篇我将需要扩容的大小写在扩容方法内，在传入大数组时可能需要扩容多次，为了减轻运行负担，在传入数组时算出要扩容的大小并一步扩容到位。

    public void addArray(E[] newArray){
        //int continueAddArray;
//        System.out.println("此功能会将空元素传入，是否继续");
//        System.out.println("继续请输入1，退出请输入0：");
//        continueAddArray=sc.nextInt();
//        while(continueAddArray!=0 && continueAddArray!=1){
//            System.out.println("请输入0或1:");
//            continueAddArray=sc.nextInt();
//        }
//        if(continueAddArray==0){
//            System.out.println("已取消此次传入");
//            return;
//        }
        int newArrayLength = newArray.length;
// 目前数组的长度
        int valuesLength = values.length;

        if(newArrayLength==0){
            System.out.println("传入数组为空，请传入有数据的数组");
            return;
        }

        if(valuesLength - size < newArrayLength){
            int minSize = newArrayLength + size;// 最少需要的空间
            int minLength = valuesLength + (valuesLength >> 1);// 1.5倍扩容
            if(minSize < minLength){
// 1.5倍扩容
                dilatation (minLength);
            } else{
                dilatation (minSize);
            }

        }

        for(int i=0;i<newArrayLength;i++){
            values[size] = newArray[i];
            size++;
        }
        System.out.println("数组传入完毕");
    }

    public void dilatation(int newLength){
// System.out.println (newLength);
// 使用新的长度创建一个新的 容量更大的数组
        Object[] newValues = new Object[newLength];
// 将原数组中的元素i移动到新数组中
        for(int i = 0; i < size; i++){
            newValues[i] = values[i];
        }
// 将新数组的对象变量名中存储的新数组的内存地址赋值给旧数组名
// 替换引用 因为这个类中所有的方法都是使用 values这个变量名
        values = newValues;
// 更新最新的数组长度
        length = newLength;
        System.out.println ("数组扩容完成，长度是：" + length);
    }

新增方法：

替换有某个值的所有元素为另一个值

    public void replace(E oldE, E newE){// 替换元素
        for(int i=0;i<size;i++){
            if(values[i].equals(oldE)){
                values[i]=newE;
            }
        }
    }

判断元素是否在数组内

    public boolean contains(E o){
        for(int i=0;i<size;i++){
            if(values[i].equals(o)){
                return true;
            }
        }
        return false;
    }

返回元素所在的第一个下标

    public int indexOf(E e){
        for(int i=0;i<size;i++){
            if(values[i].equals(e)){
                return i;
            }
        }
        System.out.println("No found");
        return -1;
    }