int[][] x = {{1},{1,2},{1,2,3}};
int[] x[] = new int[5][];   //通过类似这样的方式声明（new int[5][]），得到一个可动态生成的二维数组
int x[][] = new int[5][5];
//等号后面的方式可以与的等号前面的方式任意组合使用
//但这种方式是不正确的：x[1] = {1};

import java.util.Scanner;
public class MultiArray
{
    public static void main(String[] args) {
        
        /*
        0 0 0 0 0 0
        0 0 1 0 0 0 
        0 2 0 3 0 0
        0 0 0 0 0 0
        */
?
        //创建二维数组
        int[][] arr = new int[4][6];//默认元素0
?
        /*
            int[][] arr;
            arr = new int[4][6];
        */
?
        //重新指定值
        arr[1][2] = 1;
        arr[2][1] = 2;
        arr[2][3] = 3;
?
        //遍历二维数组
        //说明
        //1. arr.length 二维数组中，含有多少个一维数组
        for( int  i = 0; i <  arr.length; i++) {
                
                //2. arr[i].length 返回 arr[i] 一维数组有多少个元素
                for( int j = 0; j < arr[i].length; j++) {
                    //3. arr[i][j] 表示返回 第i个一维数组的第j个元素值
                    System.out.print(arr[i][j] + "\t"); 
                }
                System.out.println();
        }
    }
}
?

import java.util.Scanner;
public class MultiArray2
{
    public static void main(String[] args) {
?
        /*生成类似这样的二维数组：
                            1
                            2 2
                            3 3 3
        
        //分析
        //1. 二维数组的有 3 个一维数组
        //2. 但是每个一维数组的元素个数不同
        */
?
        int[][] arr = new int[10][];
        for( int i = 0; i < arr.length; i++) {
            //分配空间，一定要注意这里需要i+1！！！
            arr[i] = new int[i+1];  
            //遍历赋值
            for( int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i+1;
            }
        }
?
        //输出遍历
        for( int  i = 0; i <  arr.length; i++) {
                
                //2. arr[i].length 返回 arr[i] 一维数组有多少个元素
                for( int j = 0; j < arr[i].length; j++) {
                    //3. arr[i][j] 表示返回 第i个一维数组的第j个元素值
                    System.out.print(arr[i][j] + "\t"); 
                }
                System.out.println();
        }
    }
}

/** 
    杨辉三角：   打印十行
    1
    1 1
    1 2 1
    1 3 3  1
    1 4 6  4  1
    1 5 10 10 5 1
    
    1. 第一行有 1 个元素, 第 n 行有 n 个元素
    2. 每一行的第一个元素和最后一个元素都是 1
    3. 中间元素是（上面元素+上面元素的前面元素），例 3 = 1+2，10 = 4+6，5 = 4+1
        
    思路：
        1.每行的元素个数 = 行数 ，由此动态定义二维数组
        2.分析中间元素下标  3 = 1 + 2   3的下标为arr[3][1],1的下标为arr[2][0],2的下标为arr[2][1]
        3.可以看出 中间元素 arr[i][j] = arr[i-1][j-1] + arr[i-1][j]（从第三行开始！）
        4.将二维数组依次规律动态赋值即可
*/
import java.util.Scanner;   
public class YangHui
{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要打印的杨辉三角层数：");
        int layer = input.nextInt();
        int[][] yh = new int[layer][]; 
        System.out.println();
?
        //仔细思考二维数组的动态生成过程，这里不需要担心出现空指针的情况
        //首先初始化第一行和第二行 避免下面出现空指针异常
//      yh[0] = new int[]{1};   //yh[0] = {1}; 是错误的！！
//      yh[1] = new int[]{1,1};
?
        //动态生成二维数组,并赋值
        for(int i = 0;i< layer;i++){    //层数，从第三层开始
            yh[i] = new int[i+1];       //生成此层的数组
            for (int j = 0;j < yh[i].length;j++ )   // 第n层有n个元素
            {
                if(j == 0 || j == yh[i].length-1){  //第一个和最后一元素
                    yh[i][j] = 1;
                }else{
                    yh[i][j] = yh[i-1][j-1] + yh[i-1][j];
                }
            }
        }
?
        //遍历二维数组进行打印输出
        for(int i = 0;i< layer;i++){    
            for (int j = 0;j < yh[i].length;j++)    
            {
                System.out.print(yh[i][j]+"\t");
            }
            System.out.println();
        }
    }
}
?

import java.util.Scanner;   
public class Think
{
    public static void main(String[] args){
        int i = 3;
        do{
            if(i--%2 == 0){     //清楚这里的运算顺序
                System.out.println(i);
                break;
            }
            System.out.println(i);
        }while(i>0);
    }
}
?
//答案 ： 2  1