數組

一、數組的一些特點

1、數組是一個有界的線性序列，大小被固定、隨機訪問速度非常快（超過集合）；
2、數組可以存儲基本類型，也可以存儲引用類型；
3、數組如果沒被初始化則爲null，數組如果沒被顯式初始化，則會自動初始化。其中的值與數組元素類型的默認初始化值相同；
4、數組可以有多維的，但是，一維數組要比多維的快很多。在對效率要求很高的程序中，一般都不用多維數組，需要用的時候，也常常將多維數組轉換爲一維的存儲方式；
5、數組的聲明不能使用泛型，其實也沒必要在數組上使用泛型；

二、數組的初始化

1、系統默認自動初始化

比如int[] a = int[3]; 實際上與int[] a= {0,0,0}相同。

如果是引用類型則其中自動初始化爲null值。

2、顯式指定初始化

int[] a= {0,0,0};

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

3、使用工具初始化

int[] c = new int[3];

Arrays.fill(c,3);

三、java.util.Arrays

Arrays類是一個非常有用數組工具類，裏面有很多工具方法，檢索、填充、排序、比較、toString()等。

下面給個例子：

import java.util.Arrays;

/**
 * 數組綜合測試
 */
public class TestArrays {
	public static void main(String[] args) {
		int[] i = new int[10];
		// 填充數組
		Arrays.fill(i, 2);
		// 遍歷數組
		for (int x : i) {
			System.out.print(x + " ");
		}
		// toString()數組
		System.out.println("\n" + Arrays.toString(i));
		// 複製數組
		int[] b = new int[12];
		System.arraycopy(i, 0, b, 2, 5);
		System.out.println(Arrays.toString(b));
		// 一維數組的比較
		int[] c = new int[3];
		int[] d = new int[3];
		Arrays.fill(c, 3);
		Arrays.fill(d, 3);
		System.out.println(c.equals(d));
		System.out.println(Arrays.equals(c, d));
		System.out.println("-------------");
		int[][] a1 = { { 1, 2, 3 }, { 4, 5, 6 } };
		int[][] a2 = { { 1, 2, 3 }, { 4, 5, 6 } };
		System.out.println(a1.equals(a2));
		System.out.println(Arrays.equals(a1, a2));
		System.out.println(Arrays.deepEquals(a1, a2));
		// 深度toString()
		System.out.println(Arrays.toString(a1));
		System.out.println(Arrays.deepToString(a1));

		// 數組的排序
		int[] a3 = { 3, 2, 5, 4, 1 };
		System.out.println(Arrays.toString(a3));
		Arrays.sort(a3);
		System.out.println(Arrays.toString(a3));
		// 一維數組數值檢索
		int index1 = Arrays.binarySearch(a3, 4);
		int index2 = Arrays.binarySearch(a3, -12);
		int index3 = Arrays.binarySearch(a3, 8);
		System.out.println(index1 + " " + index2 + " " + index3);
	}
}

執行結果：

2 2 2 2 2 2 2 2 2 2 
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2] 
[0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0] 
false 
true 
------------- 
false 
false 
true 
[[I@3e25a5, [I@19821f] 
[[1, 2, 3], [4, 5, 6]] 
[3, 2, 5, 4, 1] 
[1, 2, 3, 4, 5] 
3 -1 -6 

四、數組的複製

java.lang.System

public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)

參數：src - 源數組。 srcPos - 源數組中的起始位置。 dest - 目標數組。 destPos - 目標數據中的起始位置。 length - 要複製的數組元素的數量。

具體用法參看上例。

五、補缺

1、數組的長度：數組名.length；

2、數組元素的訪問：數組名[index],或數組名[index1][index2]；

六、Array類

java.lang.reflect.Array 提供了動態創建和訪問 Java 數組的方法。java.sql.Array SQL 類型 ARRAY 在 Java 編程語言中的映射關係。

七、陷阱

1、填充數組，Arrays.fill()方法只能填充一維基本類型數組。

2、數組複製，不但適合一維數組，也適合多維數組，只是多維數組賦值時候要特別小心，有時候會出一些莫名其妙的問題

int[][] a1 = {{1, 2, 3}, {4, 5, 6}}; 
int[][] ax = newint[3][3];
System.arraycopy(a1,1,ax,1,1); 
System.out.println(Arrays.deepToString(ax));

輸出結果：

[[0, 0, 0], [4, 5, 6], [0, 0, 0]]

如果改爲：

int[][] a1 = {{1, 2, 3}, {4, 5, 6}}; 
int[][] ax = newint[2][4]; 
System.arraycopy(a1,0,ax,0,1); 
int[] x1 = ax[0]; 
System.out.println("二維數組第一個元素的長度："+x1.length);
System.out.println("-----"); 
for (int[] t : ax) {
for (int _i : t) {
System.out.println(_i); 
} 
System.out.println("-----"); 
}

輸出結果：

二維數組第一個元素的長度：3 
----- 
1 
2 
3 
----- 
0 
0 
0 
0 
-----

這個結果看起來就太迷惑了！

3、數組的排序，只能排序基本類型數組，如果是其他類型，可以考慮使用集合工具Collections來做。

4、儘可能不要使用多維數組，多維數組效率會有很大的損失。

JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。

快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。

冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。

選擇排序法是將數組的第一個數據作爲最大或者最小的值，然後通過比較循環，輸出有序的數組。

插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。

<1>利用Arrays帶有的排序方法快速排序

import java.util.Arrays;
 public class Test2{
         public static void main(String[] args){
                 int[] a={5,4,2,4,9,1};
                 Arrays.sort(a);  //進行排序
                 for(int i: a){
                         System.out.print(i);
                 }
         }
 }

<2>冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法
                 for(int i=0;i<args.length-1;i++){
                         for(int j=i+1;j<args.length;j++){
                                 if (args[i]>args[j]){
                                         int temp=args[i];
                                         args[i]=args[j];
                                         args[j]=temp;
                                 }
                         }
                 }
                 return args;
         }

