测试驱动技术（TDD）系列之3：详解Java数组

在前面的文章中我介绍了如何通过junit4和TestNG实现参数化，这两种架构都通过二维数组来实现参数化，在这里我就给大家详细的介绍一下java数组。

Junit4定义参数化数据，代码如下：

public static Collection prepareData(){
Object [][]object= {{1,2,3},{0,2,2},{0,3,3}};
return Arrays.asList(object);
}
TestN

G定义参数化数据，代码如下：

@DataProvider     
public Object[][] dp1() {       
return new Object[][] {         
new Object[] { 1, 1,0 },        
 new Object[] { 2, 1,1 },         
new Object[] { 2, 1,2 },      
 };  
}

数组的定义

在java中，数组是一种最简单的复合数据类型。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

type arrayName[ ]；

类型(type)可以为Java中任意的数据类型，包括简单类型和复合类型。

例如：

int intArray[ ]；

Date dateArray[];

讲到这里，有的同学可能会问？为什么要用数组呢？用变量也可以解决问题啊!但如果现在要求定义1000个整型变量，那么该如何定义呢?定义的结构如下：

int i1, i2, i3, ... i1000;

这个时候如果按照此类方式定义就会非常麻烦，因为这些变量彼此之间没有任何的关联，也就是说如果现在突然再有一个要求，要求你输出这1000个变量的内容，意味着你要编写System.out.println()语句1000次。

数组的初始化

（1）静态初始化,即定义数组的同时给数组赋值

intintArray[]={1,2,3,4};

String stringArray[]={"abc", "How", "you"};

（2）动态初始化，即先定义数组后给数组赋值

1）简单类型的数组

int intArray[];   //声明未初始化

int Array =newint[5];// 定义占用空间大小（5个int）

2）复合类型的数组

例子1

String stringArray[ ];

String stringArray =newString[3];/* 开辟了一个长度为3的数组 */ 

stringArray[0]=newString("How");//为第一个数组元素开辟空间

stringArray[1]=newString("are");//为第二个数组元素开辟空间

stringArray[2]=newString("you");//为第三个数组元素开辟空间

例子2

这里强调下，数组type arrayName[ ]中的type代表类型，可以是我们熟悉的String、Integer等类型，也可以是我们自定义的类类型，例如

public class Car {
    public void drive() {};
    public void brake() {};
}
Car car1=new Car();
Car car2=new Car();
Car car3=new Car();
//定义一个Car类型的数组，并存放Car类的实例
Car[] carArray = new Car[3];  
carArray[0]=car1;
carArray[1]=car2;
carArray[2]=car3;

数组元素的调用

数组元素的调用方式为：

arrayName[index]

index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性。

arrayName[0] 代表数组arrayName的第一个元素。

length指明它的长度，例如：intArray.length指明数组intArray的长度。

arrayName[intArray.length-1] 代表数组arrayName的最后一个元素。

4.实例

int [] array1={1,2,3};
for(int i=0;i<array1.length;i++)
            {
                System.out.println(array1[i])；
            }

数组的引用

举个例子来讲解数组的引用

public class ArrayDemo {

    public static void main(String args[]) {

        int data[] = null;
        data = new int[3]; //开辟一个长度为3的数组，data指向这个数组的起始地址
        int temp[] = null; //声明数组对象
        data[0] = 1;
        data[1] = 2;
        data[2] = 3;
        tmp = data;  //tmp指向data所指向的数组地址
        tmp[0] = 9;
        for(int i = 0; i < temp.length; i++) {
            System.out.println(data[i]);
        }
    }
}

运行代码将会输出：

9

2

3

首先data指向这个数组的起始地址，由于tmp初始值为null，所以没有指向任何地址。

执行tmp = data;后，tmp和data都指向了这个数组的起始地址

执行tmp[0] = 9;后，数组里第一个位置的值变成了9 ，所以data[0]也是9。

二维数组

在之前所使用的数组发现只需要一个索引就可以进行访问，那么这样的数组实际上非常像一个数据行的概念。通一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组

二维数组本质上是行列集合，要确定某一个数据需要行索引和列索引来进行定位。数据使用的结构是“数组名称[行索引][列索引]”，所以这样的结构就是一个表的结构。

代码如下：

int data[][] = new int[][] {
            {1, 2}, {3, 4, 5}, {6, 7, 8, 9}

};

//外部的循环i控制输出的行数，即有几个{}；而内部的循环j控制输出列数，即{}里面有几个数据

        for(int i = 0; i < data.length; i++) {
            for(int j = 0; j < data[i].length; j++) {
                System.out.print("data[" + i + "][" + j+ "]=" + data[i][j]+ "、");
            }
        }

输出

data[0][0]=1、data[0][1]=2、

data[1][0]=3、data[1][1]=4、data[1][2]=5、

data[2][0]=6、data[2][1]=7、data[2][2]=8、data[2][3]=9、

多维数组之三维数组

三维数组中每个元素都是一个二维数组，定义如下

int[][][] array ={
                {
                       { 1, 2, 3 },
                       { 4, 5, 6 },
                       { 7, 8, 9 }
                },
                {
                       { 10, 11 },
                       { 12, 13 }
                },
                {
                       { 14, 15, 16 },
                       { 17, 18 }
                }
        };

同理，我们可以推导出4维数组以及n维数组的定义，但是在实际应用中就极其有限了，这里也就不再赘述了。