java 数组的测试_自动化测试学习之路--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 (intSecondDimensional : 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,

}

}

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

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

下面是方法举例：

packagecom.claire.vairableParameter0701;public classBookTestVar {public static voidmain(String[] args) {//TODO Auto-generated method stub

VarString varObj=newVarString();

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的方法

}

}classVarString{//这里定义一个可变参数列表的方法，限定只能输入String类型的0个或多个参数

public voidvar(String... str) {for(String getStr : str) {

System.out.print(getStr+" ");

}

System.out.println();

}//重载上述的var()方法，限定只能输入Integer类型的0个或多个参数

public voidvar(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方法(方法重载是根据参数个数、类型和顺序判断，当无参的时候，是判断不出的)。所以，当我们想使用这种方法来构建一个数组的时候，要么只使用一个可变参数列表的方法，要么就不要用。