數組對于每一門編輯應語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。

? ? ? ?Java語言中提供的數組是用來存儲固定大小的同類型元素。 可以聲明一個數組變量，如numbers[100]來代替直接聲明100個獨立變量number0，number1，....，number99。

一、數組基礎

下面介紹Java數組的聲明、創建和初始化，并給出其對應的代碼：

1、聲明數組變量

? ? ? ??首先必須聲明數組變量，才能在程序中使用數組。在聲明數組變量時，需要指出數組類型（數組類型緊跟[]）和數組變量的名字。

下面是聲明數組變量的語法（以int 型為例）：

[java]?view plaincopy

int[]?a;?//?首選的方法??

或

[java]?view plaincopy

int?a[];?//?效果相同，但不是首選方法??

注意: 建議使用int [] a的聲明風格聲明數組變量。 int a[] 風格是來自 C/C++ 語言 ，在Java中采用是為了讓 C/C++ 程序員能夠快速理解java語言。

2、創建數組

Java語言使用new操作符來創建數組，語法如下：

[java]?view plaincopy

arrayRefVar?=?new?dataType[arraySize];??

上面的語法語句做了兩件事：

一、使用dataType[arraySize]創建了一個數組。
二、把新創建的數組的引用賦值給變量 arrayRefVar。

數組變量的聲明，和創建數組可以用一條語句完成，如下所示：

[java]?view plaincopy

dataType[]?arrayRefVar?=?new?dataType[arraySize];??

另外，你還可以使用如下的方式創建數組。

[java]?view plaincopy

Type[]?arrayRefVar?=?{value0,?value1,?...,?valuek};??

數組的元素是通過索引訪問的。數組索引從0開始，所以索引值從0到arrayRefVar.length-1。

實例

下面的語句首先聲明了一個數組變量myList，接著創建了一個包含10個double類型元素的數組，并且把它的引用賦值給myList變量。

[java]?view plaincopy

double[]?myList?=?new?double[10];??

下面的圖片描繪了數組myList。這里myList數組里有10個double元素，它的下標從0到9。

3、處理數組

? ? ?數組的元素類型和數組的大小都是確定的，所以當處理數組元素時候，我們通常使用基本循環或者foreach循環。

示例

該實例完整地展示了如何創建、初始化和操縱數組：

[java]?view plaincopy

public?class?TestArray?{??

public?static?void?main(String[]?args)?{??

double[]?myList?=?{1.9,?2.9,?3.4,?3.5};??

//打印所有數組元素??

for?(int?i?=?0;?i?<?myList.length;?i++)?{??

System.out.println(myList[i]?+?"?");??

}??

//?計算所有元素的總和??

double?total?=?0;??

for?(int?i?=?0;?i?<?myList.length;?i++)?{??

total?+=?myList[i];??

}??

System.out.println("Total?is?"?+?total);??

//?查找最大元素??

double?max?=?myList[0];??

for?(int?i?=?1;?i?<?myList.length;?i++)?{??

if?(myList[i]?>?max)?max?=?myList[i];??

}??

System.out.println("Max?is?"?+?max);??

}??

}??

以上實例編譯運行結果如下：

[java]?view plaincopy

1.9??

2.9??

3.4??

3.5??

Total?is?11.7??

Max?is?3.5??

3.1、foreach循環

JDK 1.5 引進了一種新的循環類型，被稱為foreach循環或者加強型循環，它能在不使用下標的情況下遍歷數組。

示例
　　該實例用來顯示數組myList中的所有元素：

[java]?view plaincopy

public?class?TestArray?{??

public?static?void?main(String[]?args)?{??

double[]?myList?=?{1.9,?2.9,?3.4,?3.5};??

//打印所有數組元素??

for?(double?element:?myList)?{??

System.out.println(element);??

}??

}??

}??

以上實例編譯運行結果如下：

[java]?view plaincopy

1.9??

2.9??

3.4??

3.5??

?

4、數據拷貝

? ? ? 在Java中，允許講一個數組變量拷貝給另一個數組變量。這里有兩種方法：

1）將一個數組所有值拷貝到新的數組中去，使用Arrays 類的copyOf?方法：

[java]?view plaincopy

int[]?copiedLucyNumbers?=?Arrays.coyOf?(luclyNumbers,?luckyNumbers.length);??

其中，第二個參數是新數組的參數；

