變量或者是常量, 隻能用來存儲一個資料, 例如: 存儲一個整數, 小數或者字元串等.
如果需要同時存儲多個同類型的資料, 用變量或者常量來實作的話, 非常的繁瑣. 針對于
這種情況, 我們就可以通過數組來實作了.
例如: 假設某公司有50名員工, 現在需要統計該公司員工的工資情況, 例如計算平均
工資、擷取最高工資等。針對于這個需求，如果用前面所學的知識實作，程式首先需要聲
明50個變量來分别記住每位員工的工資，然後在進行操作，這樣做非常繁瑣，而且錯誤率
也會很高。是以我們可以使用容器進行操作。将所有的資料全部存儲到一個容器中，統一
操作。數組, 就是一種容器.
解釋:
容器: 就是将多個資料存儲到一起, 每個資料都是該容器的元素.
現實生活中的容器: 水杯, 衣櫃, 教室等...
數組概述
數組就是用來存儲多個同類型元素的容器, 例如: 存儲5個整數, 或者存儲10個小數, 亦或
者存儲3個字元串等...
1 package com.it.demo08_array;
2
3 /*
4 案例: 示範數組的定義格式.
5
6 數組簡介:
7 概述:
8 數組就是用來 同時存儲 多個 同類型元素 的容器.
9 定義格式:
10 動态初始化: 我們給長度, 由系統給出預設值.
11 格式1:
12 資料類型[] 數組名 = new 資料類型[長度];
13 int[] arr = new int[3];
14
15 格式2:
16 資料類型 數組名[] = new 資料類型[長度];
17 int arr[] = new int[3];
18
19 靜态初始化: 我們給出預設值, 由系統決定長度.
20 格式1:
21 資料類型[] 數組名 = new 資料類型[]{值1, 值2, 值3...};
22 int[] arr = new int[]{11, 22, 33};
23
24 格式2:
25 資料類型[] 數組名 = {值1, 值2, 值3...};
26 int[] arr = {11, 22, 33}; //屬于格式1的簡化版, 學名叫: 文法糖.
27 */
28 public class Demo01 {
29 public static void main(String[] args) {
30 //1.建立int類型的數組, 用來存儲3個元素. //我們給長度, 系統給預設值, 這個叫: 動态初始化.
31 //格式1: 定義一個int類型的數組, 數組名叫: arr1, 初始化長度為3.
32 int[] arr1 = new int[3]; //推薦使用.
33
34 //格式2: 定義一個int類型的arr數組, 數組名叫arr2, 初始化長度為3.
35 int arr2[] = new int[3];
36
37
38 //2.建立int類型的數組, 存儲資料11, 22, 33. //我們給值, 由系統決定長度, 這個叫: 靜态初始化.
39 //格式1:
40 int[] arr3 = new int[]{11, 22, 33}; //推薦使用.
41
42 //格式2: 文法糖
43 int[] arr4 = {11, 22, 33}; //推薦使用.
44 }
45 } 1 /*
2 定義數組容器
3 定義數組容器,要素,強制資料類型的語言
4 必須有資料類型, 大小, 就是存儲資料的個數
5 定義數組公式:
6 資料類型[] 變量名 = new 資料類型[存儲元素的個數];
7
8 資料類型: 數組中存儲元素的資料類型
9 [] 表示數組的意思
10 變量名 自定義辨別符
11
12 new 建立容器關鍵字
13 資料類型: 數組中存儲元素的資料類型
14 [] 表示數組的意思
15 元素個數,就是數組中,可以存儲多少個資料 (恒定, 定長)
16
17 數組是一個容器: 存儲到數組中的每個元素,都有自己的自動編号
18 自動編号,最小值是0, 最大值,長度-1
19 自動編号專業名次, 索引(index), 下标, 角标
20 通路數組存儲的元素,必須依賴于索引, 公式 數組名[索引]
21
22 Java提供一個屬性,操作索引的
23 數組的一個屬性,就是數組的長度, 屬性的名字 length
24 使用屬性: 數組名.length 資料類型 int
25
26 數組的最小索引是0, 最大索引數組.length-1
27 */
28 public class ArrayDemo{
29 public static void main(String[] args){
30 //定義數組,存儲整數,容器長度, 3個
31 // 資料類型[] 變量名 = new 資料類型[存儲元素的個數];
32 int[] arr = new int[3];
33 System.out.println(arr);
34
35 //通過索引的方式,數組中的三個元素
36 System.out.println(arr[0]);
37 System.out.println(arr[1]);
38 System.out.println(arr[2]);
39
40
41 System.out.println(arr.length);
42
43
44
45
46
47 }
48 } 1 /*
2 數組的常用兩個定義方式
3 資料類型[] 變量名 = new 資料類型[]{元素1,元素2,元素3};
4 注意事項: new 後面的中括号中,不允許寫任何内容,寫了就編譯失敗
5
6 資料類型[] 變量名 = {元素1,元素2,元素3};
7 */
8 public class ArrayDemo_2{
9 public static void main(String[] args){
10 //定義數組,定義的同時,對元素進行指派
11 int[] arr = new int[]{1,2,4,5,7,9};
12 System.out.println(arr.length);
13 System.out.println(arr[5]);
14
15
16 System.out.println("==================");
17 //定義數組,直接大括号指派
18 int[] arr2 = {0,2,4,6,8};
19 System.out.println(arr2.length);
20 System.out.println(arr2[1]);
21 }
22 } 1 /*
2 數組的操作, 使用索引,對數組中的元素指派
3 */
4 public class ArrayDemo_1{
5 public static void main(String[] args){
6 //定義數組,存儲int類型數組,長度就是5
7 int[] arr = new int[5];
8
9 //将1索引上的元素,指派3
10 arr[1] = 3;
11 System.out.println(arr[1]);
12 System.out.println(arr[2]);
13 }
14 } 1 /*
2 數組周遊:
3 将所有的數組元素,全擷取
4 依靠索引, 規律從0開始,一直在自動增長1, 到達length-1
5 循環來實作
6 for 知道循環次數, 計數器思想
7 while 不确定循環次數
8 */
9
10 public class ArrayDemo_3{
11 public static void main(String[] args){
12 int[] arr = {2,1,3,5,7,0,4};
13
14 for(int i = 0 ; i < arr.length; i++){
15 System.out.println(arr[i]);
16 }
17 }
18 } 1 /*
2 數組操作中,常見的兩個異常
3 數組的索引越界異常
4 空指針異常
5 */
6 public class ArrayDemo_4{
7 public static void main(String[] args){
8 //數組的索引越界異常
9 //int[] arr = {5,2,1};
10 //數組中3個元素,索引 0,1,2
11 //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
12
13 //空指針異常
14 int[] arr2 = {1,5,8};
15 System.out.println(arr2[2]);
16 arr2 = null; // arr2 不在儲存數組的位址了
17 System.out.println(arr2[2]);//java.lang.NullPointerException
18 }
19 } 1 /*
2 計算數組中的最大值
3 數組 {4,1,7,5}; 做比較
4 */
5 public class ArrayDemo_5{
6 public static void main(String[] args){
7 //定義數組,int類型
8 int[] arr = {5,1,12,4,6,8,0,3};
9 //定義變量,記錄數組中0索引上的元素
10 int max = arr[0];
11
12 //周遊數組,擷取所有的元素,和變量max比較
13 for(int i = 1; i < arr.length ; i++){
14 //變量max,和數組中的每個元素進行比較
15 //如果max,小于了數組中的一個元素
16 if( max < arr[i] ){
17 //較大的數組的元素,指派給max
18 max = arr[i];
19 }
20 }
21 // 周遊完成,變量max,就是數組最大值
22 System.out.println(max);
23 }
24 }//歡迎加入Java開發交流君樣：909038429 1 package com.it.demo08_array;
2
3 /*
4 案例: 示範數組的基本格式.
5
6 涉及到的知識點:
7 數組的各部分解釋, 此處以 動态初始化舉例, 例如: int[] arr = new int[3];
8 int: 表示數組中存儲元素的資料類型, int說明隻能存儲整數, 如果是String說明隻能存儲字元串, 如果是double, 說明隻能存儲小數.
9 []: 表示它是一個數組
10 arr: 表示數組名, 命名的規則和命名變量是一樣的(遵循小駝峰命名法), 都要符合辨別符的規範.
11 new: 表示建立對象, 該對象存儲在 堆記憶體 空間.
12 3: 表示數組的長度, 即: 數組中最多隻能存儲幾個資料.
13
14 數組的元素特點:
15 1. 數組中每個元素都是有索引(也叫: 編号, 角标, 下标)的, 且索引是從 0 開始的.
16 2. 數組中的每個元素都是有預設值的, 例如:
17 int[], 元素預設值為: 0
18 double[], 元素預設值為: 0.0
19 boolean[], 元素預設值為: false
20 String[], 元素預設值為: null
21
22 數組的基本格式:
23 數組名[索引] 根據索引值, 擷取該索引對應的元素.
24 數組名[索引] = 值 修改指定索引處的元素為指定的值.
25 數組名.length 擷取數組的長度.
26 數組名.length - 1 擷取數組中最後一個元素的索引.
27
28 */
29 public class Demo02 {
30 public static void main(String[] args) {
31 //1.定義一個長度為5的int類型的數組.
32 int[] arr = new int[5]; //11 0, 0, 0, 0
33 System.out.println(arr); //因為數組是對象, 是以直接列印數組, 列印的是: 該對象在記憶體中的位址值.
34
35 //2.列印數組中的第3個元素.
36 System.out.println(arr[2]); //索引從0開始.
37
38 //3.設定數組中的第一個元素值為11.
39 arr[0] = 11;
40
41 //4.擷取數組中的第一個元素值, 并将其指派給變量a, 然後列印.
42 int a = arr[0];
43 System.out.println(a); //11
44
45 //5.列印數組的長度.
46 System.out.println(arr.length);
47 }
48 } 1 package com.it.demo08_array;
2
3 /*
4 JVM的記憶體劃分:
5 1. 棧
6 作用:
7 存儲局部變量以及所有代碼的執行的.
8 //局部變量: 就是定義在方法中或者方法聲明上的變量.
9 特點:
10 先進後出, 後進先出. //用完就釋放.
11 2. 堆
12 作用:
13 存儲所有new出來的内容(對象)
14 特點:
15 在不确定的時間, 被GC(Java中的垃圾回收機制)回收.
16 3. 方法區
17 作用:
18 用來存儲 位元組碼檔案, 靜态成員, 常量, 具體的方法等内容.
19 分類:
20 代碼區, 方法區, 常量池, 靜态區.
21 4. 本地方法區
22 給本地方法(native修飾的方法)使用的, 我們了解即可.
23 5. 寄存器
24 給CPU使用的, 我們了解即可.
25 */
26
27 //案例: 示範一個數組的記憶體圖.
28 public class Demo03 {
29 public static void main(String[] args) {
30 int[] arr = new int[3];
31 System.out.println(arr[0]); //列印數組中的第一個元素, 值為: 0
32 System.out.println(arr); //[I@1540e19d
33 }
34 } 
1 package com.it.demo08_array;
2
3 //案例: 示範兩個數組的記憶體圖
4 public class Demo04 {
5 public static void main(String[] args) {
6 //1.定義一個長度為3的int類型的數組.
7 int[] arr = new int[3]; //0, 0, 0
8 //2.修改數組中的第一個元素為: 11
9 arr[0] = 11; //11, 0, 0
10 //3.列印數組中的第一, 第二個元素.
11 System.out.println(arr[0]); //11
12 System.out.println(arr[1]); //0
13 //4.列印數組對象.
14 System.out.println(arr); //位址值
15 //5.定義一個int類型的數組, 存儲元素1, 2.
16 int[] arr2 = new int[]{1, 2}; //1, 2
17 //6.修改數組的第二個元素值為: 22.
18 arr2[1] = 22; //1, 22
19 //7.列印數組的第二個元素.
20 System.out.println(arr2[1]); //22
21 //8.列印數組對象.
22 System.out.println(arr2); //位址值
23 }
24 } 1 package com.it.demo08_array;
2
3 //案例: 示範兩個數組指向同一個位址的記憶體圖.
4 public class Demo05 {
5 public static void main(String[] args) {
6 //1.定義一個int類型的數組, 存儲元素11, 22, 33.
7 int[] arr = new int[]{11, 22, 33};
8 //2.列印數組對象.
9 System.out.println(arr);
10 //3.列印數組中的各個元素值.
11 System.out.println(arr[0]);
12 System.out.println(arr[1]);
13 System.out.println(arr[2]);
14 //4.定義第二個數組, 把第一個數組的位址值指派給第二個數組.
15 int[] arr2 = arr;
16 //5.通過第二個數組, 修改第二個元素值為200.
17 arr2[1] = 200;
18 //6.列印數組對象.
19 System.out.println(arr2);
20 //7.列印數組中的各個元素值.
21 System.out.println(arr[0]);
22 System.out.println(arr[1]);
23 System.out.println(arr[2]);
24
25 System.out.println(arr2[0]);
26 System.out.println(arr2[1]);
27 System.out.println(arr2[2]);
28
29 }
30 } 1 /*
2 二維數組
3 數組中的數組,數組裡面存儲的還是數組
4
5 定義方式和一維數組很相似
6
7 int[][] arr = new int[3][4];
8 定義一個二維數組
9 [3] 表示: 二維數組中,有三個一維數組
10 [4] 表示: 三個一維數組中,每個數組的長度是4
11 */
12 public class ArrayArrayDemo{
13 public static void main(String[] args){
14 int[][] arr = new int[3][4];
15 System.out.println(arr);
16
17 System.out.println(arr[1]);
18 System.out.println(arr[2][3]);
19 }//歡迎加入Java開發交流君樣：909038429
20 } 1 /*
2 int[][] arr = new int[3][] 不推薦
3 二維數組中定義三個一維數組,每個一維數組長度,沒有指定
4 arr[0]
5 arr[1]
6 arr[2]
7 必須要new
8 arr[0] = new int[5];
9 arr[1] = new int[4];
10
11 最簡單的二維數組定義方式
12 int[][] arr = { {1,4} ,{3,6,8}, {0,9,8} };
13 */
14
15 public class ArrayArrayDemo_1{
16 public static void main(String[] args){
17 int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} };
18
19 //問題: 列印7,是數組中的元素0
20
21 System.out.println(arr[2][1]);
22
23 //問題: 輸出結果
24 System.out.println(arr[3][0]);
25 }
26 } 1 /*
2 二維數組的周遊
3 二維數組中,存儲4個一維數組,每個一維數組的長度不同
4
5 周遊: for循環,周遊二維數組
6 周遊過程中, for周遊一維數組
7
8 */
9 public class ArrayArrayDemo_2{
10 public static void main(String[] args){
11 int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} };
12
13 //外循環,周遊二維數組
14 for(int i = 0 ; i < arr.length ;i++){
15 //内循環,周遊每個一維數組 arr[0] arr[1] arr[i]
16 for(int j = 0 ; j < arr[i].length; j++){
17 System.out.print(arr[i][j]);
18 }
19 System.out.println();
20 }
21 }
22 } 1 /*
2 二維數組的周遊求和
3 第一小組銷售額為{11, 12}萬元
4 第二小組銷售額為{21, 22, 23}萬元
5 第三小組銷售額為{31, 32, 33, 34}萬元。
6 每個小組就是一個數組, 三個數組存儲到一個數組中,形成二維數組
7 求和:
8 每個小組求和
9 所有元素求和
10 */
11
12 public class ArrayArrayDemo_3{
13 public static void main(String[] args){
14 int[][] arr = { {11,12} , {21,22,23} ,{31,32,33,34} };
15 //定義變量,儲存2個求和的值
16 int sum = 0 ; //所有元素的求和
17 int groupSum = 0 ; //每個一維數組的求和
18
19 for(int i = 0 ; i < arr.length ; i++){
20 for(int j = 0 ; j < arr[i].length ; j++){
21 //将一維數組的元素求和
22 groupSum += arr[i][j];
23 }
24 System.out.println("每個小組總金額 "+groupSum);
25
26 //将每個一維數組的總和在相加
27 sum += groupSum;
28 //每個唯一數組求和,清空
29 groupSum = 0;
30 }
31 System.out.println("本公司總金額 "+sum);
32 }
33 } 1 /*
2 随機點名器:
3 1 存儲姓名
4 2. 預覽所有人的姓名
5 3. 随機出一個人的姓名
6 */
7 import java.util.Random;
8 public class CallName{
9 public static void main(String[] args){
10 //存儲姓名,姓名存儲到數組中
11 //數組存儲姓名,姓名的資料類型,String
12 String[] names = {"張三","李四","王五","李蕾","韓梅梅","小名","老王","小華","約翰遜","愛麗絲"};
13
14 //預覽: 周遊數組,列印所有姓名
15 for(int i = 0 ; i < names.length ; i++){
16 System.out.println(names[i]);
17 }//歡迎加入Java開發交流君樣：909038429
18 System.out.println("=============");
19
20 //随機出一個人的名
21 //利用随機數,生成一個整數,作為索引,到數組中找到對應的元素
22 Random ran = new Random();
23 //随機數,範圍必須是0-數組的最大索引
24 int index = ran.nextInt(names.length);//index 就是随機數,作為索引
25 System.out.println(names[index]);
26 }
27 } 1 package com.it.demo01_array;
2
3 /*
4 案例: 數組内容回顧.
5
6 數組簡介:
7 概述:
8 就是用來同時存儲 多個 同類型元素的 容器.
9 特點:
10 1. 元素都有編号(下标, 角标, 索引), 且編号是從 0 開始的.
11 2. 數組的每個元素都有預設值.
12 int[] -> 0
13 double[] -> 0.0
14 boolean[] -> false
15 引用類型數組-> null
16 定義格式:
17 動态初始化: 我們給長度, 系統給預設值.
18 格式1:
19 int[] arr = new int[3];
20 格式2:
21 int arr[] = new int[3];
22 靜态初始化: 我們給值, 由系統決定長度.
23 格式1:
24 int[] arr = new int[]{11, 22, 33};
25 格式2:
26 int[] arr = {11, 22, 33};
27 數組的基本使用格式:
28 數組名[索引] 根據索引, 擷取數組中的該元素值.
29 數組名[索引] = 值 修改指定索引處的元素為指定的值.
30 數組名.length 擷取數組的長度
31 數組名.length - 1 擷取數組中元素的 最大索引值.
32 數組的記憶體圖:
33 了解.
34 */
35 public class Demo01 {
36 public static void main(String[] args) {
37
38 }
39 } 1 package com.it.demo01_array;
2
3 /*
4 案例: 示範使用數組時的兩個小問題.
5
6 問題一: 數組索引越界異常(ArrayIndexOutOfBoundsException)
7 問題描述:
8 數組的長度為2, 但是我們卻通路了數組中的第3個元素, 此時代碼就有問題了, 會報: 數組索引越界異常(ArrayIndexOutOfBoundsException)
9 産生原因:
10 你通路了數組中不存在的元素.
11 解決方案:
12 通路數組中存在的元素即可.
13 */
14 public class Demo02 {
15 public static void main(String[] args) {
16 //1.定義int類型的數組, 存儲元素11, 22.
17 //int[] arr = new int[]{11, 22};
18 int[] arr = {11, 22}; //int a = 10;
19 arr = new int[]{1, 2, 3, 4, 5}; //a = 20;
20 //arr = {1, 2, 3, 4, 5, 6}; //這樣寫會報錯, 靜态初始化的 文法糖隻有在定義數組的時候有效.
21
22 //2.列印數組中的第2個元素.
23 System.out.println(arr[1]); //22
24
25 //3.嘗試列印數組中的第3個元素.
26 System.out.println(arr[2]); //數組索引越界異常(ArrayIndexOutOfBoundsException)
27 }
28 } 1 package com.it.demo01_array;
2
3 /*
4 案例: 示範空指針異常.
5
6 問題二: 空指針異常(NullPointerException)
7 問題描述:
8 我們定義了數組對象, 初始化值為11, 22, 然後将null指派給數組對象, 發現列印數組的第一個元素時, 程式報錯: 空指針異常(NullPointerException)
9 産生原因:
10 null表示空, 即什麼都沒有, 是以你通過null去通路數組中的元素, 肯定找不到, 于是就報錯.
11 解決方案:
12 new一個具體的數組, 然後來通路數組中存在的元素即可.
13
14 */
15 public class Demo03 {
16 public static void main(String[] args) {
17 //1.定義int類型的數組, 存儲元素11, 22.
18 int[] arr = {11, 22};
19 //2.将null(空常量)指派給數組.
20 arr = null;
21 //arr = new int[3];
22 //3.嘗試列印數組的第一個元素.
23 System.out.println(arr[0]); //空指針異常(NullPointerException)
24 }
25 } 1 package com.it.demo02_exercise;
2
3 /*
4 案例: 周遊數組.
5
6 大白話翻譯: 即逐個擷取數組中的元素, 并列印.
7 */
8 public class Demo01 {
9 public static void main(String[] args) {
10 //1.定義int類型的數組arr, 存儲元素11, 22, 33, 44, 55.
11 int[] arr = {11, 22, 33, 44, 55};
12
13 //2.通過for循環, 周遊數組.
14
15 //方式二: 實際開發版
16 //2.1 通過for循環, 擷取數組中所有元素的索引.
17 for (int i = 0; i < arr.length; i++) {
18 //i就是數組中每個元素的: 索引值.
19
20 //2.2 根據 數組名[索引] 的方式, 擷取數組中的元素.
21 System.out.println(arr[i]);
22 }
23
24 System.out.println("------------------------");
25 //方式一: 最Low版
26 System.out.println(arr[0]);
27 System.out.println(arr[1]);
28 System.out.println(arr[2]);
29 System.out.println(arr[3]);
30 System.out.println(arr[4]);
31 }//歡迎加入Java開發交流君樣：909038429
32 } 1 package com.it.demo02_exercise;
2
3 /*
4 案例: 擷取數組元素的最大值.
5
6 需求:
7 已知各位美女的顔值如下圖, 請求出下圖中, 顔值最高的數字, 并列印到控制台上.
8 即:求數組int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值.
9
10 細節:
11 1. 假設數組的第一個元素值為最大(小)值, 這個值不能我們自定義, 否則可能會比數組中所有元素值都大, 或者都小.
12 2. 從數組的第二個元素開始周遊, 逐個比較, 可以減少一次比較次數, 進而節約資源, 提高效率.
13 */
14 public class Demo02 {
15 public static void main(String[] args) {
16 //已知各位美女的顔值如下圖, 請求出下圖中, 顔值最高的數字, 并列印到控制台上.
17 //即:求數組int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值.
18 //1. 定義數組, 記錄要擷取最值的元素.
19 int[] arr = {5, 15, 2000, 10000, 100, 4000};
20
21 //2. 定義變量, 用來記錄數組元素的最大值.
22 int max = arr[0];
23
24 //3. 周遊數組, 擷取到每一個元素.
25 for (int i = 1; i < arr.length; i++) {
26 //arr[i]: 就是數組中的每個元素
27 //4. 依次比較目前周遊到的元素 是否大于 臨時變量max的值, 如果大, 就将其值指派給max.
28 if (arr[0] > max)
29 max = arr[i];
30 }
31 //5. for循環結束後, max記錄的就是數組元素的最大值, 列印結果即可.
32 System.out.println("數組元素最大值是: " + max);
33 }
34 } 1 package com.it.demo02_exercise;
2
3 /*
4 案例: 示範數組元素的反轉.
5
6 解決方案:
7 思路一: 初始化條件定義一個.
8 細節一: 必須明确數組元素的交換次數, 即: 數組的長度 / 2
9 細節二: 必須明确誰和誰交換. arr[i] 和 arr[arr.length - 1 - i]
10
11 思路二: 初始化條件定義兩個.
12 細節:
13 定義兩個變量start, end, 分别記錄交換雙方的元素的索引值, 一個(start)從前往後, 一個(end)從後往前.
14
15 分析思路:
16 arr[0] arr[arr.length - 1 - 0]
17 第1次交換: 第一個元素11 和 倒數第一個元素44, 交換完畢後為: 44, 33, 22, 55, 11
18
19 arr[1] arr[arr.length - 1 - 1]
20 第2次交換: 第二個元素33 和 倒數第二個元素55, 交換完畢後為: 44, 55, 22, 33, 11
21
22 ...
23 arr[i] arr[arr.length - 1 - i]
24 第i次交換: 第i個元素 和 倒數第i個元素交換.
25
26 */
27 public class Demo03 {
28 public static void main(String[] args) {
29 //1.定義int類型的數組, 存儲資料: 11, 33, 22, 55, 44.
30 int[] arr = { 11, 33, 22, 55, 44};
31
32 //2.反轉數組
33 /*
34 思路一: 初始化條件定義一個.
35
36 細節一: 必須明确數組元素的交換次數, 即: 數組的長度 / 2
37 細節二: 必須明确誰和誰交換. arr[i] 和 arr[arr.length - 1 - i]
38 */
39 /*for (int i = 0; i < arr.length / 2; i++) {
40 //arr[i] 和 arr[arr.length - 1 - i] 交換
41 int temp = arr[i];
42 arr[i] = arr[arr.length - 1 - i];
43 arr[arr.length - 1 - i] = temp;
44 }*/
45
46
47 //思路二: 初始化條件定義兩個.
48 for(int start = 0, end = arr.length - 1; start < end; start++, end--) {
49 //arr[start] 和 arr[end]交換
50 int temp = arr[start];
51 arr[start] = arr[end];
52 arr[end] = temp;
53 }
54
55 //3. 并列印反轉後的結果.
56 for (int i = 0; i < arr.length; i++) {
57 System.out.println(arr[i]);
58 }
59 }
60 } 1 package com.it.demo02_exercise;
2
3 /*
4 案例: 計算數組的元素和.
5
6 需求:
7 1. 定義int類型的數組, 存儲資料: 11, 33, 22, 55, 44.
8 2. 計算數組的元素和, 并列印結果.
9 */
10 public class Demo04 {
11 public static void main(String[] args) {
12 //1. 定義int類型的數組, 存儲資料: 11, 33, 22, 55, 44.
13 int[] arr = {11, 33, 22, 55, 44};
14 //2. 定義求和變量sum, 用來記錄所有元素的和.
15 int sum = 0;
16 //3. 周遊數組, 擷取到每一個元素.
17 for (int i = 0; i < arr.length; i++) {
18 sum += arr[i];
19 }
20 //4. 将擷取到的值累加給周遊sum
21 System.out.println("數組元素和為: " + sum);
22
23 //5. 列印結果.
24 }
25 } ![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)