Java 數組

數組

        數組是最常見的一種資料結構，是相同類型的、用一個辨別符封裝到一起的基本類型資料序列或對象序列。可以用一個統一的數組名和下标來唯一确定數組中的元素。實質上數組是一個簡單的線性序列，是以數組通路起來很快。

Java中雖然資料類型不是對象，但是由資料基本類型組成的則是對象，在程式中引入數組可以更有效的管理和處理資料。

  數組根據維數的不同分為：一維數組、二維數組和多元數組。

5.1  一維數組

5.1.1 建立一維數組

  數組作為對象使用new關鍵字進行配置設定記憶體，必須首先定義數組變量所屬的類型，即聲明數組。聲明一維數組有兩種形式:

數組元素類型 數組名字[];

數組元素類型[] 數組名字；

注：

1.數組元素類型：決定了數組的資料類型，它可以是java中的任意的資料類型，包括基本資料類型和非基本資料類型。

2.數組名字：為一個合法的辨別符。

3.符号“[]”:指明變量是一個數組類型變量類型，單個“[]”表示要建立的是一位數組。

【例】聲明一位數組

int arr[]    //聲明int型數組，數組中的每個元素都是int型數值

String[]str  //聲明String數組，數組中的每個元素都是String型數值

聲明數組後，還不能通路它的任何元素，因為聲明數組僅僅是給出了數組名字的元素的資料類型，要想使用數組還要為其配置設定記憶體空間，且配置設定空間需要指明數組的長度，配置設定記憶體空間的文法格式：

數組名字=new 數組元素類型[數組元素的個數];

.數組名字：已經聲明的數組變量的名稱

.new：對數組配置設定空間的關鍵字。

.數組元素的個數：指定數組中變量的個數，即數組的長度。

【例】為數組配置設定記憶體

arr =new int[5];

5.1.2 初始化一維數組

數組可以與基本資料類型一樣進行初始化的操作，數組的初始化可以分别初始化數組中的每個元素，數組的初始化有兩種方式。

【例】初始化一維數組

int arr[]=new int[]{1,2,3,4}     //第一種初始化方式

int arr2[]={1,2,3,4}             //第二種初始化方式

5.2 二維數組 

二維數組是應用最為廣泛的一種數組，二維數組是指有兩個底标的數組。

5.2.1聲明二維數組

聲明二維數組有兩種方法，文法格式分别如下:

數組元素類型 數組名字[][];

數組元素類型[][] 數組名字；

1.數組元素類型：決定了數組的數組類型，它可以是java中的任意的資料類型，包括基本資料類型和非基本資料類型。

2.數組名字：使用一個合法的辨別符。

3.[][]:兩個“[]”表示要建立的數組是二維數組。

【例】聲明二維數組

float A[][];

5.2.2 建立二維數組

建立二維數組的過程，世紀實際上就是在計算機中申請一個存儲空間。

【例】建立二維數組

int A [][]={1,2,3},{4,5,6}

通過上述代碼建立了一個二維數組，A是數組名，實質上此二維數組相當于一個兩行三列的矩陣，當需要取多元中的值時，可以使用下标來顯示。

5.2.3 初始化二維數組

二維數組的初始化與一位數組的初始化類似，同樣可以使用大括号來完成二維數組的初始化。文法格式：

type arrayname[][]={value1，value2,…value n}

type :數組資料類型

arrayname：數組名稱，一個合法的辨別符

value：數組中各元素的值。

【例】初始化二維數組

int mychar[][]={{12,23},{56,96}}

初始化二維數組後要明确數組的下标都是從0開始的。

5.3三維數組

三維數組是多元數組的一種，是二維數組和一位數組的更新。三維數組則使用三個中括号，初始化三維數組時，由三層大括号進行初始化，使用時也麻煩一些，需要使用三層for循環。

[例]建立Ransack類，在類的主方法中建立三維數組，并将三維數組在控制台輸出。

