java-04 数组和二维数组

java 中内存分配地址值以及栈和堆得区别：

##########数组操作的两个常见小问题（越界和空指针）##############

数组索引越界异常，访问了不存在的索引：

空指针：

#################数组常见操作#################

/*
 * 依次输出数组数组中的每一个元素
 */
public class ShuZu {
    public static void main(String[] args) {
        int [] arry = {11,22,33,44,55,66};
        for (int i = 0; i < arry.length; i++) {
            System.out.println("数组的第"+i+"个是"+arry[i]);

        }

    }

}
结果：

数组的第0个是11
数组的第1个是22
数组的第2个是33
数组的第3个是44
数组的第4个是55
数组的第5个是66

改进版：

/*
 * 依次输出数组数组中的每一个元素
 */
public class ShuZu {
    public static void main(String[] args) {
        int [] arry = {11,22,33,44,55,66};
        printArry(arry);
        }
    public static void printArry(int [] arry){
        for (int i = 0; i < arry.length; i++) {
            System.out.println(arry[i]);
        }
    }
}

2.数组操作获取数组中的最大最小值：

/*
 * 输出数组中的最大值
 */
public class ShuZu {
    public static void main(String[] args) {
        int [] arry = {44,33,22,11,55,66};
        int result = max(arry);
        System.out.println("数组中的最大值是："+result);
        }
    public static int max(int [] arry){
        int max = arry[0];
        for (int i = 0; i < arry.length; i++) {

            if(arry[i]>max){
                max = arry[i];

            }

        }
        return max;
    }
}

结果：
数组中的最大值是：66

#################数组逆序#################

/*
    数组元素逆序 (就是把元素对调)

    分析：
        A:定义一个数组，并进行静态初始化。
        B:思路
            把0索引和arr.length-1的数据交换
            把1索引和arr.length-2的数据交换
            ...
            只要做到arr.length/2的时候即可。
*/
class ArrayTest3 {
    public static void main(String[] args) {
        //定义一个数组，并进行静态初始化。
        int[] arr = {12,98,50,34,76};

        //逆序前
        System.out.println("逆序前：");
        printArray(arr);

        //逆序后
        System.out.println("逆序后：");
        //reverse(arr);
        reverse2(arr);
        printArray(arr);
    }

    /*
        需求：数组逆序
        两个明确：
            返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组)
            参数列表：int[] arr
    */
    public static void reverse(int[] arr) {
        /*
        //第一次交换
        int temp = arr[0];
        arr[0] = arr[arr.length-1-0];
        arr[arr.length-1-0] = temp;

        //第二次交换
        int temp = arr[1];
        arr[1] = arr[arr.length-1-1];
        arr[arr.length-1-1] = temp;

        //第三次交换
        int temp = arr[2];
        arr[2] = arr[arr.length-1-2];
        arr[arr.length-1-2] = temp;
        */
        //用循环改进
        for(int x=0; x<arr.length/2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }

    public static void reverse2(int[] arr) {
        for(int start=0,end=arr.length-1; start<=end; start++,end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) { //这是最后一个元素
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

#################二维数组##################

############二维数组遍历#####################

public class ErW {
    public static void main(String[] args) {
        int [][] tarry = {{22,66,44},{77,33,88},{25,45,65},{11,69,99}};
        for (int i = 0; i < tarry.length; i++) {
            System.out.println(i+"数组:");
            for (int j = 0; j < tarry[i].length; j++) {
                System.out.print(tarry[i][j]+"\t");

            }
            System.out.println();
        }

    }

}
结果：

0数组:
22 66 44
1数组:
77 33 88
2数组:
25 45 65
3数组:
11 69 99

函数是遍历二维数组：

public class ErW {
    public static void main(String[] args) {
        int [][] tarry = {{22,66,44},{77},{25,45,65},{11,69,99}};
        printArry(tarry);
        /*
        for (int i = 0; i < tarry.length; i++) {
            System.out.println(i+"数组:");
            for (int j = 0; j < tarry[i].length; j++) {
                System.out.print(tarry[i][j]+" ");

            }
            System.out.println();
        }
        */

    }
    public static void printArry(int [][]tarray ) {

        for (int i = 0;  i < tarray.length; i++) {
            for (int j = 0; j < tarray[i].length; j++) {
                System.out.print(tarray[i][j]+" ");
            }
            System.out.println();
        }

    }

}
结果：

22 66 44
77
25 45 65
11 69 99

求和：

public class ErW {
    public static void main(String[] args) {
        int [][] tarry = {{22,66,44},{77,33,88},{25,45,65},{11,69,99}};
        printArry(tarry);
        /*
        for (int i = 0; i < tarry.length; i++) {
            System.out.println(i+"数组:");
            for (int j = 0; j < tarry[i].length; j++) {
                System.out.print(tarry[i][j]+" ");

            }
            System.out.println();
        }
        */

    }
    public static void printArry(int [][]tarray ) {
        int sum = 0;
        for (int i = 0;  i < tarray.length; i++) {
            for (int j = 0; j < tarray[i].length; j++) {
                sum += tarray[i][j]    ;
            }
            System.out.println("sum"+i+":"+sum);
        }

    }

}

输出结果为：

sum0:132
sum1:330
sum2:465
sum3:644

#############杨辉三角################

/*

    需求：打印杨辉三角形(行数可以键盘录入)

    1
    1 1
    1 2 1
    1 3 3 1
    1 4 6 4 1
    1 5 10 10 5 1

    分析：看这种图像的规律
        A:任何一行的第一列和最后一列都是1
        B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

    步骤：
        A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
          这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值
            从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据：");
        int n = sc.nextInt();

        //定义二维数组
        int[][] arr = new int[n][n];

        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }

        //按照规律给其他元素赋值
        //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的，就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始，因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }

        //遍历这个二维数组。
        /*
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
        */
        //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}
结果：

please a number:
6
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1