自动化测试学习之路--java 数组

数组的定义与为数组元素分配空间和赋值是分开进行的，称为动态初始化。

在数组定义的同时就为数组元素分配空间并赋值，称为静态初始化。

一维数组举例：

        //动态初始化
        int[] intArr;
        intArr=new int[3];
        intArr[0]=1;
        intArr[1]=2;
        intArr[2]=3;
        //动态初始化
        int[] intArr2;
        intArr2=new int[] {1,2,3};
        //静态初始化
        int[] intArr3= {1,2,3};

二维数组举例：

        //动态初始化
        int[][] intArr;
        intArr=new int[2][];
        intArr[0]=new int[] {1,2,3};
        intArr[0]=new int[] {4,5,6};
        //动态初始化
        int[][] intArr2;
        intArr2=new int[2][];
        intArr[0]=new int[3];
        intArr[1]=new int[2];
        
        //静态初始化
        int[][] intArr3= {{1,2,3},{4,5}};

注意：

　　1.数组的效率高。但是数组空间大小被固定，在其生命周期内不可变。

　　2.引用类型数组默认初始化为null，数值类型数组默认初始化为0，char类型数组默认初始化为(char)0，boolean类型的数组默认初始化为false。

　　3.intArr1=intArr2，代表的是将intArr2的引用赋值给intArr1,此时intArr1和intArr2都是指向intArr2原本指向的对象。

关于数组元素的输出：

1.使用for循环

        int[][] intArr= {{1,2,3},{4,5},{6,7,8,9}};
        for (int i = 0; i < intArr.length; i++) {
            for (int j = 0; j < intArr[i].length; j++) {
                System.out.print(intArr[i][j]);
            }
            System.out.println();
            
        }

2.使用增强的for

        int[][] intArr= {{1,2,3},{4,5},{6,7,8,9}};
        for (int[] FirstDimensional : intArr) {
            for (int SecondDimensional : FirstDimensional) {
                System.out.print(SecondDimensional);
            }
            System.out.println();
        }

3.使用Arrays.toString（）或者Arrays.deepToString（），这两个是Arrays类中的静态方法。

        //二维的用Arrays.deepToString（）
        int[][] intArr= {{1,2,3},{4,5},{6,7,8,9}};
        System.out.println(Arrays.deepToString(intArr));
        //一维的用Arrays.toString（）
        int[] intArr2= {1,2,3};
        System.out.println(Arrays.toString(intArr2));

Arrays类中的常用Static方法：

1.equals和deepEquals

        int[][] intArr11 = {{1,2,3},{4,5},{6,7,8,9}};
        int[][] intArr22 = {{1,2,3},{4,5},{6,7,8,9}};
        System.out.println(Arrays.deepEquals(intArr11, intArr22));//结果为True
        int[] intArr1 = {1,2,3};
        int[] intArr2 = {1,2,3};
        System.out.println(Arrays.equals(intArr1, intArr2));//结果为True

2.fill，下面是fill方法的两种重载

        int[] intArr=new int[3];
        Arrays.fill(intArr, 3);
        System.out.println(Arrays.toString(intArr));//输出结果为【3,3,3】

        int[] intArr=new int[3];
        Arrays.fill(intArr, 3);
        Arrays.fill(intArr, 1, 2, 8);
        System.out.println(Arrays.toString(intArr));//输出结果为【3，8，3】

3.sort

        int[] intArr= {3,2,5,4,6,7,1,9,0};
        Arrays.sort(intArr);
        System.out.println(Arrays.toString(intArr));//输出结果是[0, 1, 2, 3, 4, 5, 6, 7, 9]

4.binarySearch:二分法查找，是应用于已经排序过的数组，来找出指定的元素下标

        int[] intArr= {3,2,5,4,6,7,1,9,0};
        System.out.println(Arrays.binarySearch(intArr, 0));//这里还没有对数组进行排序，输出结果为-1（错误的）
        Arrays.sort(intArr);
        int index=Arrays.binarySearch(intArr, 5);
        System.out.println(index);//对已经排序过的数组进行查找元素，其输出结果为5（正确的）

关于数组的拷贝：