2）用System類的arraycopy方法講一個數組的元素拷貝到另一個數組中。其語法格式為：

[java]?view plaincopy

System.arraycopy?(from,?fromIndex,?to,?toIndex,?count?);??

參數：

from - 源數組。?
fromIndex - 源數組中的起始位置。?
to- 目標數組。?
toIndex- 目標數據中的起始位置。?
count- 要復制的數組元素的數量。?

?

5、數組作為函數的參數

? ? ? 數組可以作為參數傳遞給方法。例如，下面的例子就是一個打印int數組中元素的方法。

[java]?view plaincopy

public?static?void?printArray(int[]?array)?{??

for?(int?i?=?0;?i?<?array.length;?i++)?{??

System.out.print(array[i]?+?"?");??

}??

}??

下面例子調用printArray方法打印出 3，1，2，6，4和2：

[java]?view plaincopy

printArray(new?int[]{3,?1,?2,?6,?4,?2});??

數組作為函數的返回值

[java]?view plaincopy

public?static?int[]?reverse(int[]?list)?{??

int[]?result?=?new?int[list.length];??

for?(int?i?=?0,?j?=?result.length?-?1;?i?<?list.length;?i++,?j--)?{??

result[j]?=?list[i];??

}??

return?result;??

}??

以上實例中result數組作為函數的返回值。

?

6、Arrays 類

? ? ? ?java.util.Arrays類能方便地操作數組，它提供的所有方法都是靜態的。具有以下功能：

1、給數組賦值：通過fill方法。
2、對數組排序：通過sort方法,按升序。
3、比較數組：通過equals方法比較數組中元素值是否相等。
4、查找數組元素：通過binarySearch方法能對排序好的數組進行二分查找法操作

具體說明請查看下表：

序號 方法和說明

1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。如果查找值包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果兩個指定的?long?型數組彼此相等，則返回 true。如果兩個數組包含相同數量的元素，并且兩個數組中的所有相應元素對都是相等的，則認為這兩個數組是相等的。換句話說，如果兩個數組以相同順序包含相同的元素，則兩個數組是相等的。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 將指定的 int 值分配給指定 int 型數組指定范圍中的每個元素。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。
4	public static void sort(Object[] a) 對指定對象數組根據其元素的自然順序進行升序排列。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

二、一維數組

1、一維數組的聲明

使用一個數據時，必須要對其進行聲明，這個道理對于數組來說也一樣，數組在使用之前也必須先聲明。先看下面的代碼，是如何聲明一個變量的。

[java]?view plaincopy

int?a;??

　　仔細分析一下：int 是指變量的數據類型，a 是指變量名，由變量的聲明可以聯系到數組的聲明。
[java]?view plaincopy

int?a[];??

　　仔細分析一下：int 是指數組中所有數據的數據類型，也可以說是這個數組的數據類型，a[]表示數組名。

基本類型數組的聲明有幾種形式：

[java]?view plaincopy

int?a[];??

int[]?a;??

這兩種形式沒有區別，使用效果完全一樣，讀者可根據自己的編程習慣選擇。
　　

2、一維數組的初始化

? ? ? ? 數組的初始化分為靜態初始化和動態初始化：靜態初始化是在聲明數組的同時進行賦值; 動態初始化是在聲明數組后在對其進行賦值。

1)、靜態初始化

[java]?view plaincopy

int?intArray[]={1,2,3,4};??

String?stringArray[]={"abc",?"How",?"you"};??

2)動態初始化

[java]?view plaincopy

intArray?=?new?int[5];??

String?stringArray[?];??

String?stringArray?=?new?String[3];/*為數組中每個元素開辟引用空間(32位)?*/??

stringArray[0]=?new?String("How");//為第一個數組元素開辟空間??

stringArray[1]=?new?String("are");//為第二個數組元素開辟空間??

stringArray[2]=?new?String("you");//?為第三個數組元素開辟空間??

3、一維數組元素的引用

?一維數組元素的引用方式為：

[java]?view plaincopy

arrayName[index]??

index為數組下標，它可以為整型常數或表達式，下標從0開始。每個數組都有一個屬性length指明它的長度，例如：intArray.length指明數組intArray的長度。

? ? ? ?在編寫程序的過程中，如果要引用數組的長度，一般是使用變量“length”，在程序中一般是使用下列格式：

? ? ? ?數組名.length