<3>選擇排序算法

public static int[] selectSort(int[] args){//選擇排序算法
                 for (int i=0;i<args.length-1 ;i++ ){
                         int min=i;
                         for (int j=i+1;j<args.length ;j++ ){
                                 if (args[min]>args[j]){
                                         min=j;
                                 }
                         }
                         if (min!=i){
                         int temp=args[i];
                         args[i]=args[min];
                         args[min]=temp;        
                         }
                 }
                 return args;
         }

<4>插入排序算法

public static int[] insertSort(int[] args){//插入排序算法
                 for(int i=1;i<args.length;i++){
                         for(int j=i;j>0;j--){
                                 if (args[j]<args[j-1]){
                                         int temp=args[j-1];
                                         args[j-1]=args[j];
                                         args[j]=temp;        
                                 }else break;
                         }
                 }
                 return args;
         }

最後數組的總結:

數組（array）是相同類型變量的集合，可以使用共同的名字引用它。數組可被定義爲任何類型，可以是一維或多維。數組中的一個特別要素是通過下標來訪問它。數組提供了一種將有聯繫的信息分組的便利方法。注意：如果你熟悉C/C++，請注意， Java數組的工作原理與它們不同。

1、數組不是集合，它只能保存同種類型的多個原始類型或者對象的引用。數組保存的僅僅是對象的引用，而不是對象本身。

2、數組本身就是對象，Java中對象是在堆中的，因此數組無論保存原始類型還是其他對象類型，數組對象本身是在堆中的。

3、數組聲明的兩種形式：一、int[] arr; 二、int arr[]; 推薦使用前者，這符合Sun的命名規範，而且容易瞭解到關鍵點，這是一個int數組對象，而不是一個int原始類型。

4、在數組聲明中包含數組長度永遠是不合法的！如：int[5] arr; 。因爲，聲明的時候並沒有實例化任何對象，只有在實例化數組對象時，JVM才分配空間，這時才與長度有關。

5、在數組構造的時候必須指定長度，因爲JVM要知道需要在堆上分配多少空間。反例：int[] arr = new int[];

6、多維數組的聲明。int[][][] arr; 是三維int型數組。

7、一維數組的構造。形如：String[] sa = new String[5]; 或者分成兩句：String[] sa; sa = new String[5];

8、原始類型數組元素的默認值。對於原始類型數組，在用new構造完成而沒有初始化時，JVM自動對其進行初始化。默認值：byte、short、 int、long--0 float--0.0f double--0.0 boolean--false char--'"u0000'。（無論該數組是成員變量還是局部變量）

9、對象類型數組中的引用被默認初始化爲null。如：Car[] myCar = new Car[10]; 相當於從myCar[0]到myCar[9]都這樣被自動初始化爲myCar[i] = null;

10、對象類型的數組雖然被默認初始化了，但是並沒有調用其構造函數。也就是說：Car[] myCar = new Car[10];只創建了一個myCar數組對象！並沒有創建Car對象的任何實例！

11、多維數組的構造。float[][] ratings = new float[9][]; 第一維的長度必須給出，其餘的可以不寫，因爲JVM只需要知道賦給變量ratings的對象的長度。

12、數組索引的範圍。數組中各個元素的索引是從0開始的，到length-1。每個數組對象都有一個length屬性，它保存了該數組對象的長度。（注意和String對象的length()方法區分開來，這兩者沒有統一起來是很遺憾的。）

13、Java有數組下標檢查，當訪問超出索引範圍時，將產生ArrayIndexOutOfBoundsException運行時異常。注意，這種下標檢查不是在編譯時刻進行的，而是在運行時！也就是說int[] arr = new int[10]; arr[100] = 100; 這麼明顯的錯誤可以通過編譯，但在運行時拋出！Java的數組下標檢查是需要額外開銷的，但是出於安全的權衡還是值得的，因爲很多語言在使用數組時是不安全的，可以任意訪問自身內存塊外的數組，編譯運行都不會報錯，產生難以預料的後果！