java 二维数组

public class Lesson{
 public static void main(String [] args){
 
  //二维数组的声明方式：
  //数据类型 [][] 数组名称 = new 数据类型 [长度][长度] ;
  //数据类型 [][] 数组名称 = {{123},{456}} ;
  
  
  int [][] num = new int [3][3]; //定义了三行三列的二维数组
  num[0][0] = 1; //给第一行第一个元素赋值
  num[0][1] = 2; //给第一行第二个元素赋值
  num[0][2] = 3; //给第一行第三个元素赋值
  
  num[1][0] = 4; //给第二行第一个元素赋值
  num[1][1] = 5; //给第二行第二个元素赋值
  num[1][2] = 6; //给第二行第三个元素赋值
  
  num[2][0] = 7; //给第三行第一个元素赋值
  num[2][1] = 8; //给第三行第二个元素赋值
  num[2][2] = 9; //给第三行第三个元素赋值
  for(int x = 0; x
   for(int y = 0; y
    System.out.print(num[x][y]);
   }
   System.out.println("/n");
  }
 }
}
//数组值arr[x][y]表示指定的是第x行第y列的值。
//在使用二维数组对象时，注意length所代表的长度，
//数组名后直接加上length(如arr.length)，所指的是有几行(Row)；

//指定索引后加上length(如arr[0].length)，指的是该行所拥有的元素，也就是列(Column)数目。

1. //1.二维数组的定义  
2. //2.二维数组的内存空间  
3. //3.不规则数组  
4. package me.array;  
5. public class Array2Demo{  
6.       
7.       
8.     public static void main(String[] args){  
9.           
10.           
11.         //定义二维数组  
12.         int[ ] [ ] arr={{1,2,3},{4,5,6}};  
13.         //静态初始化  
14.            
15.         //打印出二维数组  
16.           
17.         for(int i=0;i<arr.length;i++){  
18.               
19.             for(int j=0;j<arr[i].length;j++){  
20.                       
21.                 System.out.print(arr[i][j]+" ");  
22.                   
23.             }  
24.             //输出一列后就回车空格  
25.             System.out.println();  
26.               
27.         }  
28.           
29.     }  
30.       
31. }  

在描述算法之前，先看看下面的5*5的表格：

 1 3 4 10 11 2 5 9 12
 19
 6 8 13 18 20 7 14 17 21 24 15 16 22 23 25
    上面的表格很容易看出规律。就是从左上角第一个格开始（起始为1），然后延右上角到左下角的斜线。先从下到上，再从上到下。开始按数字递增排列。也就是说每一个斜线上分别有如下几组数字：

1    2 3     4 5 6       7 8 9 10      11 12 13 14 15          16 17 18 19      20 21 22      23 24       25

    由于是先从上到下（1可以看做是从上到下），再从下到上，很象一条蛇，因此，该数字表格也可称为蛇形矩阵。现在要与一个方法（或函数），方法的参数是一个int类型，表示n，方法返回一个二维数组，表示要获得的往返接力数字表格。
    实际上，这个算法并不复杂，只需要从分别获得1至n^2中每个数字对应的二维数组的坐标就可以了。先拿这个5行5列的表格来说，求出上面每组数组对应的坐标（起始位置为0）。

第0组
第1组
第2组
第3组
第4组
第5组
第6组
第7组
第8组
1     
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 
20 21 22
23 24
25
(0,0)
(1,0)   (0,1)
(0,2)   (1,1)   (2,0)
(3,0)   (2,1)   (1,2)   (0,3)
(0,4)   (1,3)   (2,2)   (3,1)   (4,0)
(4,1)   (3,2)   (2,3)   (1,4)
(2,4)   (3,3)   (4,2)
(4,3)   (3,4)
(4,4)
                                 
    从上面的从标可以看出一个规律。  左上角的半个表格（以对角线分界）的横坐标和纵坐标从0开始，每一组增1，直到增至表格的边界（n - 1），而且是交替的，也就是说，偶数行是列增，行减小，行+列=组的索引。而右下角的4组数字虽然行、列也是交替增长的，但递减的行或列总是从(n - 1)开始（对于本例，是从4开始），而递增的行或列总是从index - n + 1开始，其中index表示组的索引。这就可以得出一个算法。实现代码如下：

