Java筆記(02)：二維數組

時間 2019-11-18

標籤 java 筆記二維數組欄目 Java 简体版

原文原文鏈接

1、二維數組相關語法java

/*
    二維數組：就是元素爲一維數組的一個數組。
    
    格式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 }

2、練習測試

一、二維數組遍歷加密

 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 }

二、公司銷售額求和spa

 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 }

三、打印楊輝三角code

 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 }

以上代碼的改進：blog

 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 }