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<number.length;i++)
{
    System.out.println(number[i]);//依次輸出1,2,3,4,5
}

二維數組

以第一個下標表示元素所在的行，第二個下標表示元素所在的列,二維數組被看做數組的數組

建立

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<temp.length;i++)
    {
        for(int j=0;j<temp[i].length;j++)
        {
            System.out.println("temp["+i+"]["+j+"]");
        }
    }
}

多維數組

除了一維數組和二維數組外，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;i<arr.length-1;i++){//外層循環控制排序趟數
　　　　　　for(int j=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[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<j) {//先看右邊，依次往左遞減
        while (temp<=arr[j]&&i<j) {
            j--;
        }
        while (temp>=arr[i]&&i<j) {//再看左邊，依次往右遞增
                i++;
        }
        if (i<j) {//若是知足條件則交換
            t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
         }
    }
    //最後將基準爲與i和j相等位置的數字交換
    arr[low] = arr[i];
    arr[i] = temp;
    //遞歸調用左半數組
    quickSort(arr, low, j-1);
    //遞歸調用右半數組
    quickSort(arr, j+1, high);
}
quickSort(arr, 0, arr.length-1);

選擇排序

選擇排序法也能夠對上述數組中的元素進行排序，可是它與冒泡排序不一樣。選擇排序是指每一趟從待排序的數據元素中選出最大（或最小）的一個元素，順序放在已排好序的數列的最後，直到所有待排序的數據元素排完

int[] number={13,15,24,99,4,1};
int index;
for(int i=1;i<number.length;i++)
{
    index=0;
    for(int j=1;j<=number.length-i;j++)
    {
        if(number[j]>number[index])
        {
            index=j;    //查找最大值
        }
    }
    int temp=number[number.length-i];
    number[number.length-1]=number[index];
    number[index]=temp;
}