1 /*
 2     數組:存儲同一種數據類型的多個元素的容器。
 3     
 4     定義格式：
 5         A:數據類型[] 數組名;
 6         B:數據類型 數組名[];
 7         
 8     舉例：
 9         A:int[] a; 定義一個int類型的數組a變量
10         B:int a[]; 定義一個int類型的a數組變量
11         
12     註意：效果可以認為是一樣的，都是定義一個int數組，但是念法上有些小區別。推薦使用第一種。
13     
14     如何對數組進行初始化呢?
15         A:何謂初始化呢? 就是為數組開辟內存空間，並為每個數組元素賦予值
 
16         B:有幾種方式呢?
17             a:動態初始化 只指定長度，由系統給出初始化值
18             b:靜態初始化 給出初始化值，由系統決定長度
19             
20     動態初始化的格式：
21         數據類型[] 數組名 = new 數據類型[數組長度];
22         
23         舉例：
24         int[] arr = new int[3];    
25         
26     如何獲取數組中的元素呢?
27         通過:
28             數組名[索引]
 
29             索引其實就是每個元素的編號，從0開始，最大索引是數組的長度-1。
30 */
31 class ArrayDemo {
32     public static void main(String[] args) {
33         //定義一個數組
34         //int[] a;
35         //可能尚未初始化變量a
36         //System.out.println(a);
37         
38         int[] arr = new int[3];
39         /*
40             左邊：
41                 int:說明數組中的元素的數據類型是int類型
 
42                 []:說明這是一個數組
43                 arr:是數組的名稱
44                 
45             右邊：
46                 new:為數組分配內存空間。
47                 int:說明數組中的元素的數據類型是int類型
48                 []:說明這是一個數組
49                 3:數組長度，其實也就是數組中元素的個數
50         */
51         
52         System.out.println(arr); //[[email protected] 地址值。
53         //我要地址值沒有意義啊，我就要數據值，怎麽辦呢?
54         //不用擔心，java為你考慮到了。
55         //其實數組中的每個元素都是有編號的，並且是從0開始。最大編號是數組的長度-1。
56         //用數組名和編號的配合就可以獲取數組中的指定編號的元素。這個編號的專業叫法：索引
57         //通過數組名訪問數據的格式是：數組名[索引];
58         System.out.println(arr[0]);
59         System.out.println(arr[1]);
60         System.out.println(arr[2]);
61     }
62 }

 1 /*
 2     定義一個數組，輸出該數組的名稱和數組元素值。
 3     給數組元素賦值，再次輸出該數組的名稱和數組元素值。
 4 */
 5 class ArrayDemo2 {
 6     public static void main(String[] args) {
 7         //定義一個數組
 8         int[] arr = new int[3];
 9         
10         //輸出數組名稱
11         System.out.println(arr);//[[email protected] 地址值
12         //輸出數組元素值
13         System.out.println(arr[0]);
14         System.out.println(arr[1]);
15         System.out.println(arr[2]);
16         System.out.println("----");
17         
18         //給數組元素賦值
19         arr[0] = 100;
20         arr[2] = 200;
21         
22         //輸出數組名稱
23         System.out.println(arr);
24         //輸出數組元素值
25         System.out.println(arr[0]);
26         System.out.println(arr[1]);
27         System.out.println(arr[2]);
28     }
29 }

