自动化测试学习之路--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方法（方法重载是根据参数个数、类型和顺序判断，当无参的时候，是判断不出的）。所以，当我们想使用这种方法来构建一个数组的时候，要么只使用一个可变参数列表的方法，要么就不要用。
