【原】Java學習筆記010 - 數組。本站提示廣大學習愛好者：（【原】Java學習筆記010 - 數組）文章只能為提供參考，不一定能成為您想要的結果。以下是【原】Java學習筆記010 - 數組正文
1 package cn.temptation;
2
3 public class Sample01 {
4 public static void main(String[] args) {
5 // 需求：一堆分數，要統計最高分、最低分、總分、平均分
6 // int score1 = 80;
7 // int score2 = 70;
8 // int score3 = 90;
9 // int score4 = 65;
10 // // ...
11 // // 以計算平均分為例
12 // double average = ((double)(score1 + score2 + score3 + score4)) / 4;
13 // System.out.println("平均分為：" + average);
14
15 // 問題：相同意義的變量定義了一大堆，覺得這樣一點都不簡潔
16
17 // 思考解決方案：運用抽象的思維，類比生活中使用的冰格，作為一個制作冰塊的容器，其內部每一個格子中的冰塊可以單獨使用的，兼具了批量性 和 獨立性
18 // 那麼考慮制作一個存放分數的容器，且在這個分數容器中的每一個分數也可以單獨使用
19
20 // 數組：Array，存儲同一數據類型的多個元素的容器
21
22 // 注意：【數組是引用數據類型（引用類型），基本數據類型是值類型】
23 // 內存：根據處理的內容的不同，分為 堆棧（棧：stack） 和 堆（Heap）
24 // 值類型：存儲在棧中
25 // 引用數據類型：聲明存儲在棧中，內容存儲在堆中
26
27 // 數組的格式：
28 // 形式1：數據類型[] 數組名（硬性要求：大家使用這種形式）：聲明了一個xxx數據類型的數組，名字叫yyy
29 // 形式2：數據類型 數組名[]：聲明了一個xxx數據類型，名字叫yyy的數組
30
31 // 聲明一個成績數組
32 // int[] scoreArr;
33 // int scoreArr[]; // 語法OK，但是不建議這樣寫
34
35 // 數組變量使用前必須進行初始化操作
36 // 語法錯誤：The local variable scoreArr may not have been initialized
37 // System.out.println(scoreArr);
38
39 // 數組初始化形式：
40 // 1、動態初始化：由使用者設置數組的長度，再填充元素
41 // 2、靜態初始化：由使用者填充元素，由JDK計算數組的長度
42
43 // 動態初始化的格式：new 數據類型[數組的長度];
44 // A：new 關鍵字用來在內存的堆（Heap）中開辟一塊空間
45 // B：數組的長度由使用者設置
46 // C：數組的下標（索引）用來表示數組中元素的位置，下標（索引）從0開始，到數組的長度-1結束
47
48 // 對於已經聲明過的數組變量，進行動態初始化並賦值
49 // scoreArr = new int[3];
50
51 // 數組的初始化：可以把數組的聲明 和 初始化 放在一行語句中執行
52 int[] scoreArr = new int[3];
53
54 // 下句輸出 [I@15db9742 ，表示了scoreArr數組變量在內存中的類型 和 地址（以@符號作為分隔，前面是類型，後面是地址）
55 System.out.println(scoreArr); // [I@15db9742
56 }
57 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 // 數組的下標（索引）是從0開始的
6 // 數組的長度就是描述數組中元素的個數
7 // int[] arr = new int[3];
8 // arr[0] = 90; // 對數組中的第一個元素賦值為90
9
10 // 創建int類型的數組，向其中存放其他數據類型的元素，會發生什麼現象？
11 // 向int類型的元素存放boolean類型的內容，語法出錯
12 // 產生語法錯誤：Type mismatch: cannot convert from boolean to int
13 // arr[1] = true; // 對數組中的第二個元素賦值為true
14
15 // 向int類型的元素存放long類型的內容，語法出錯
16 // 產生語法錯誤：Type mismatch: cannot convert from long to int
17 // arr[1] = 12345678901L;
18
19 // 向int類型的元素存放byte類型的內容，語法OK
20 // arr[1] = (byte)126;
21
22 // 向int類型的元素存放short類型的內容，語法OK
23 // arr[1] = (short)130;
24
25 // 【數組在內存中的存儲形式】
26 // 賦值號左邊的是數組的聲明，類比名片
27 // 賦值號右邊的是數組的內容，類比具體的家的位置
28 // 通過名片找到具體的家的位置
29 // 通過棧上聲明的變量找到堆中具體存放內容的位置來使用數組
30
31 // System.out.println(arr); // [I@15db9742
32
33 // 數組中元素的默認值
34 // byte、short、int、long類型的數組的元素默認值為0
35 // int[] arr1 = new int[3];
36 // System.out.println(arr1[0]); // 0
37 // System.out.println(arr1[1]); // 0
38 // System.out.println(arr1[2]); // 0
39
40 // byte[] arr2 = new byte[3];
41 // System.out.println(arr2[0]); // 0
42 // System.out.println(arr2[1]); // 0
43 // System.out.println(arr2[2]); // 0
44 //
45 // short[] arr3 = new short[3];
46 // System.out.println(arr3[0]); // 0
47 // System.out.println(arr3[1]); // 0
48 // System.out.println(arr3[2]); // 0
49 //
50 // long[] arr4 = new long[3];
51 // System.out.println(arr4[0]); // 0
52 // System.out.println(arr4[1]); // 0
53 // System.out.println(arr4[2]); // 0
54
55 // double、float類型的數組的元素默認值為0.0
56 // double[] arr5 = new double[3];
57 // System.out.println(arr5[0]); // 0.0
58 // System.out.println(arr5[1]); // 0.0
59 // System.out.println(arr5[2]); // 0.0
60 //
61 // float[] arr6 = new float[3];
62 // System.out.println(arr6[0]); // 0.0
63 // System.out.println(arr6[1]); // 0.0
64 // System.out.println(arr6[2]); // 0.0
65
66 // char類型的數組的元素默認值為'\u0000'
67 // char[] arr7 = new char[3];
68 // System.out.println(arr7[0]); // '\u0000'
69 // System.out.println(arr7[1]); // '\u0000'
70 // System.out.println(arr7[2]); // '\u0000'
71
72 // boolean類型的數組的元素默認值為false
73 boolean[] arr8 = new boolean[3];
74 System.out.println(arr8[0]); // false
75 System.out.println(arr8[1]); // false
76 System.out.println(arr8[2]); // false
77 }
78 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 int[] scoreArr = new int[3];
6
7 System.out.println(scoreArr); // [I@15db9742
8 System.out.println(scoreArr[0]); // 0
9 System.out.println(scoreArr[1]); // 0
10 System.out.println(scoreArr[2]); // 0
11
12 System.out.println("-------------------------------------");
13
14 // 對數組中的部分元素進行賦值
15 scoreArr[0] = 80;
16 scoreArr[2] = 55;
17
18 // 1、數組的元素的值發生變化後，數組的地址沒有變化
19 // 2、數組的元素的值發生變化後，數組中沒有發生變化的元素的值還是之前的值
20 System.out.println(scoreArr); // [I@15db9742
21 System.out.println(scoreArr[0]); // 80
22 System.out.println(scoreArr[1]); // 0
23 System.out.println(scoreArr[2]); // 55
24 }
25 }
1 package cn.temptation;
2
3 public class Sample04 {
4 public static void main(String[] args) {
5 // 需求：把數組中的元素的值都顯示出來
6 int[] scoreArr = new int[3];
7
8 // 下面的寫法可以實現需求，但是使用起來很不方便
9 // System.out.println(scoreArr[0]);
10 // System.out.println(scoreArr[1]);
11 // System.out.println(scoreArr[2]);
12
13 // 看到有重復的操作，就想到了循環
14 // for (int i = 0; i < 3; i++) {
15 // System.out.println(scoreArr[i]);
16 // }
17
18 // 上面的寫法不具備通用性，因為這裡的數字3是硬編碼，其實它應該表示為數組的長度（數組中元素的個數）
19
20 // 通過使用 數組名.length 可以獲取到數組的長度
21 // System.out.println("數組的長度為：" + scoreArr.length);
22
23 // 下面的寫法就具備通用性（注意：eclipse中提供的for語句塊結構：iterate over array，即在數組上進行迭代）
24 // for (int i = 0; i < scoreArr.length; i++) {
25 // System.out.println(scoreArr[i]);
26 // }
27
28 // 還有更加簡單的寫法，使用增強型for循環-----> foreach
29 // 增強型for循環的格式：for(數據類型 遍歷變量名(迭代變量名) : 被遍歷變量名(被迭代變量名)) { ... }
30 // for (int i : scoreArr) {
31 // System.out.println(i);
32 // }
33
34 // 注意：遍歷變量名(迭代變量名)可以由使用者自己定義名稱
35 // for (int item : scoreArr) {
36 // System.out.println(item);
37 // }
38
39 // 產生錯誤：Type mismatch: cannot convert from element type int to byte
40 // for (byte i : scoreArr) {
41 // System.out.println(i);
42 // }
43
44 // 產生錯誤：Type mismatch: cannot convert from element type int to short
45 // for (short i : scoreArr) {
46 // System.out.println(i);
47 // }
48
49 // 語法OK
50 // for (long i : scoreArr) {
51 // System.out.println(i);
52 // }
53
54 // 總結：被遍歷的變量名的數據類型，認為其內部的元素也是該數據類型的，那麼用范圍比它大的數據類型接收時是可以的
55 // 用范圍比它小的數據類型接收時就會抱語法錯誤
56
57 // 需求：使用循環和數組長度等技術點，制作一個方法printArray，用來打印數組中的元素，要求顯示為[元素1的值, 元素2的值, ... 元素n的值]
58 printArray(scoreArr);
59 }
60
61 /**
62 * 打印數組方法
63 * @param arr：int類型的數組
64 */
65 public static void printArray(int[] arr) {
66 // 最左邊先打印出一個"["
67 System.out.print("[");
68
69 // 遍歷數組
70 for (int i = 0; i < arr.length; i++) {
71 if (i == arr.length - 1) { // 數組中的最後一個元素，加上"]"
72 System.out.print(arr[i] + "]");
73 } else { // 數組中的其他元素，加上","
74 System.out.print(arr[i] + ",");
75 }
76 }
77
78 // 換行
79 System.out.println();
80 }
81 }
1 package cn.temptation;
2
3 public class Sample05 {
4 public static void main(String[] args) {
5 int[] arr = new int[3];
6 arr[0] = 10;
7 arr[1] = 21;
8 arr[2] = 30;
9
10 // 需求：制作一個方法getMaxItem，獲取數組中的最大元素值
11 int maxItem = getMaxItem(arr);
12 System.out.println("數組中最大的元素為：" + maxItem);
13
14 // 需求：制作一個方法getMinItem，獲取數組中的最小元素值
15 int minItem = getMinItem(arr);
16 System.out.println("數組中最小的元素為：" + minItem);
17
18 // 需求：制作一個方法getTotal，獲取數組中的元素的總和
19 int total = getTotal(arr);
20 System.out.println("數組中元素的總和為：" + total);
21
22 // 需求：制作一個方法getAverage，獲取數組中的元素的平均值
23 double average = getAverage(arr);
24 System.out.println("數組中元素的平均值為：" + average);
25 }
26
27 /**
28 * 獲取數組中的最大元素值
29 * @param arr：數組
30 * @return：最大的元素值
31 *
32 * 思路：使用窮舉思路
33 * 1、先設置一個作為比較的標桿，從數組中拿出一個元素認為它是最大的
34 * 2、把數組中的其他元素與之進行比較
35 * 3、如果有其他的元素比作為標桿的元素大，則替換之
36 * 4、比較完成後，就可以得到數組中的最大元素
37 */
38 public static int getMaxItem(int[] arr) {
39 int tempMax = arr[0];
40
41 // 遍歷數組
42 for (int i = 0; i < arr.length; i++) {
43 if (arr[i] > tempMax) {
44 tempMax = arr[i];
45 }
46 }
47
48 return tempMax;
49 }
50
51 /**
52 * 獲取數組中的最小元素值
53 * @param arr：數組
54 * @return：最小的元素值
55 */
56 public static int getMinItem(int[] arr) {
57 int tempMin = arr[0];
58
59 // 遍歷數組
60 for (int i = 0; i < arr.length; i++) {
61 if (arr[i] < tempMin) {
62 tempMin = arr[i];
63 }
64 }
65
66 return tempMin;
67 }
68
69 /**
70 * 獲取數組中的元素值的總和
71 * @param arr：數組
72 * @return：數組中元素的總和
73 */
74 public static int getTotal(int[] arr) {
75 int total = 0;
76
77 // 遍歷數組
78 for (int i = 0; i < arr.length; i++) {
79 total += arr[i];
80 }
81
82 return total;
83 }
84
85 /**
86 * 獲取數組中的元素值的平均值
87 * @param arr：數組
88 * @return：數組中元素的平均值
89 */
90 public static double getAverage(int[] arr) {
91 double total = 0.0;
92
93 for (int i = 0; i < arr.length; i++) {
94 total += arr[i];
95 }
96
97 return total / arr.length;
98 }
99 }
1 package cn.temptation;
2
3 public class Sample06 {
4 public static void main(String[] args) {
5 int[] arr1 = new int[3];
6 arr1[0] = 80;
7 arr1[2] = 55;
8
9 int[] arr2 = new int[3];
10 arr2[0] = 80;
11 arr2[2] = 55;
12
13 System.out.println("數組1的地址：" + arr1); // [I@15db9742
14 printArray(arr1);
15
16 System.out.println("數組2的地址：" + arr2); // [I@6d06d69c
17 printArray(arr2);
18
19 System.out.println("----- 修改元素值 -----");
20
21 arr2[0] = 38;
22 arr2[1] = 100;
23
24 System.out.println("數組1的地址：" + arr1); // [I@15db9742
25 printArray(arr1);
26
27 System.out.println("數組2的地址：" + arr2); // [I@6d06d69c
28 printArray(arr2);
29
30 // 不同的數組，元素的值相同，修改後，對其他數組中的元素的值無影響
31 // 因為不同的數組中的元素存放在內存的堆中不同的空間裡
32
33 // 從運行的結果得知：
34 // 【只要使用了new關鍵字，就在內存的堆中開辟了新的空間】
35 }
36
37 /**
38 * 打印數組方法
39 * @param arr：int類型的數組
40 */
41 public static void printArray(int[] arr) {
42 // 最左邊先打印出一個"["
43 System.out.print("[");
44
45 // 遍歷數組
46 for (int i = 0; i < arr.length; i++) {
47 if (i == arr.length - 1) { // 數組中的最後一個元素，加上"]"
48 System.out.print(arr[i] + "]");
49 } else { // 數組中的其他元素，加上","
50 System.out.print(arr[i] + ",");
51 }
52 }
53
54 // 換行
55 System.out.println();
56 }
57 }
1 package cn.temptation;
2
3 public class Sample07 {
4 public static void main(String[] args) {
5 int[] arr1 = new int[3];
6 arr1[0] = 80;
7 arr1[2] = 55;
8
9 // 注意：下句語句體現了引用數據類型的特點
10 int[] arr2 = arr1;
11
12 System.out.println("數組1的地址：" + arr1); // [I@15db9742
13 printArray(arr1);
14
15 System.out.println("數組2的地址：" + arr2); // [I@15db9742
16 printArray(arr2);
17
18 System.out.println("----- 修改元素值 -----");
19
20 arr2[0] = 38;
21 arr2[1] = 100;
22
23 System.out.println("數組1的地址：" + arr1); // [I@15db9742
24 printArray(arr1);
25
26 System.out.println("數組2的地址：" + arr2); // [I@15db9742
27 printArray(arr2);
28
29 // 從運行的結果得知：
30 // 1、只要使用了new關鍵字，就在內存的堆中開辟了新的空間
31 // 2、引用數據類型在做值傳遞時，傳遞的是引用
32 }
33
34 /**
35 * 打印數組方法
36 * @param arr：int類型的數組
37 */
38 public static void printArray(int[] arr) {
39 // 最左邊先打印出一個"["
40 System.out.print("[");
41
42 // 遍歷數組
43 for (int i = 0; i < arr.length; i++) {
44 if (i == arr.length - 1) { // 數組中的最後一個元素，加上"]"
45 System.out.print(arr[i] + "]");
46 } else { // 數組中的其他元素，加上","
47 System.out.print(arr[i] + ",");
48 }
49 }
50
51 // 換行
52 System.out.println();
53 }
54 }
1 package cn.temptation;
2
3 public class Sample08 {
4 public static void main(String[] args) {
5 // 值類型的特點
6
7 // int i = 2;
8 // int j = 2;
9 //
10 // System.out.println("i的值為：" + i);
11 // System.out.println("j的值為：" + j);
12 //
13 // System.out.println("----- 修改元素值 -----");
14 //
15 // j = 3;
16 //
17 // System.out.println("i的值為：" + i);
18 // System.out.println("j的值為：" + j);
19
20 int i = 2;
21 int j = i;
22
23 System.out.println("i的值為：" + i);
24 System.out.println("j的值為：" + j);
25
26 System.out.println("----- 修改元素值 -----");
27
28 j = 3;
29
30 System.out.println("i的值為：" + i);
31 System.out.println("j的值為：" + j);
32
33 // 值類型的特點
34 // 存儲在棧上，沒有棧和堆之間的指向引用，變化只影響自身
35 }
36 }
1 package cn.temptation;
2
3 public class Sample09 {
4 public static void main(String[] args) {
5 // 數組初始化
6 // 靜態初始化：由使用者填充數組的元素，由JDK自動判定數組的長度
7
8 // 靜態初始化的格式：
9 // 1、簡寫形式：{ 元素1, 元素2, ... 元素n}
10 // 2、完整形式：new 數據類型[] { 元素1, 元素2, ... 元素n}
11
12 // 簡寫形式
13 int[] arr1 = { 10, 20, 30 };
14 System.out.println("數組的長度為：" + arr1.length);
15
16 // 完整形式
17 int[] arr2 = new int[] { 10, 20, 30 };
18 System.out.println("數組的長度為：" + arr2.length);
19
20 // 遍歷數組中的元素
21 // 方式1：一般for循環
22 for (int i = 0; i < arr1.length; i++) {
23 System.out.println(arr1[i]);
24 }
25
26 // 方式2：增強型for循環
27 for (int item : arr2) {
28 System.out.println(item);
29 }
30
31 // 注意：
32 // 1、靜態初始化的簡寫形式看起來沒有new，但是實際上還是做了new的操作，還是在內存的堆上開辟了空間
33 // 2、數組的初始化有兩種形式，使用時只能選擇一種形式使用，不能混搭
34
35 // 混搭動態初始化和靜態初始化會產生語法錯誤
36 // 產生語法錯誤：Cannot define dimension expressions when an array initializer is provided
37 // int[] arr3 = new int[3] { 10, 20, 30 };
38 }
39 }
1 package cn.temptation;
2
3 public class Sample10 {
4 public static void main(String[] args) {
5 // 1、下面語句是否在內存的堆中開辟了空間？ 答：new出了空間，地址為15db9742
6 // 2、下面這個數組長度是多少？ 答：數組長度為0
7 // 3、如何為這個數組填充元素並給元素賦值？
8 int[] arr = {};
9
10 System.out.println(arr); // [I@15db9742
11 System.out.println("數組的長度為：" + arr.length); // 0
12
13 // 遍歷數組
14 for (int i = 0; i < arr.length; i++) {
15 System.out.println(arr[i]);
16 }
17
18 for (int item : arr) {
19 System.out.println(item);
20 }
21
22 // 下句執行時會產生異常：java.lang.ArrayIndexOutOfBoundsException: 0，數組索引越界異常
23 // 因為當前arr數組中一個元素都沒有，而下句語句要給第一個元素進行賦值，自然出現數組索引越界異常
24 // arr[0] = 10;
25 // 下句執行時會產生異常：java.lang.ArrayIndexOutOfBoundsException: 10，數組索引越界異常
26 // arr[10] = 99;
27 // 由上面的語句得知java.lang.ArrayIndexOutOfBoundsException後的數字指的是越界元素對應的索引
28
29 // 考慮1、考慮設置數組arr的length屬性
30 // 語法錯誤：The final field array.length cannot be assigned
31 // 數組的length屬性可以被讀取，但是不可以被修改
32 // arr.length = 3;
33
34 // 考慮2、張冠李戴
35 // 通過創建一個新的數組，在堆中開辟一塊新的空間，然後把指向之前開辟出的空間的引用（arr的棧堆之間的引用）改為指向新開辟的空間的引用
36 int[] arrExtend = { 10, 20, 30 };
37 arr = arrExtend;
38
39 // 遍歷數組
40 for (int i = 0; i < arr.length; i++) {
41 System.out.println(arr[i]);
42 }
43
44 for (int item : arr) {
45 System.out.println(item);
46 }
47 }
48 }