示例：創建一個擁有 10 個元素的整數型數組 a，并通過 a[i]=i*i 為每個數組元素賦值，最后將結果輸出。

[java]?view plaincopy

public?class?arrary1{??

public?static?void?main(String[]?args){??

int[]?a;??

a?=?new?int[10];??

int?i;??

for(i=0;i<10;i++){??

System.out.println("a[i]="+(i*i));??

}??

}??

}??

運行結果：

[java]?view plaincopy

??a[0]=0??

a[1]=1??

a[2]=4??

a[3]=9??

a[4]=16??

a[5]=25??

a[6]=36??

a[7]=49??

a[8]=64??

a[9]=81??

程序先作了個數組聲明“int[] a”，然后，創建了一個數組對象“a=new int[10]”，最后使用循環語句輸出數組中所有數據。

幾點說明：

1、數組是對象類型數據，聲明數組時注意new的使用。

2、聲明數組時，一定要考慮數組的最大容量，防止容量不夠的現象。數組一旦被聲明，它的容量就固定了，不容改變。如果想在運行程序時改變容量，就需要用到數組列表。數組列表不屬于本章的內容，在數據結構一部分會詳細講述。

3、其實數組有一個缺點，就是一旦聲明，就不能改變容量，這個也是其使用頻率不高的原因。一般存儲數據會使用數組列表或 vector，這兩種數據結構來存儲數據。

三、二維數組

1、二維數組的定義

[java]?view plaincopy

type?arrayName[?][?];??

type?[?][?]arrayName;??

Java語言中，由于把二維數組看作是數組的數組，數組空間不是連續分配的，所以不要求二維數組每一維的大小相同。

2、動態初始化

1) 直接為每一維分配空間，格式如下：

[java]?view plaincopy

arrayName?=?new?type[arrayLength1][arrayLength2];??

int?a[?][?]?=?new?int[2][3];??

2) 從最高維開始，分別為每一維分配空間：

[java]?view plaincopy

arrayName?=?new?type[arrayLength1][?];??

arrayName[0]?=?new?type[arrayLength20];??

arrayName[1]?=?new?type[arrayLength21];??

…??

arrayName[arrayLength1-1]?=?new?type[arrayLength2n];??

3) 例：
　　二維簡單數據類型數組的動態初始化如下： [java]?view plaincopy

int?a[?][?]?=?new?int[2][?];??

a[0]?=?new?int[3];??

a[1]?=?new?int[5];??

對二維復合數據類型的數組，必須首先為最高維分配引用空間，然后再順次為低維分配空間。而且，必須為每個數組元素單獨分配空間。例如： [java]?view plaincopy

String?s[?][?]?=?new?String[2][?];??

s[0]=?new?String[2];//為最高維分配引用空間??

s[1]=?new?String[2];?//為最高維分配引用空間??

s[0][0]=?new?String("Good");//?為每個數組元素單獨分配空間??

s[0][1]=?new?String("Luck");//?為每個數組元素單獨分配空間??

s[1][0]=?new?String("to");//?為每個數組元素單獨分配空間??

s[1][1]=?new?String("You");//?為每個數組元素單獨分配空間??

3、二維數組元素的引用

對二維數組中的每個元素，引用方式為：

[java]?view plaincopy

arrayName[index1][index2]??

二維數組舉例：兩個矩陣相乘 [java]?view plaincopy

public?class?MatrixMultiply{??

public?static?void?main(String?args[]){??

int?i,j,k;??

int?a[][]=new?int?[2][3];?//動態初始化一個二維數組??

int?b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態初始化一個二維數組??

int?c[][]=new?int[2][4];?//動態初始化一個二維數組??

for?(i=0;i<2;i++)??

for?(j=0;?j<3?;j++)??

a[i][j]=(i+1)*(j+2);??

for?(i=0;i<2;i++){??

for?(j=0;j<4;j++){??

c[i][j]=0;??

for(k=0;k<3;k++)??

c[i][j]+=a[i][k]*b[k][j];??

}??

}??

System.out.println("*******Matrix?C********");//打印Matrix?C標記??

for(i=0;i<2;i++){??

for?(j=0;j<4;j++)??

System.out.println(c[i][j]+"?");??

System.out.println();??

}??

}??

} ?

總結

以上是生活随笔為你收集整理的Java 基础——数组解析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。