大龄屌丝自学笔记Java零基础到菜鸟013

数组，二维数组，杨辉三角形

1、数组

数组是存储同一数据类型的多个元素的集合。

数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：数据类型[] 数组名  //数组必须初始化之后，才能使用

数组动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];  如：int[] a = new a[3];  //初始化时，只指定数组的长度   

数组静态初始化1：数据类型[] 数组名 = new 数据类型[]{元素1 , ... , 元素n};  如：int[] a = new a[]{1,2,3};  //初始化时，即指定每个数组元素的初始值

数组静态初始化2：数据类型[] 数组名 = {元素1 , ... , 元素n};  如：int[] a = {1,2,3};  //初始化时，即指定每个数组元素的初始值

数组元素的值：数组名[索引] ，如：int[] a = {1,2,3};  int n = a[1];  //n=2，数组的索引从0开始，数组是引用类型

class Fin{
    public static void main(String[] args){
        int[] a=int[3];
        a[0]=1;
        a[1]=2;
        a[2]=3;

        int[] b=a;
        b[1]=4;

        System.out.println(b)     //输出数组b的地址（与数组a的地址相同）
        System.out.println(a[1])  //a[1]=4
    }
}

常见问题：索引越界异常、空指针异常。

索引越界异常：数组的索引大于数组的元素个数，访问不存在的索引，如：int[] a = int[3];  int n = a[5];   //报错

空指针异常：数组已不再指向【堆】内存，仍然访问数组，如：int[] a = int[3];  n = null;  int n = a[0];  //报错

获取数组的长度：数组名.length;  //int

// 数组的逆序
public static void liverpool(int[] arr){
    int k=0;
    for(int i=0,j=arr.length-1;i<j;i++,j--){
        k=arr[i];
        arr[i]=arr[j];
        arr[j]=k;
    }
}

2、二维数组

二维数组就是元素为一维数组的数组。

二维数组的定义格式：数据类型[][] 数组名

二维数组动态初始化1：数据类型[] 数组名 = new 数据类型[m][n];  如：int[][] a = new a[2][3];  //m（2）个长度为n（3）的一维数组   

二维数组动态初始化2：数据类型[] 数组名 = new 数据类型[m][];  如：int[][] a = new a[2][];  //m（2）个未初始化的一维数组   

二维数组静态初始化1：数据类型[] 数组名 = new 数据类型{{元素...}, ... ,{元素...}};  如：int[][] a = new int[][]{{1,2,3} , {4,5} , {6}};

二维数组静态初始化2：数据类型[] 数组名 = {{元素...}, ... ,{元素...}};  如：int[][] a = {{1,2,3} , {4,5} , {6}};

二维数组元素的值　：数组名[索引][索引] ，如：int[][] a = {{1,2,3} , {4,5,6}};  int n = a[1][2];  //n=6

3、杨辉三角形

每行的第一列、最后一列，值为1；第三行开始，每列（最后一列除外）的值等于上一行的前一列和上一行的本列之和，即a[m][n]=a[m-1][n-1]+a[m-1][n]。

class Test{    
    public static void main(String[] args){
        yang(5);
    }

    public static void  yang(int n){    
        if(n>0){
            //二维数组
            int[][] y=new int[n][];
            if(n==1){
                y[0]=new int[]{1};
            }else if(n==2){
                y[0]=new int[]{1};
                y[1]=new int[]{1,1};
            }else{
                y=new int[n][];
                y[0]=new int[]{1};
                y[1]=new int[]{1,1};
                for(int i=2;i<n;i++){
                    y[i]=new int[i+1];
                    for(int j=0;j<=i;j++){
                        if(j==0||j==i){
                            y[i][j]=1;
                        }else{
                            y[i][j]=y[i-1][j-1]+y[i-1][j];
                        }
                    }
                }
            }
            //输出
            for(int i=0;i<y.length;i++){
                for(int j=0;j<y[i].length;j++){
                    System.out.print(y[i][j]+ "  ");
                }
                System.out.println("");
            }    
        }else{
            System.out.print("bug");  //n<1，bug
        }
    }
}