----------------------------------------------------------------------------

 1 /*
 2     定義第一個數組,定義完畢後，給數組元素賦值。賦值完畢後，在輸出數組名稱和元素。
 3     定義第二個數組,定義完畢後，給數組元素賦值。賦值完畢後，在輸出數組名稱和元素。
 4     定義第三個數組,把第一個數組的地址值賦值給它。(註意類型一致)，通過第三個數組的名稱去把元素重復賦值。
 5     最後，再次輸出第一個數組數組名稱和元素。
 6 */
 7 class ArrayDemo4 {
 8     public static void main(String[] args) {
 9         //定義第一個數組
10         int[] arr = new int[3];
11         arr[0] = 88;
12         arr[1] = 33;
13         arr[2] = 66;
14         System.out.println(arr);
15         System.out.println(arr[0]);
16         System.out.println(arr[1]);
17         System.out.println(arr[2]);
18         System.out.println("----");
19         
20         //定義第二個數組
21         int[] arr2 = new int[3];
22         arr2[0] = 22;
23         arr2[1] = 44;
24         arr2[2] = 55;
25         System.out.println(arr2);
26         System.out.println(arr2[0]);
27         System.out.println(arr2[1]);
28         System.out.println(arr2[2]);
29         System.out.println("----");
30         
31         //定義第三個數組
32         int[] arr3 =  arr;
33         arr3[0] = 100;
34         arr3[1] = 200;
35         System.out.println(arr);
36         System.out.println(arr[0]);
37         System.out.println(arr[1]);
38         System.out.println(arr[2]);
39     }
40 }

三個數組的內存圖解：

 1 /*
 2     數組的靜態初始化：
 3         格式：數據類型[] 數組名 = new 數據類型[]{元素1,元素2,…};
 4         簡化格式：
 5             數據類型[] 數組名 = {元素1,元素2,…};
 6         
 7         舉例：
 8             int[] arr = new int[]{1,2,3};
 9             
10             簡化後：
11             
12             int[] arr = {1,2,3};
13             
14     註意事項：
15         不要同時動態和靜態進行。
16         如下格式：
17             int[] arr = new int[3]{1,2,3}; //錯誤
18 */
19 class ArrayDemo5 {
20     public static void main(String[] args) {
21         //定義數組
22         int[] arr = {1,2,3};
23         
24         System.out.println(arr);
25         System.out.println(arr[0]);
26         System.out.println(arr[1]);
27         System.out.println(arr[2]);
28     }
29 }

數組靜態初始化內存圖解：

/*
    數組操作的兩個常見小問題：
        ArrayIndexOutOfBoundsException:數組索引越界異常
            原因：你訪問了不存在的索引。
        
        NullPointerException:空指針異常
            原因：數組已經不在指向堆內存了。而你還用數組名去訪問元素。
*/
class ArrayDemo6 {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {1,2,3};
        
        //System.out.println(arr[3]);
    
        //引用類型的常量：空常量 null
        arr = null;
        System.out.println(arr[0]);
    }
}

如上代碼段執行如下：

-----------------------------------------------------------------------------

練習：

 1 /*
 2     數組遍歷：就是依次輸出數組中的每一個元素。
 3     
 4     註意：數組提供了一個屬性length，用於獲取數組的長度。
 5           格式：數組名.length
 6 */
 7 class ArrayTest {
 8     public static void main(String[] args) {
 9         //定義數組
10         int[] arr = {11,22,33,44,55};
11         
12         //獲取每一個元素
13         for(int x=0; x<5; x++) {
14             //x=0,1,2,3,4
15             System.out.println(arr[x]);
16         }
17         System.out.println("--------------------");
18         
19         //從0開始我們是明確的，但是為什麽到5呢，我們是數了一下數組的個數
20         //繼續看下個數組如何遍歷
21         int[] arr2 = {1,2,3,4,5,6,7,8,9,10,11,2,2,3,4,5,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8};
22         //而我們在很多時候，數組的元素不能靠數
23         //這個時候，數組就給我們提供了一個屬性：length專門用於獲取數組的長度
24         //格式：數組名.length 返回數組的長度
25         System.out.println(arr.length);
26         System.out.println(arr2.length);
27         System.out.println("--------------------");
28         
29         //改進第一個程序
30         for(int x=0; x<arr.length; x++) {
31             System.out.println(arr[x]);
32         }
33         System.out.println("--------------------");
34         
35         //我們如果想要對多個數組進行遍歷，每個數組的遍歷我們都把代碼寫一遍，麻煩不
36         //麻煩，所以，我們準備用方法改進。
37         //用方法改進後，請調用
38         printArray(arr);
39         System.out.println("--------------------");
40         printArray(arr2);
41         System.out.println("--------------------");
42         printArray2(arr);
43     }
44     
45     /*
46         遍歷數組的方法
47         
48         兩個明確：
49             返回值類型：void
50             參數列表：int[] arr
51     */
52     public static void printArray(int[] arr) {
53         for(int x=0; x<arr.length; x++) {
54             System.out.println(arr[x]);
55         }
56     }
57     
58     //請看改進版本
59     public static void printArray2(int[] arr) {
60         System.out.print("[");
61         for(int x=0; x<arr.length; x++) {
62             if(x == arr.length-1) { //這是最後一個元素
63                 System.out.println(arr[x]+"]");
64             }else {
65                 System.out.print(arr[x]+", ");
66             }
67         }
68     }
69 }