1. public class Ransack_ {
2. public static void main(String[] args) {
3. int arr[][][]=new int[][][]{
4. {{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
5. //周遊數組
6. for (int i = 0; i < arr.length; i++) {
7. System.out.println("三維數組的第"+(i+1)+"個元素是一個"+arr[0].length+"維數組，内容如下：");
9. for (int j = 0; j < arr[0].length; j++) {
10. //周遊數組
11. for (int k = 0; k < arr[0][0].length; k++) {
12. System.out.print(arr[i][j][k]+"\n");
13. }
14. System.out.println();
15. }
16. }
18. }

5.4周遊數組

1.周遊一維數組

【例】在項目中建立一個Getday類，在主方法中建立int型數組，并實作将各月份的天數列印出來。

1. public class Getday {
2. public static void main(String[] args) {
3. int day[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
4. for (int i = 0; i < 12; i++) {
5. System.out.println((i+1)+"月有"+day[i]+"天"+"\t");
6. if ((i+1)%3==0) {
7. System.out.println();
8. }
9. }

2.周遊二維數組

【例】使用二維數組，輸出一個3行4列的所有元素都是0的矩陣。

1. public class matrix_ {
2. public static void main(String[] args) {
3. int a[][]=new int[3][4];
4. for (int i = 0; i < a.length; i++) {
5. for (int j = 0; j < a[i].length; j++) {
6. System.out.print(a[i][j]);
7. }
8. System.out.println();

5.5數組的基本操作

Java.util包的Arrays類包含了用來操作數組的各種方法。

5.5.1填充替換數組元素

數組中的元素定義完成後，可以通過Arrays類的靜态方法fill()來對數組中的元素進行替換，該方法可以通過各種重載形式可以完成對任意類型數組元素的替換，fill()方法可以有兩種參數類型。(下面以int型為例)

1、fill(int []a,int value)

a:要進行元素替換的數組

value：要儲存數組中的所有元素值。

2.fill(int[]a ，int fromIndex,int toIndex,int value)

a:要進行填充的數組

fromIndex:要使用指定值填充的第一個元素的索引（包括）。

toIndex：使用指定值填充的最後一個元素的索引（不包括）。

value： 要儲存在數組中的所有元素的值。

【例】建立一維數組，并通過fill()方法替換數組中的元素，最後将數組中的各個元素輸出。

1. public class Displace_ {
3. int arr[]=new int[]{45,1,2,3};//定義初始化數組
4. Arrays.fill(arr,1,2,8);//使用fill()方法對數組進行初始化
5. for (int i = 0; i < arr.length; i++) {
6. /**
7. * 使用for循環周遊數組中的元素
8. */
9. System.out.println("第"+i+"個元素是："+arr[i]);//輸出數組中的每個元素
10. }
11. }

5.5.2對數組進行排序

通過Arrays類的靜态，sort()方法可以實作對數組的排序，sort（）方法提供了多種重載形式。可以對任意類型的數組進行升序排序。文法如下：Arrays.sort(object),其中，object是指進行排序的數組名稱。

1. 【例】建立一維數組，将數組排序後輸出。
2. public class text_03 {
4. int []arr=new int[]{23,56,42,6};
5. Arrays.sort(arr);//将數組進行升序排序
6. for (int i = 0; i < arr.length; i++) {
7. System.out.println(arr[i]);

5.5.3複制數組

Arrays類的copyOf()方法與copyOfRange()可以實作對數組的複制。

1、copyOf()方法

文法：copyOf(arr，int newlength)

arr：要進行複制的數組

newlengh：int常量，是指複制後新數組的長度。如果新數組的長度大于數組的長度，則用0來補充。（根據複制數組的類型來決定填充的值，整型數組用0來補充，char型數組用null來補充，如果複制後的數組的長度小于數組arr的長度，則會從數組的第一個元素開始的截取至滿足新數組的長度為止。）

1. 【例】建立一維數組實作将此數組複制到的一個新的長度為5的新數組，并将數組的元素輸出。
2. public class text4 {
4. int []arr=new int []{23,42,12};//定義數組
5. int []newarr=Arrays.copyOf(arr, 5);//複制數組arr得到新的數組newarr
6. for (int i = 0; i < newarr.length; i++) {
7. /**
8. * 周遊新數組
9. */
10. System.out.println(newarr[i]);//将新的數組輸出

5.6數組排序算法

程式常用的排序方法有冒泡排序、直接選擇排序、反轉排序。

在程式設計中，經常需要将一組數列進行排序，這樣更加友善統計與查詢。程式常用的排序方法有冒泡排序、選擇排序和快速排序等。

5.6.1冒泡排序

1、基本思想

冒泡算法是由雙層循環實作的，其中外層循環用于控制排序輪數，内層循環主要用于對比數組中每個臨近元素的大小，以确定是否要交換位置，對比和交換次數随排序輪數而減少。

2、算法的實作

1. 【例】建立一個類，類的代碼将實作冒泡排序的一個示範，排序使用的是正排序。
2. public class BubbleSort {
4. //建立一個二維數組，數組中的元素是亂序的
5. int[]array={63,56,12,36,2,15};
6. //建立冒泡排序的類的一個對象
7. BubbleSort sorter=new BubbleSort();
8. //調用排序方法，将數組進行排序
9. sorter.sort(array);
11. /**
12. * 冒泡法排序
13. * @param array
14. */
15. public void sort(int[] array) {
16. for (int i = 0; i < array.length; i++) {
17. //比較兩個相鄰元素，較大的數往後冒泡
18. for (int j = 0; j < array.length-i; j++) {
19. if (array[j]>array[j+1]) {
20. int temp=array[i];//把第一個元素的值儲存到臨時變量中
21. array[j]=array[j+1];//把第二個元素的值儲存到第一個元素的單元中
22. array[j+1]=temp;//把臨時變量儲存到第二個元素中
24. }
25. }
26. showArray(array);//輸出冒泡排序後的數組的元素
28. /**
29. * 顯示數組中的所有元素
30. * @param array
31. */
32. public void showArray(int[] array) {
33. for (int i:array) {//周遊數組
34. System.out.println(">"+i);//輸出每個元素值
36. System.out.println();

5.6.2直接選擇排序

直接選擇排序的基本思想是指定排序位置與其他數組有元素分别進行對比，如果滿足條件，就交換數組元素，注意，這裡差別于冒泡排序，不是交換相鄰的元素，而是把滿足條件的元素與指定的排序位置交換。這樣排序好的位置逐漸擴大，最後整個數組都成為已排序好的格式。

2、算法實作

1. 【例】建立SelectSort類，這個類的代碼作為直接選擇排序的一個示範，其中排序使用正序排序。
2. public class SelectSort_ {
4. //建立一個數組，數組的元素是亂序的
5. int[]array={63,4,24,1,31,15};
6. //建立直接排序的對象
7. SelectSort_ sorter=new SelectSort_();
8. //調用排序對象的方法将數組排序
9. sorter.sort(array);
12. * 直接排序
16. int index;
17. for (int i = 1; i < array.length; i++) {
18. index=0;
19. for (int j = 1; j < array.length-i; j++) {
20. if(array[j]>array[index]){
21. index=j;
24. //交換位置array.length-i和index（最大值）上的兩個數
25. int temp=array[array.length-i];//把第一個元素值儲存到臨時變量中
26. array[array.length-i]=array[index];//把第二個元素值儲存到第一個元素單元中
27. array[index]=temp;//把臨時變量即就是第一個元素值儲存到第二個元素中
29. showArray(array);//輸出直接選擇排序後的數組值
32. * 顯示數組中的所有元素
35. public void showArray(int[] array) {
36. for (int i:array) {
37. System.out.print(i);

5.6.3反轉排序

思路就是把數組的最後一個元素和第一個元素替換，倒數第二個數和第二個元素替換，以此類推，直到把所有數組元素反轉替換。

5.7小結

數組的下标是從0開始的，最後一個元素的表示總是“數組名.length-1”