Java入門教程七(數組)

數組是最常見的一種數據結構，它是相同類型的用一個標識符封裝到一起的基本類型數據序列或者對象序列。數組使用一個統一的數組名和不同的下標來唯一確定數組中的元素。實質上，數組是一個簡單的線性序列，因此訪問速度很快

一維數組

一組相同類型數據的線性集合,一旦聲明瞭數組的大小，就不能再修改。

創建

數據類型[] 數組名; 數據類型既可以是基本數據類型，也可以是引用數據類型

String[] name; 
Person[] persons;

分配空間

分配空間就是要告訴計算機在內存中為它分配幾個連續的位置來存儲數據。在 Java 中可以使用 new 關鍵字來給數組分配空間

name =new String[10];
persons =new Person[30];

創建並分配空間

int arr=new int[5];

初始化一維數組

數組可以進行初始化操作，在初始化數組的同時，可以指定數組的大小，也可以分別初始化數組中的每一個元素

int[] number=new int[5];
number[0]=1;
number[1]=2;
number[2]=3;
number[3]=5;
number[4]=8;
//或
int[] number=new int[]{1, 2, 3, 4, 5};
//或
int[] number={1,2,3,5,8};

獲取元素

指定元素所在數組的下標獲取

int[] number={1,2,3,4,5};
System.out.println(number[0]);//輸出1

遍歷

利用 for 循環語句遍歷 number 數組中的全部元素