---------------------------------------------------

 1 /*
 2     數組獲取最值(獲取數組中的最大值最小值)
 3     
 4     分析：
 5         A:定義一個數組，並對數組的元素進行靜態初始化。
 6         B:從數組中任意的找一個元素作為參照物(一般取第一個),默認它就是最大值。
 7         C:然後遍歷其他的元素，依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。
 8         D:最後參照物裏面保存的就是最大值。
 9 */
10 class ArrayTest2 {
11     public static void main(String[] args) {
12         //定義一個數組
13         int[] arr = {34,98,10,25,67};
14         
15         //請獲取數組中的最大值
16         /*
17         //從數組中任意的找一個元素作為參照物
18         int max = arr[0];
19         //然後遍歷其他的元素
20         for(int x=1; x<arr.length; x++) {
21             //依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。
22             if(arr[x] > max) {
23                 max = arr[x];
24             }
25         }
26         //最後參照物裏面保存的就是最大值。
27         System.out.println("max:"+max);
28         */
29     
30         //把這個代碼用方法改進
31         //調用方法
32         int max = getMax(arr);
33         System.out.println("max:"+max);
34             
35         //請獲取數組中的最小值
36         int min = getMin(arr);
37         System.out.println("min:"+min);
38     }
39     
40     /*
41         需求：獲取數組中的最大值
42         兩個明確：
43             返回值類型：int
44             參數列表：int[] arr
45     */
46     public static int getMax(int[] arr) {
47         //從數組中任意的找一個元素作為參照物
48         int max = arr[0];
49         //然後遍歷其他的元素
50         for(int x=1; x<arr.length; x++) {
51             //依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。
52             if(arr[x] > max) {
53                 max = arr[x];
54             }
55         }
56         //最後參照物裏面保存的就是最大值。
57         return max;
58     }
59     
60     public static int getMin(int[] arr) {
61         //從數組中任意的找一個元素作為參照物
62         int min = arr[0];
63         //然後遍歷其他的元素
64         for(int x=1; x<arr.length; x++) {
65             //依次獲取和參照物進行比較，如果小就留下來，如果大，就離開。
66             if(arr[x] < min) {
67                 min = arr[x];
68             }
69         }
70         //最後參照物裏面保存的就是最小值。
71         return min;
72     }
73 }

---------------------------------------------------------

 1 /*
 2     數組元素逆序 (就是把元素對調)
 3     
 4     分析：
 5         A:定義一個數組，並進行靜態初始化。
 6         B:思路
 7             把0索引和arr.length-1的數據交換
 8             把1索引和arr.length-2的數據交換
 9             ...
10             只要做到arr.length/2的時候即可。
11 */
12 class ArrayTest3 {
13     public static void main(String[] args) {
14         //定義一個數組，並進行靜態初始化。
15         int[] arr = {12,98,50,34,76};
16         
17         //逆序前
18         System.out.println("逆序前：");
19         printArray(arr);
20         
21         //逆序後
22         System.out.println("逆序後：");
23         //reverse(arr);
24         reverse2(arr);
25         printArray(arr);
26     }
27     
28     /*
29         需求：數組逆序
30         兩個明確：
31             返回值類型：void (有人會想到應該返回的是逆序後的數組，但是沒必要，因為這兩個數組其實是同一個數組)
32             參數列表：int[] arr
33     */
34     public static void reverse(int[] arr) {
35         /*
36         //第一次交換
37         int temp = arr[0];
38         arr[0] = arr[arr.length-1-0];
39         arr[arr.length-1-0] = temp;
40         
41         //第二次交換
42         int temp = arr[1];
43         arr[1] = arr[arr.length-1-1];
44         arr[arr.length-1-1] = temp;
45         
46         //第三次交換
47         int temp = arr[2];
48         arr[2] = arr[arr.length-1-2];
49         arr[arr.length-1-2] = temp;
50         */
51         //用循環改進
52         for(int x=0; x<arr.length/2; x++) {
53             int temp = arr[x];
54             arr[x] = arr[arr.length-1-x];
55             arr[arr.length-1-x] = temp;
56         }
57     }
58     
59     public static void reverse2(int[] arr) {
60         for(int start=0,end=arr.length-1; start<=end; start++,end--) {
61             int temp = arr[start];
62             arr[start] = arr[end];
63             arr[end] = temp;
64         }
65     }
66     
67     //遍歷數組
68     public static void printArray(int[] arr) {
69         System.out.print("[");
70         for(int x=0; x<arr.length; x++) {
71             if(x == arr.length-1) { //這是最後一個元素
72                 System.out.println(arr[x]+"]");
73             }else {
74                 System.out.print(arr[x]+", ");
75             }
76         }
77     }
78 }