public static int[][] getGrid(int n)
{
    int[][] array = new int[n][n];
    int row = 0, col = 0, m = 1;
    //  用于控制奇偶组，false表示偶组，true表示奇组
    boolean isRow = false;
    //  i表示当前组的索引，从0开始
    for (int i = 0; i < (2 * n - 1); i++)
    {
        row = i;
        while (row >= ((i < n) ? 0 : i - n + 1))
        {
            //  如果处理的是右下角表格中的数字，行或列最大不能超过n-1
            if (row > (n - 1))
                row = n - 1;
            col = i - row;
            if (isRow)
                array[row][col] = m;
            else  //  将row变成列，将col变成行
                array[col][row] = m;
            m++;
            row--;
        }
        //  切换奇偶组
        isRow = !isRow;
    }
    return array;
}

   另一种算法

  上面实现的算法需要循环N*N次才可以生成蛇形矩阵。但仔细分析一下，还可以稍微变换一下这个算法，使循环次数减小至N*N/2。我们上学时曾学过用高斯的方法计算1+2+3+...+100，   1 + 100 = 101，2 + 99 = 101，...，50+51 = 101，因此，结果是101 * 50 = 5050。很方便。我们这个算法也可采用类似的方法。仔细观察上面5*5的数字表格发现，算出左上角的矩阵中每一个数字后，都可以直接获得右下角度某个位置的数字。例如在(0,0)位置的1，可以向到(4,4)位置的25，(1,2)位置的9可以得到(3,2)位置的17。我们发现，每一对数之和都为26。而且它们坐标的关系是(row,col)，(n - row - 1, n - col - 1)。因此，只要得到左上角的半个矩阵，就可以得出右下角的另外半个矩阵。如果n为奇数，对角线中间的一个数（在5*5的矩阵中是13）与之对应的数是其自身。好，我们看看改进的算法的实现：

public static int[][] getGrid1(int n)
{
    int[][] array = new int[n][n];
    int row = 0, col = 0, m = 1;
    int number1 =  (n * n / 2 + n * n % 2);
    int number2 = n * n + 1;        
    boolean isRow = false;
    //  number1表示要计算的蛇形矩阵中最大的数字，对于5*5矩阵来说该数是13
    for (int i = 0; m < number1; i++)
    {
        row = i;
        while (row >= 0)
        {
            col = i - row;
            if (isRow)
            {
                array[row][col] = m;
                //  填充与m对应的另外一个数
                array[n - row - 1][n - col - 1] = number2 - m;
            }
            else
            {
                array[col][row] = m;
                //  填充与m对应的另外一个数
                array[n - col - 1][n - row - 1] = number2 - m;

            }
            m++;
            if(m >= number1) break;
            row--;
        }
        isRow = !isRow;
    }
    return array;
}

   
   上面的算法虽然将循环次数减少了一半，但每次循环的计算量增加了，因此，算法总体效率并没有提高。至于使用哪个算法，可根据实际情况决定。
   如果想输出n=10的数字表格，可以使用int[][] grid = getGrid(10)或int[][] grid1 = getGrid1(10)，会得到同样的结果。输出grid和grid1，看看是不是下面的结果：

134101121223637552591220233538545668131924343953577271418253340525871731517263241515970748516273142506069758486283043496168768387942944486267778288939545476366788189929699466465798090919798100

不规则二维数组

http://blog.csdn.net/incyanggan/article/details/9819005

[java] view plaincopyprint?