1.System.arrayCopy();

        int[] intArray= {1,2,3,4,5};
        int[] copyArray=new int[3];
        //已经存在两个数组对象，使用System.arrayCopy。
        System.arraycopy(intArray, 0, copyArray, 0, copyArray.length);//参数意义：源数组，原数组开始copy的index，目标数组，目标数组开始copy的index，copy长度
        System.out.println(Arrays.toString(copyArray));
        

2.Arrays.copyOf()

        String[] strArr= {"I","Love","You"};
        //当前只有一个数组，使用copyOf方法。是先创建一个指定长度的数组，之后再使用System.arrayCopy（），将数据拷贝进去。返回一个拼接的String字符串
        System.out.println(Arrays.toString(Arrays.copyOf(strArr, 3)));//结果是 [I, Love, You]

3.clone()，该方法是Object类中protect类型方法，用来克隆一个完全一致的对象。可以在数组中使用。

        int[] intArray2= {1,2,3,4,5};
        //clone()方法
        int[] clone=intArray2.clone();
        clone[0]=1000;
        System.out.println(Arrays.toString(intArray2));//结果为【1，2，3，4，5】
        System.out.println(Arrays.toString(clone));//结果为【1000，2，3，4，5】
        System.out.println(clone);

上面的例子2、3都是使用一维数组举例的，都是为数组元素开辟了新的空间的。这种叫做深度拷贝。

如果为二维数组使用Arrays.copyOf()或者数组对象.clone()，都只创建了一个一维数组A，然后将第二维数组元素的引用赋值给了一维数组A，并没有为第二维度开辟新的空间。所以改变数组元素的时候，是相互影响的。这种叫做浅拷贝。如下：

Double[][] douArr=new Double[][] {{1.2,3.4},{5.66},{7.88,9.0,7.0}};
        //二维数组的copyOf（）
        Double[][] copy=Arrays.copyOf(douArr, 3);
        //这里修改了拷贝数组的第一个元素
        copy[0][0]=100000.00;
        //输出拷贝数组
        for (Double[] FirstcopyDou : copy) {
            for (Double SecondCopyDou : FirstcopyDou) {
                System.out.print(SecondCopyDou+",");//100000.0,3.4,5.66,7.88,9.0,7.0,
            }
            
        }
        System.out.println();
        //这里输出被拷贝数组
        for (Double[] FirstcopyDou : douArr) {
            for (Double SecondCopyDou : FirstcopyDou) {
                System.out.print(SecondCopyDou+",");//100000.0,3.4,5.66,7.88,9.0,7.0,
            }
            
        }

下面是简略的内存分配图：

提到数组，这里扩展一下可变参数方法（这个方法是将传入的参数包装成一个数组，以助于我们可以不用显示创建数组）：

下面是方法举例：

package com.claire.vairableParameter0701;

public class BookTestVar {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        VarString varObj=new VarString();
        varObj.var("I","Love","you");//可以自行判断去调用参数为String的方法
        varObj.var(new String[]{"who","am","I"});//可以自行判断去调用参数为String的方法
        
        varObj.var(1,2,3,4,5);//可以自行判断去调用参数为Integer的方法
        varObj.var(new Integer(1),new Integer(2));//可以自行判断去调用参数为Integer的方法

    }

}

class VarString{
    //这里定义一个可变参数列表的方法，限定只能输入String类型的0个或多个参数
    public void var(String... str) {
        for (String getStr : str) {
            System.out.print(getStr+" ");
            
        }
        System.out.println();
        
    }
    //重载上述的var（）方法，限定只能输入Integer类型的0个或多个参数
    public void var(Integer... i) {
        for (Integer getI : i) {
            System.out.print(getI);
        }
        System.out.println();
    }
}

上面程序的输出结果为：

I Love you
who am I
12345
12

通过上述程序举例，可以明显看出，我们的可变参数列表的方法是将参数包装成了一个数组，所以可以直接使用增强的for来获取元素。

注意：

　　1.可变参数列表的方法，是可以接受无参的调用的。如var();---------这样调用的时候，上述程序就会出现问题，因为无法判断应该调用哪个var方法（方法重载是根据参数个数、类型和顺序判断，当无参的时候，是判断不出的）。所以，当我们想使用这种方法来构建一个数组的时候，要么只使用一个可变参数列表的方法，要么就不要用。