----------------------------------------------------------------------------

 1 /*
 2     數組查表法(根據鍵盤錄入索引,查找對應星期)
 3         意思是：String[] strArray = {"星期一","星期二",...};
 4 */
 5 import java.util.Scanner;
 6 
 7 class ArrayTest4 {
 8     public static void main(String[] args) {
 9         //定義一個字符串數組
10         String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
11         
12         //創建鍵盤錄入對象
13         Scanner sc = new Scanner(System.in);
14         
15         System.out.println("請輸入一個數據(0-6)：");
16         int index = sc.nextInt();
17         
18         System.out.println("你要查找的日期是："+strArray[index]);
19     }
20 }

-------------------------------------------------

 1 /*
 2     需求：數組元素查找(查找指定元素第一次在數組中出現的索引)
 3     
 4     分析：
 5         A:定義一個數組，並靜態初始化。
 6         B:寫一個功能實現
 7             遍歷數組，依次獲取數組中的每一個元素，和已知的數據進行比較
 8             如果相等，就返回當前的索引值。
 9 */
10 class ArrayTest5 {
11     public static void main(String[] args) {
12         //定義一個數組，並靜態初始化
13         int[] arr = {200,250,38,888,444};
14         
15         //需求：我要查找250在這個數組中第一次出現的索引
16         int index = getIndex(arr,250);
17         System.out.println("250在數組中第一次出現的索引是："+index);
18         
19         int index2 = getIndex2(arr,250);
20         System.out.println("250在數組中第一次出現的索引是："+index2);
21         
22         int index3 = getIndex2(arr,2500);
23         System.out.println("2500在數組中第一次出現的索引是："+index3);
24     }
25     
26     /*
27         需求：查找指定數據在數組中第一次出現的索引
28         兩個明確：
29             返回值類型：int
30             參數列表：int[] arr,int value
31     */
32     public static int getIndex(int[] arr,int value) {
33         //遍歷數組，依次獲取數組中的每一個元素，和已知的數據進行比較
34         for(int x=0; x<arr.length; x++) {
35             if(arr[x] == value) {
36                 //如果相等，就返回當前的索引值。
37                 return x;
38             }
39         }
40         
41         //目前的代碼有一個小問題
42         //就是假如我要查找的數據在數組中不存在，那就找不到，找不到，你就對應的返回嗎?
43         //所以報錯。
44         
45         //只要是判斷，就可能是false，所以大家要細心。
46         
47         
48         //如果找不到數據，我們一般返回一個負數即可，而且是返回-1
49         return -1;
50     }
51     
52     public static int getIndex2(int[] arr,int value) {
53         //定義一個索引
54         int index = -1;
55         
56         //有就修改索引值
57         for(int x=0; x<arr.length; x++) {
58             if(arr[x] == value) {
59                 index = x;
60                 break;
61             }
62         }
63         
64         //返回index
65         return index;
66     }
67 }

JAVA：一維數組