1. //1.二维数组的定义  
2. //2.二维数组的内存空间  
3. //3.不规则数组  
4. package me.array;  
5. public class Array2Demo{  
6.       
7.       
8.     public static void main(String[] args){  
9.           
10.         //创建和打印不规则二维数组  
11.         int arr[ ][ ];  
12.           
13.         arr=new int[3][];//现在说明为不规则数组  
14.           
15.         arr[0]=new int[10];//arr[0]指向另一个一位数组  
16.         arr[1]=new int[3];  
17.         arr[2]=new int[4];  
18.           
19.         //赋值  
20.         for(int i=0;i<arr.length;i++){  
21.               
22.             for(int j=0;j<arr[i].length;j++){  
23.                   
24.                 arr[i][j]=j;  
25.             }  
26.               
27.         }  
28.           
29.         //输出  
30.         for(int i=0;i<arr.length;i++){  
31.               
32.             for(int j=0;j<arr[i].length;j++){  
33.                   
34.                 System.out.print(arr[i][j]+" ");  
35.             }  
36.             System.out.println();  
37.         }  
38.           
39.         /*输出结果： 
40.         0 1 2 3 4 5 6 7 8 9  
41.         0 1 2  
42.         0 1 2 3  
43.         *///  
44.           
45.     }  
46.       
47. }  

[java] view plaincopyprint?

1. //3.编写一个方法，返回double型二维数组，数组通过解析字符串参数获得。  
2. //如"1,2;3,4,5;6,7,8"  
3. //d[0,0]=1.0 d[0,1]=2.0 d[1,0]=3.0 ....  
4. package me.parser;  
5. public class TestString{  
6.       
7.     public static void main(String[] args){  
8.           
9.         //1.用字符串分解split(";")成三个字符串数组  
10.         //2.再分解split(",")  
11.           
12.         //声明一个二维数组用来装分解好的字符  
13.           
14.           
15.         String s="1,2;3,4,5;6,7,8";  
16.         //以split()方法 分解  
17.         String[] sFirst=s.split(";");  
18.           
19.         String[][] word=new String[sFirst.length][];  
20.           
21.         int flag=0;  
22.         for(int i=0;i<sFirst.length;i++){  
23.               
24.             //打印出已经分开的  
25.             //System.out.println(sFirst[i]);  
26.             /*这条语句输出 
27.             1,2 
28.             3,4,5 
29.             6,7,8 
30.             *///接下来在按照 ,分开他们放入一个一维数组  
31.               
32.             String[] sSecond=sFirst[i].split(",");  
33.              //~ System.out.println(sSecond.length);  
34.             //~ /*输出:  
35.             //~ 2  
36.             //~ ---------------------------------  
37.             //~ 3  
38.             //~ ---------------------------------  
39.             //~ 3  
40.             //~ ---------------------------------             
41.             //~ *///说明每次sSencond这个一维数组的长度不同  
42.             word[i]=new String[sSecond.length];//这步确定行不规则数组的每行长度  
43.       
44.             //为这个数组赋值  
45.             for(int j=0;j<sSecond.length;j++){  
46.                       
47.                 word[i][j]=sSecond[j];  
48.             }  
49.               
50.             System.out.println("---------------这是第"+(i+1)+"次循环-------------------");  
51.         }  
52.           
53.         //输出二维数组  
54.         System.out.println("输出二维数组-------------------");  
55.         for(int i=0;i<word.length;i++){  
56.             for(int j=0;j<word[i].length;j++){  
57.                   
58.                 System.out.print(word[i][j]+" ");  
59.             }  
60.             System.out.println();  
61.         }  
62.         /*结果： 
63.         ---------------这是第1次循环------------------- 
64.         ---------------这是第2次循环------------------- 
65.         ---------------这是第3次循环------------------- 
66.         输出二维数组------------------- 
67.         1 2  
68.         3 4 5  
69.         6 7 8  
70.         输出二维数组------------------- 
71.         *///  
72.     }  
73. }