二维数组用二重for循环遍历,但是如果其中每一个一维数组的值的个数不一样,用for就不好遍历了.比如
int [] []  arr=new int [3] []
arr[0]=new int [3]
arr[1]=new int [1]
arr[2]=new int [2]
这样的二维数组怎么遍历呀?

public class Array2d
{
   public static void main(String[] args)
   {
      int[i][j] twoD = new int[4][];
     
     twoD[0] = new int[4];
     twoD[1] = new int[5];
     twoD[2] = new int[6];
     twoD[3] = new int[7];
      for(int i=0;i<int[i].length;i++)
        {     
           for(int j=0;j<int[j].length;j++)
           System.out.print(int[j]+" ");
           System.out.print("\n");
        }  
  }
}
不知道对不对哎

一个二维数组int mat[] = {{1,2,3},{4,5,6]};在这个二维数组中，可以用length属性返回数组的长度，但返回的数组长度含义不同。比如：
mat.length    返回二维数组的长度，即二维数组的行数；    mat[0].length   返回的二维数组中第一个一位数组的长度。所以，可以对二维数组中第一个下标进行for循环，二维数组中每一个一位数组长度可以写为是mat[x].length

        int[][] arr ={{3,2,1,5},{4,5,6,3},{6,4,3,6,}};        //直接给二维数组赋值
                int sum = 0;
               
               
                for (int i = 0; i < arr.length; i++) {        //按二维数组的长度遍历
                        for (int j = 0; j < arr[i].length; j++) {        //二维数组中的一维数组
                               
                                System.out.println(arr[i][j]);        //循环输出二维数组中的值.
                        }
                }
这样就可以了 ， 注释什么的写的很清楚了

楼上正解~

为了消除下困意，我又把这个弄得好看了点儿~~

1. class  ArrTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[][] arr={{1,2,3},{4},{5,6}};
   
6.                 printArr(arr);
   
7.         }
   
8.         public static void printArr(int[][] arr)
   
9.         {
   
10.                 System.out.print("{");
    
11.                 for (int x=0;x<=arr.length-1 ;x++ )
    
12.                 {
    
13.                         for (int y =0;y<=arr[x].length-1 ;y++ )
    
14.                         {
    
15.                                 if(arr[x].length==1)
    
16.                                         System.out.print("{"+arr[x][y]+"},");
    
17.                                 else if(y==0)
    
18.                                         System.out.print("{"+arr[x][y]+",");
    
19.                                 else if(y==arr[x].length-1&&arr[x][y]!=arr[arr.length-1][arr[arr.length-1].length-1])
    
20.                                         System.out.print(arr[x][y]+"},");
    
21.                                 else if(arr[x][y]==arr[arr.length-1][arr[arr.length-1].length-1])
    
22.                                         System.out.print(arr[x][y]+"}");
    
23.                                 else
    
24.                                 System.out.print(arr[x][y]+",");
    
25.                         }
    
26.                 }
    
27.                 System.out.println("}");
    
28.                
    
29.         }
    
30. }
    

复制代码

一堆判断语句~自己都快晕了~~
我估计还得有更好的办法~~

打印出来的结果是这样的~~
{{1,2,3},{4},{5,6}}

自己给自己出的小题，勿笑。。。

王亚男 发表于 2012-3-9 01:46
楼上正解~

为了消除下困意，我又把这个弄得好看了点儿~~一堆判断语句~自己都快晕了~~

打印数组，用递归方便，以前有人讨论过。

public static void main(String[] args) {///！我没学过多维数组，目前我只知道多维的概念所以跃跃欲试
                //！！说实话我也很晕！！！
                //但是我怒了，它O了！
                                                                        int [] []  arr=new int [3] [];
                                            arr[0]=new int[] {0,1,2};//子数组0
                                                arr[1]=new int []{5};//子数组1
                                                arr[2]=new int[]{7,9};//子数组2
                                                  for(int i=0;i<arr.length;i++)//遍历所有子数组
                                              {     
                                                 for(int j=0;j<arr[i].length;j++){//遍历子数组0、1、2元素
                                                                                         System.out.print(arr[i][j]);
                                                 }
                                                 System.out.println();
        }

        }
期待鼓励！

还有什么不明白，尽管问，尽管拿去运行，我跟它斗上劲了！{:soso_e113:}

首先你要先明白2维数组中的概念
比如  int[][] arr=new int[n][];
arr是什么？   arr[n]  是什么  arr[n][] 又是什么？
arr是而为数组的一个引用对象，他存储在内存中的栈内存中，当new int[n][] 的时候就创建了二维数组了  而而为数组
是存放在堆内存当中的，  而系统把二维数组的首地址赋给了arr      这样arr就和二维数组之间建立了联系，arr指向二维数组的首地址
而二维数组是由1维数组组成的   所以arr[0] 又指向了一维数组的首地址   所以二维数组的长度就是arr.length  它里面的一维数组的长度
自然就是arr[0].length  0代表二维数组中的第一个元素
比如你要遍历   int[][] arr=new int[3][];所有的元素只需要这样就可以了
for (int i=0;i<arr.length ;i++ )
{
        for (int j=0;j<arr[i].length ;j++ )
        {
                System.out.println(arr[i][j]);
        }
}   

黄秋 发表于 2012-3-9 02:01
打印数组，用递归方便，以前有人讨论过。

好的！谢谢您！我查下相关的资料！

class  Arrayss
{
        public static void main(String[] args)
        {
                //最简单的说法就是  大循环套小循环

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

                for(int x=0;x<arr.length;x++)
                {
                   for(int y=0;y<arr[x].length;y++)
                         {
                                System.out.println("Arr"+arr[x][y]);
                         }
                }               

        }
}

打印结果是 0 0 0 0 0 0   0 .......哈哈

刚看到二维数组,所以不太明白,现在明白了~~~~谢谢楼上嘞

这哥们出现一个书写错----->int [] arr=new int[3]{}后面是大括号。

不管长度是否一样，用数组length就可以了啊！