Java中的二维数组的定义与学习

//定义二维数组写法1   
class numthree
{
public static void main(String[] args)
{
float[][] numthree;             //定义一个float类型的2维数组
numthree=new float[5][5];       //为它分配5行5列的空间大小
numthree[0][0]=1.1f;            //通过下标索引去访问     1行1列=1.1
numthree[1][0]=1.2f;                                  // 2行1列=1.2
numthree[2][0]=1.3f;                                  // 3行1列=1.3
numthree[3][0]=1.4f;                                  // 4行1列=1.4
numthree[4][0]=1.5f;                                  // 5行1列=1.5
System.out.println(numthree[0][0]); //打印换行输出喽 
System.out.println(numthree[1][0]);
System.out.println(numthree[2][0]);
System.out.println(numthree[3][0]);
System.out.println(numthree[4][0]);
}
}
//定义二维数组写法2   定义的同时分配空间大小
class numfour
{
public static void main(String[] args)
{
   short[][] numfour=new short[5][8]; //定义一个short类型的数组同时为它分配5行8列的空间大小
   numfour[0][7]=10;
   numfour[1][6]=20;
   numfour[2][5]=30;
   numfour[3][4]=40;
   numfour[4][3]=50;
   System.out.println(numfour[0][7]);
   System.out.println(numfour[1][6]);
   System.out.println(numfour[2][5]);
   System.out.println(numfour[3][4]);
   System.out.println(numfour[4][3]);
}
}


//定义二维数组写法3        不规则数组 

class numfive
{
public static void main(String[] args)
{
long[][] numfive=new long[5][];     //定义一个long类型的不规则数组 
numfive[0]=new long[5];             //为第1行分配5列
numfive[1]=new long[6];             //为第2行分配6列
numfive[2]=new long[7];             //为第3行分配7列
numfive[3]=new long[8];             //为第4行分配8列
numfive[4]=new long[9];             //为第5行分配9列
numfive[0][4]=10000000000L;         //1行5列=10000000000
numfive[1][5]=20000000000L;         //2行6列=20000000000
numfive[2][6]=30000000000L;         //3行7列=30000000000
numfive[3][7]=40000000000L;         //4行8列=40000000000
numfive[4][8]=50000000000L;         //5行9列=50000000000
System.out.println(numfive[0][4]); //打印换行输出喽 
System.out.println(numfive[1][5]);
System.out.println(numfive[2][6]);
System.out.println(numfive[3][7]);
System.out.println(numfive[4][8]);
System.out.println(numfive[4][7]);
//打印输出一个没有定义数组元素的数组 java会自动将他初始化值为0 
} 
} 

//定义2维数组写法4    定义的同时赋初始值 
class numsix 
{ 
public static void main(String[] args) 
{ 
double[][] numsix={{1.111D,2.222D,3.333D},{4.444D,5.555D,6.666D}};//定义double型的数组分配3行3列的空间同时赋值 
System.out.println(numsix[0][0]); //打印换行输出1行1列=1.111 
System.out.println(numsix[1][1]); //打印换行输出2行2列=5.555 
} 
} 

//定义2维数组写法5   定义不规则的2维数组同时赋初始值 

class numseven
{
public static void main(String[] args)
{
int[][] numseven=new int[][]{{10,20,30},{40,50},{60}};
System.out.println(numseven[0][2]);
System.out.println(numseven[1][1]);
System.out.println(numseven[0][0]);
}
}

//定义2维数组写法6 定义不规则的2维数组同时赋初始值； 

class numeight
{
public static void main(String[] args)
{
int[][] numeight={{100,200,300,400},{500,600,700,800},{900,1000,1100,1200,1300}};
System.out.println(numeight[0][2]);
System.out.println(numeight[1][2]);
System.out.println(numeight[2][1]);
}
}

在java中，对数组的定义其实比较灵活；
例如对主函数的定义public static void main(String[] args) 也可以写成public static void main(String args[]) ,请注意[]的位置，[]可以放在数组类型的后面，也可以放在数组名的后面。

我们通过一个例子就可以很明显的看出来
先看源程序：

       //一维数组定义与输出 

class  less02
{
 public static void main(String[] args) 
 {
  int stu[]=new int[]{1,2,3};   //方法一
  //int stu[]={1,2,3};                 方法二
  //int []stu=new int[]{1,2,3};  方法三
  //int[] stu={1,2,3};                方法四
  for(int i=0;i<stu.length;i++)
   System.out.println(stu[i]);
 }
}


//二维数组定义与输出 
class less02 
{ 
public static void main(String args[]) 
{ 
  //int [][] num=new int[][]{{1,2,3},{4,5,6}};     方法一 
  int [][] num={{1,2,3},{4,5,6}};                      //方法二 
  for (int i=0;i<num.length ;i++ ) 
  { 
   for (int j=0;j<num[i].length ;j++ ) 
   { 
    System.out.print(num[i][j]+" "); 
   } 
   System.out.println(); 
  } 
} 
} 

对于一维数组的定义，我总结了四种；二维数组的定义，我中介了两种
有没有其他定义方法呢？还请大家共同来研究。


在java中数组被看成是一个对象

在定义数组时，有两种定义方法：int[] a 和int a[]；第二种是C/C++对数组定义方式，对于JAVA建议采用第一种定义方式。

1 一维数组的定义

 //定义包含三个元素的一维数组 

  int[] a = new int[3];  a = {1,2,3};//方法1，先new对象，然后赋值 

  int[] b = {1,2,3}; //方法2，直接赋值 

  int[] c = new int[3]{1,2,3}; //方法3，new后直接赋值 

注意：如果用new定义数组时，必须指定其维度，这样定义是错误的: int[] d = new int[];

如果无法确定其元素个数，可以这样定义:int[] e = {};

2 二维数组的定义

//定义一个3行5列的二维数组 

int[][] a = new int[3][5]; 

a = {{"a","a","a","a","a"}, {"b","b","b","b","b"}, {"c","c","c","c","c"} }; //方法1 

int[][] b = { 

            {"a","a","a","a","a"}, 
            {"b","b","b","b","b"}, 
            {"c","c","c","c","c"} 

        };//方法2 

int[][] c = new int[3][5]{{"a","a","a","a","a"}, {"b","b","b","b","b"}, {"c","c","c","c","c"} };

//方法3

定义二维数组必须指定其行数，列数可以指定，可以不指定。

这样定义是正确的：int[][] d = new int[3][]; 

这样定义是错误的：int[][] d = new int[][4]; int[][] d = new int[][]; 

也可以定义不规则数组： 

arr = new int[2][]; 

        arr[0] = new int[3]; 

        arr[1] = new int[5]; 

3 数组的长度

length是数组的一个属性(不是方法!)，对于一维数组int[] b = {1,2,3}; b.length的值是3，


对于二维数组，首先研究一下它的配置细节：

int[][] arr = new int[2][3]; 

上面这个程序片段中，配置了2行3列的二维数组对象，由于数据类型是int，所以数组元素的预设元素为0。

其实arr[0]、arr[1]是两个一维数组对象，其长度各为3，而arr类型是int[] []，内容值为arr[0]与arr[1]。其关系如图1所示。



因此arr.length与arr[0].length所表示的长度意义是不同的，arr.length表示的是数组的行数，arr[i].length表示的是指定行所包含的元素数。本例中，arr.length=2,arr[0].length=3。