/*
    二维数组：就是元素为一维数组的一个数组。
    
    格式1：
        数据类型[][] 数组名 = new 数据类型[m][n];
        
        m:表示这个二维数组有多少个一维数组。
        n:表示每一个一维数组的元素有多少个。
        
    注意：
         以下格式也可以表示二维数组
            a:数据类型 数组名[][] = new 数据类型[m][n];
            b:数据类型[] 数组名[] = new 数据类型[m][n];
        
*/
class Array2Demo {
    public static void main(String[] args) {
         //定义一个二维数组
         int[][] arr = new int[3][2];
         //定义了一个二维数组arr
         //这个二维数组有3个一维数组的元素
         //每一个一维数组有2个元素
         //输出二维数组名称
         System.out.println(arr); //地址值    [[I@175078b
         //输出二维数组的第一个元素一维数组的名称
         System.out.println(arr[0]); //地址值    [I@42552c
         System.out.println(arr[1]); //地址值    [I@e5bbd6
         System.out.println(arr[2]); //地址值    [I@8ee016
         //输出二维数组的元素
         System.out.println(arr[0][0]); //0
         System.out.println(arr[0][1]); //0
    }
}

 1 /*
 2     格式2：
 3         数据类型[][] 数组名 = new 数据类型[m][];
 4         
 5         m:表示这个二维数组有多少个一维数组。
 6         列数没有给出，可以动态的给。这一次是一个变化的列数。
 7 */
 8 class Array2Demo2 {
 9     public static void main(String[] args) {
10         //定义数组
11         int[][] arr = new int[3][];
12         
13         System.out.println(arr);    //[[I@175078b
14         System.out.println(arr[0]); //null
15         System.out.println(arr[1]); //null
16         System.out.println(arr[2]); //null
17         
18         //动态的为每一个一维数组分配空间
19         arr[0] = new int[2];
20         arr[1] = new int[3];
21         arr[2] = new int[1];
22         
23         System.out.println(arr[0]); //[I@42552c
24         System.out.println(arr[1]); //[I@e5bbd6
25         System.out.println(arr[2]); //[I@8ee016
26         
27         System.out.println(arr[0][0]); //0
28         System.out.println(arr[0][1]); //0
29         //ArrayIndexOutOfBoundsException
30         //System.out.println(arr[0][2]); //错误
31         
32         arr[1][0] = 100;
33         arr[1][2] = 200;
34     }
35 }

 1 /*
 2     格式3：
 3         基本格式：
 4             数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
 5         简化版格式：
 6             数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
 7             
 8         举例：
 9             int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
10             int[][] arr = {{1,2,3},{4,5},{6}};
11 */
12 class Array2Demo3 {
13     public static void main(String[] args) {
14         //定义数组
15         int[][] arr = {{1,2,3},{4,5},{6}};
16         
17         System.out.println(arr);
18         System.out.println(arr[0]);
19         System.out.println(arr[1]);
20         System.out.println(arr[2]);
21         
22         System.out.println(arr[0][0]); //1
23         System.out.println(arr[1][0]); //4
24         System.out.println(arr[2][0]); //6
25         
26         System.out.println(arr[0][1]); //2
27         System.out.println(arr[1][1]); //5
28         //越界
29         System.out.println(arr[2][1]); //错误
30     }
31 }

 1 /*
 2     需求：二维数组遍历
 3     
 4     外循环控制的是二维数组的长度，其实就是一维数组的个数。
 5     内循环控制的是一维数组的长度。
 6 */
 7 class Array2Test {
 8     public static void main(String[] args) {
 9         //定义一个二维数组
10         int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
11         
12         //请问谁代表{1,2,3}
13         //arr[0]就是第一个数组
14         //arr[0] = {1,2,3};
15         for(int x=0; x<arr[0].length; x++) {
16             System.out.println(arr[0][x]);
17         }
18         System.out.println("--------------");
19         
20         for(int x=0; x<arr[1].length; x++) {
21             System.out.println(arr[1][x]);
22         }
23         System.out.println("--------------");
24         
25         for(int x=0; x<arr[2].length; x++) {
26             System.out.println(arr[2][x]);
27         }
28         System.out.println("--------------");
29         
30         //用循环改进
31         for(int x=0; x<3; x++) {
32             for(int y=0; y<arr[x].length; y++) {
33                 System.out.print(arr[x][y]+" ");
34             }
35             System.out.println();
36         }
37         System.out.println("--------------");
38         
39         //这个时候，注意了，3是我们根据上面的代码得出来的
40         //但是，它不能针对任何的数组都可以这样
41         //所以，我们应该想办法改进
42         //其实，外面的这个循环的长度就是二维数组的长度
43         
44         for(int x=0; x<arr.length; x++) {
45             for(int y=0; y<arr[x].length; y++) {
46                 System.out.print(arr[x][y]+" ");
47             }
48             System.out.println();
49         }
50         System.out.println("--------------");
51         
52         //用方法改进
53         //调用方法
54         printArray2(arr);
55         System.out.println("--------------");
56         
57         //我们再来一个列数是变化的
58         int[][] arr2 = {{1,2,3},{4,5},{6}};
59         printArray2(arr2);
60     }
61     
62     /*
63         需求：遍历二维数组
64         两个明确：
65             返回值类型：void
66             参数列表：int[][] arr
67     */
68     public static void printArray2(int[][] arr) {
69         for(int x=0; x<arr.length; x++) {
70             for(int y=0; y<arr[x].length; y++) {
71                 System.out.print(arr[x][y]+" ");
72             }
73             System.out.println();
74         }
75     }
76 }

 1 /*
 2     公司年销售额求和
 3     某公司按照季度和月份统计的数据如下：单位(万元)
 4     第一季度：22,66,44
 5     第二季度：77,33,88
 6     第三季度：25,45,65
 7     第四季度：11,66,99
 8     
 9     分析：
10         A:把题目的数据用二维数组来表示
11             int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
12         B:如何求和呢?
13             求和其实就是获取到每一个元素，然后累加即可。
14         C:定义一个求和变量sum，初始化值是0。
15         D:通过遍历就可以得到每一个二维数组的元素。
16         E:把元素累加即可。
17         F:最后输出sum，就是结果。
18 */
19 class Array2Test2 {
20     public static void main(String[] args) {
21         //把题目的数据用二维数组来表示
22         int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
23         
24         //定义一个求和变量sum，初始化值是0。
25         int sum = 0;
26         
27         //通过遍历就可以得到每一个二维数组的元素。
28         for(int x=0; x<arr.length; x++) {
29             for(int y=0; y<arr[x].length; y++) {
30                 //把元素累加即可。
31                 sum += arr[x][y];
32             }
33         }
34         
35         //最后输出sum，就是结果。
36         System.out.println("一年的销售额为："+sum+"万元");
37     }
38 }

 1 /*
 2 
 3     需求：打印杨辉三角形(行数可以键盘录入)
 4     
 5     1
 6     1 1    
 7     1 2 1
 8     1 3 3 1
 9     1 4 6 4 1 
10     1 5 10 10 5 1
11 
12     分析：看这种图像的规律
13         A:任何一行的第一列和最后一列都是1
14         B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
15     
16     步骤：
17         A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
18           这个n的数据来自于键盘录入。
19         B:给这个二维数组任何一行的第一列和最后一列赋值为1
20         C:按照规律给其他元素赋值
21             从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
22         D:遍历这个二维数组。
23 */
24 import java.util.Scanner;
25 
26 class Array2Test3 {
27     public static void main(String[] args) {
28         //创建键盘录入对象
29         Scanner sc = new Scanner(System.in);
30         
31         //这个n的数据来自于键盘录入。
32         System.out.println("请输入一个数据：");
33         int n = sc.nextInt();
34         
35         //定义二维数组
36         int[][] arr = new int[n][n];
37         
38         //给这个二维数组任何一行的第一列和最后一列赋值为1
39         for(int x=0; x<arr.length; x++) {
40             arr[x][0] = 1; //任何一行第1列
41             arr[x][x] = 1; //任何一行的最后1列
42         }
43         
44         //按照规律给其他元素赋值
45         //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
46         for(int x=2; x<arr.length; x++) {
47             //这里如果y<=x是有个小问题的，就是最后一列的问题
48             //所以这里要减去1
49             //并且y也应该从1开始，因为第一列也是有值了
50             for(int y=1; y<=x-1; y++) {
51                 //每一个数据是它上一行的前一列和它上一行的本列之和。
52                 arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
53             }
54         }
55         
56         //遍历这个二维数组。
57         /*
58         for(int x=0; x<arr.length; x++) {
59             for(int y=0; y<arr[x].length; y++) {
60                 System.out.print(arr[x][y]+"\t");
61             }
62             System.out.println();
63         }
64         */
65         //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
66         for(int x=0; x<arr.length; x++) {
67             for(int y=0; y<=x; y++) {
68                 System.out.print(arr[x][y]+"\t");
69             }
70             System.out.println();
71         }
72     }
73 }

 1 /*
 2     某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
 3     在传递过程中需要加密，加密规则如下：
 4         首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
 5         最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
 6         然后，把加密后的结果在控制台打印出来。 
 7         
 8     题目要求：
 9         A:数据是小于8位的整数
10             定义一个int类型的数据
11             int number = 123456;
12         B:加密规则
13             a:首先将数据倒序
14                 结果 654321
15             b:然后将每位数字都加上5，再用和除以10的余数代替该数字
16                 结果 109876
17             c:最后将第一位和最后一位数字交换
18                 结果 609871
19         C:把加密后的结果输出在控制台
20         
21         通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。
22         不是直接写成这个样子的：
23             int[] arr = {1,2,3,4,5,6};
24             
25         如何把数据转成数组呢?
26             A:定义一个数据
27                 int number = 123456;
28             B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?
29                 int[] arr = new int[8]; //不可能超过8
30                 在赋值的时候，我用一个变量记录索引的变化。
31                 定义一个索引值是0
32                 int index = 0;
33             C:获取每一个数据
34                 int ge = number%10
35                 int shi = number/10%10
36                 int bai = number/10/10%10
37                 
38                 arr[index] = ge;
39                 index++;
40                 arr[index] = shi;
41                 index++;
42                 arr[index] = bai;
43                 ...
44 */
45 class JiaMiDemo {
46     public static void main(String[] args) {
47         //定义一个数据
48         int number = 123456;
49         
50         //定义一个数组
51         int[] arr = new int[8];
52         
53         //把数据中每一位上的数据获取到后存储到数组中
54         /*
55         int index = 0;
56         arr[index] = number%10; //arr[0]=6;
57         index++;
58         arr[index] = number/10%10; //arr[1]=5;
59         index++;
60         arr[index] = mumber/10/10%10; //arr[2]=4;
61         */
62         
63         //通过观察这个代码，我们发现应该是可以通过循环改进的
64         int index = 0;
65         
66         while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
67             arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
68             index++;//index=1,index=2,index=3,index=4,index=5,index=6
69             number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
70         }
71         
72         //然后将每位数字都加上5，再用和除以10的余数代替该数字
73         for(int x=0; x<index; x++) {
74             arr[x] += 5;
75             arr[x] %= 10;
76         }
77         
78         //最后将第一位和最后一位数字交换
79         int temp = arr[0];
80         arr[0] = arr[index-1];
81         arr[index-1] = temp;
82         
83         //输出数据
84         for(int x=0; x<index; x++) {
85             System.out.print(arr[x]);
86         }
87         System.out.println();
88     }
89 }

 1 /*
 2     把刚才的代码改进一下：
 3         A:把数据改进为键盘录入
 4         B:把代码改进为方法实现
 5         
 6         
 7         另一个数据的测试：
 8         number:1234567
 9         第一步：7654321
10         第二步：2109876
11         第三步：6109872
12         
13     知识点：
14         变量
15         数据类型
16         运算符
17         键盘录入
18         语句
19         方法
20         数组
21 */
22 import java.util.Scanner;
23 
24 class JiaMiDemo2 {
25     public static void main(String[] args) {
26         //创建键盘录入对象
27         Scanner sc = new Scanner(System.in);
28         
29         //请输入一个数据
30         System.out.println("请输入一个数据(小于8位)：");
31         int number = sc.nextInt();
32         
33         //写功能实现把number进行加密
34         //调用
35         String result = jiaMi(number);
36         System.out.println("加密后的结果是："+result);
37     }
38     
39     /*
40         需求：写一个功能，把数据number实现加密。
41         两个明确：
42             返回值类型：String 做一个字符串的拼接。
43             参数列表：int number
44     */
45     public static String jiaMi(int number) {
46         //定义数组
47         int[] arr = new int[8];
48         
49         //定义索引
50         int index = 0;
51         
52         //把number中的数据想办法放到数组中
53         while(number > 0) {
54             arr[index] = number%10;
55             index++;
56             number /= 10;
57         }
58         
59         //把每个数据加5，然后对10取得余数
60         for(int x=0; x<index; x++) {
61             arr[x] += 5;
62             arr[x] %= 10;
63         }
64         
65         //把第一位和最后一位交换
66         int temp = arr[0];
67         arr[0] = arr[index-1];
68         arr[index-1] = temp;
69         
70         //把数组的元素拼接成一个字符串返回
71         //定义一个空内容字符串
72         String s = "";
73         
74         for(int x=0; x<index; x++) {
75             s += arr[x];
76         }
77         
78         return s;
79     }
80 }