int[] number={1,2,3,4,5};
for (int i=0;i
二維數組
以第一個下標表示元素所在的行，第二個下標表示元素所在的列,二維數組被看作數組的數組
創建
type 表示二維數組的類型，array 表示數組名稱，第一個中括號表示行，第二個中括號表示列 
type[][] array;//例：int[][] age;
初始化
array=new type[][]{值 1,值 2,值 3,…,值 n};
array=new type[][]{new 構造方法(參數列),…};
type[][] array={{第1行第1列的值,第1行第2列的值,…},{第2行第1列的值,第2行第2列的值,…},…};
一個二行二列的二維數組 temp，並對數組中的元素進行了初始化
//方式一
int[][] temp;
temp =new int[][]
{
 {1,2},{3,4}
};
//方式二
int[][] temp;
temp=new int [][]
{
 {new int(1),new int(2)},{new int(3),new int(4)}
};
//方式三
int[][] temp={{1,2},{3,4}};
 
獲取元素
使用下標來獲取
array[i][j];
int[][] temp={{1,2},{3,4},{5,6}};
System.out.println(temp[1][1]);//輸出1
遍歷
在一維數組中直接使用數組的 length 屬性獲取數組元素的個數。而在二維數組中，直接使用 length 屬性獲取的是數組的行數，在指定的索引後加上 length（如 array[0].length）表示的是該行擁有多少個元素，使用嵌套循環來遍歷二維數組
public static void main(String[] args)
{
 double[][] temp={{1,2},{3,4},{5,6}};
 for(int i=0;i
多維數組
除了一維數組和二維數組外，Java 中還支持更多維的數組，如三維數組、四維數組和五維數組等，它們都屬於多維數組
以三維數組為例來介紹多維數組，三維數組有三個層次，可以將三維數組理解為一個一維數組，其內容的每個元素都是二維數組。依此類推，可以獲取任意維數的數組。
多維數組的聲明、初始化和使用都與二維數組相似。
array[i][j][r];
int[][][] temp={{1,2,1},{3,4,3},{5,6,5}};
System.out.println(temp[1][1][1]);//輸出1
 
其他與二維數組基本相似
數組比較
數組相等的條件不僅要求數組元素的個數必須相等，而且要求對應位置的元素也相等。Arrays 類提供了 equals() 方法比較整個數組，arrayA 是用於比較的第一個數組，arrayB 是用於比較的第二個數組
Arrays.equals(arrayA, arrayB);
int[] arr1={1,2,3};
int[] arr2={1,2,3};
int[] arr3={1,2,3,4};
Arrays.equals(arr1, arr2);//ture
Arrays.equals(arr1, arr3);//false
數組查找
查找數組是指從數組中查詢指定位置的元素，或者查詢某元素在指定數組中的位置。使用 Arrays 類的 binarySearch() 方法可以實現數組的查找，該方法可使用二分搜索法來搜索指定數組，以獲得指定對象，該方法返回要搜索元素的索引值，binarySearch() 方法有多種重載形式來滿足不同類型數組的查找需要，常用的重載形式有兩種。
在進行數組查詢之前，必須對數組進行排序（可以使用 sort() 方法）。如果沒有對數組進行排序，則結果是不確定的。如果數組包含多個帶有指定值的元素，則無法確認找到的是哪一個
 
binarySearch(Object[] a,Object key);
a 表示要搜索的數組，key 表示要搜索的值。如果 key 包含在數組中，則返回搜索值的索引；否則返回 -1 或“-插入點”。插入點指搜索鍵將要插入數組的位置，即第一個大於此鍵的元素索引
int[] arr={1,2,3};
Arrays.binarySearch(arr,1);//查到，位置0
Arrays.binarySearch(arr,4);//查不到，返回-1
binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
a 表示要進行查找的數組，fromIndex 指定範圍的開始處索引（包含開始處），toIndex 指定範圍的結束處索引（不包含結束處），key 表示要搜索的元素
int[] arr={1,2,3};
Arrays.binarySearch(arr,0,2,1);//查到，位置0
Arrays.binarySearch(arr,0,1,3);//查不到，返回-1
數組複製
實現數組複製有 4 種方法，分別為使用 Arrays 類的 copyOf() 方法和 copyOfRange() 方法、System 類的 arraycopy() 方法和 Object 類的 clone() 方法
copyOf()、copyOfRange()
copyOf() 方法是複製數組至指定長度
Arrays.copyOf(dataType[] srcArray,int length);
srcArray 表示要進行復制的數組，length 表示複製後的新數組的長度，使用這種方法複製數組時，默認從源數組的第一個元素（索引值為 0）開始複製，目標數組的長度將為 length。如果 length 大於 srcArray.length，則目標數組中採用默認值填充（如：int類型數組默認值為0）；如果 length 小於 srcArray.length，則複製到第 length 個元素（索引值為 length-1）即止。 
int arr[]=new int[]{1,2,3};
int[] newArr=(int[])Arrays.copyOf(arr,4);//新數組1,2,3,0
copyOfRange() 方法則將指定數組的指定長度複製到一個新數組中
Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)
srcArray 表示源數組；startIndex 表示開始複製的起始索引，目標數組中將包含起始索引對應的元素，另外，startIndex 必須在 0 到 srcArray.length 之間；endIndex 表示終止索引，目標數組中將不包含終止索引對應的元素，endIndex 必須大於等於 startIndex，可以大於 srcArray.length，如果大於 srcArray.length，則目標數組中使用默認值填充
int arr[]=new int[]{1,2,3};
int[] newArr=(int[])Arrays.copyOf(arr,1，4);//新數組2,3,0
arraycopy()
arraycopy() 方法位於 java.lang.System 類中
System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)
srcArray 表示源數組；srcIndex 表示源數組中的起始索引；destArray 表示目標數組；destIndex 表示目標數組中的起始索引；length 表示要複製的數組長度，length+srcIndex 必須小於等於 srcArray.length，同時 length+destIndex 必須小於等於 destArray.length
int arr[]=new int[]{1,2,3};
int newArr[]==new int[]{4,5,6};
System.arraycopy(arr,0, newArr,2,3);//新數組4,2,6
clone()
clone() 方法也可以實現複製數組。該方法是類 Object 中的方法，可以創建一個有單獨內存空間的對象。因為數組也是一個 Object 類，因此也可以使用數組對象的 clone() 方法來複制數組 
array_name.clone()
int[] targetArray=(int[])sourceArray.clone();
數組排序
java.util.Arrays 類中的 sort() 方法對數組進行排序分為以下兩步：導入 java.util.Arrays 包。使用 Armys.sort(數組名) 語法對數組進行排序，排序規則是從小到大，即升序。
int[] arr=new int[]{1,5,4,3,6,2};
Arrays.sort(scores);//輸出 1,2,3,4,5,6
冒泡排序
冒泡排序（Bubble Sort）是常用的數組排序算法之一，冒泡排序的基本思想是：對比相鄰的元素值，如果滿足條件就交換元素值，把較小的元素值移動到數組前面，把大的元素值移動到數組後面（也就是交換兩個元素的位置），這樣數組元素就像氣泡一樣從底部上升到頂部。
int[] arr={6,3,8,2,9,1};
for(int i=0;iarr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
快速排序
快速排序（Quicksort）是對冒泡排序的一種改進，快速排序的基本思想是：通過一趟排序，將要排序的數據分隔成獨立的兩部分，其中一部分的所有數據比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此使整個數據變成有序序列。 
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
public static void quickSort(int[] arr,int low,int high){
 int i,j,temp,t;
 if(low>high){
 return;
 }
 i=low;
 j=high;
 temp = arr[low];//temp就是基準位
 while (i=arr[i]&&i
選擇排序
選擇排序法也可以對上述數組中的元素進行排序，但是它與冒泡排序不同。選擇排序是指每一趟從待排序的數據元素中選出最大（或最小）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完
int[] number={13,15,24,99,4,1};
int index;
for(int i=1;inumber[index])
 {
 index=j; //查找最大值
 }
 }
 int temp=number[number.length-i];
 number[number.length-1]=number[index];
 number[index]=temp;
}