Java——陣列的定義和使用

Java中陣列的定義和使用

1.陣列的基本用法

1.1什么是陣列

陣列本質上就是讓我們能“批量”創建相同型別的變數，

例如：

如果需要表示兩個資料，那么直接創建兩個變數即可int a; int b;

如果需要表示五個資料，那么可以創建五個變數int a1; int a2; int a3; int a4; int a5;

但是如果需要表示一萬個資料，那么就不能創建一萬個變數了，這時候就需要使用陣列，幫我們批量創建變數，

注意事項：在Java中，陣列中包含的變數必須是相同型別，

1.2創建陣列

基本語法

//動態初始化
資料型別[] 陣列名稱 = new 資料型別 [] {初始化資料};

//靜態初始化
資料型別[] 陣列名稱 = {初始化資料};

代碼示例

int[] arr = new int[]{1, 2, 3};

int[] arr = {1, 2, 3};

注意事項：靜態初始化的時候，陣列元素個數和初始化資料的個數是一致的，

1.3陣列的使用

代碼示例：獲取長度&訪問元素

int[] arr = {1, 2, 3};

//獲取陣列長度
System.out.println("length: "+array.length);    //  執行結果：3

//訪問陣列中的元素
System.out.println(array[1]);    // 執行結果：2
System.out.println(array[0]);    // 執行結果：1
arr[2] = 100;
System.out.println(array[2]);    // 執行結果：100

注意事項

1. 使用arr.length能夠獲取到陣列的長度，.這個操作為成員訪問運算子，
2. 使用[ ]按小標取陣列元素，需要注意，下標從0開始計數，
3. 使用[ ]操作既能讀取資料，也能修改資料，
4. 下標訪問操作不能超出有效范圍[0,length-1]，如果超出有效范圍，會出現下標越界例外，

代碼示例:下標越界

int[] arr={1,2,3};
System.out.println(arr[100]);

//執行結果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
	at TestDemo.main(TestDemo.java:14)

拋出了java.lang.ArrayIndexOutOfBoundsException例外，使用陣列一定要下標謹防越界，

代碼示例:遍歷陣列

所謂"遍歷"是將陣列中的所有元素都訪問一遍，不重不漏，通常需要搭配循環陳述句，

int[] array={1,2,3};
for (int i = 0; i < array.length; i++) {
     System.out.println(array[i]);
}

//執行結果
1
2
3

代碼示例:使用for-each遍歷陣列

int[] arr = {1,2,3};
for (int x : array){
    System.out.println(x);
}

//執行結果
1
2
3

for-each是for回圈的另外一種使用方式，能夠更方便的完成對陣列的遍歷，可以避免回圈條件和更新陳述句寫錯，

2.陣列作為方法的引數

2.1基本用法

代碼示例:列印陣列內容

public static void printfArray(int[] a){
    for(int x : a){
        System.out.println(x);
    }
}

public static void main(String[] args){
    int[] arr={1,2,3};
	printArray(arr);
}

//執行結果
1
2
3

在這個代碼中

int[] a是函式的形參，int[] arr是函式實參，

如果需要獲取到陣列長度，同樣可以使用a.length，

2.2理解參考型別（重點/難點）

我們嘗試以下代碼

代碼示例 引數傳陣列型別

public static void func1(int[] array){
    array = new int[]{11,2,13,4,51,61};
}
public static void func2(int[] array){
    array[0]=899;
}

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    System.out.println(Arrays.toString(array));
    func1(array);
    func2(array);
    System.out.println(Arrays.toString(array));
}

//執行結果
func1:
1 2 3 4 5 6
[1,2,3,4,5,6]
func2:
1 2 3 4 5 6
[899,2,3,4,5,6]

我們發現，修改形參的值，不影響實參的的值，

我們發現，在函式內部修改陣列內容，函式外部也發生改變，此時陣列名arr是一個"參考"，當傳參的時候，是按照參考傳參，

2.3認識 null

null在Java中表示"空參考"，也就是一個無效的參考，

int[] arr = null;
System.out.println(arr[0]);

//執行結果
Exception in thread "main" java.lang.NullPointerException
	at TestDemo.main(TestDemo.java:13)

null的作用類似于C語言中的NULL(空指標)，都是表示一個無效的記憶體位置，因此不能對這個記憶體進行任何讀寫操作，一旦嘗試讀寫，就會拋出NullPointerException，

注意:Java中并沒有約定null和0號地址的記憶體有任何關聯，

3.陣列作為方法的回傳值

代碼示例:寫一個方法，將陣列中的每個元素都*2

public static void func(int[] array){
        for (int i = 0; i < array.length; i++) {
            array[i]=2*array[i];
        }
    }//    在原來的陣列上擴大二倍

    public static int[] transform(int[] array){
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i]=2*array[i];
        }
        return ret;
    }//    在新的陣列上擴大二倍

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] ret=transform(array);
        System.out.println(Arrays.toString(ret));
        //func(array);
        //System.out.println(Arrays.toString(array));
    }

這樣的話就不會破壞原有陣列了，

另外由于陣列是參考型別，回傳的時候只是將這個陣列的首地址回傳給函式呼叫者，沒有拷貝陣列內容，從而比較高效，

4.陣列練習

4.1陣列轉字串

代碼示例

import java.util.Arrays;

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

String newArr = Arrays.toString(arr);
System.out.println(newArr);

//執行結果
[1, 2, 3, 4, 5, 6]

使用這個方法后續列印陣列就更方便一些，

Java中提供了java.util.Arrays;包，其中包含了一些操作陣列的常用方法，

我們實作一個自己版本的陣列轉字串

public static String myToString(int[] array){
    if(array==null) return "null";
    String str="[";
    for (int i = 0; i < array.length ; i++) {
        str=str+array[i];
        //除了最后一個元素之外，其他元素后面都要加上","
        if(i!= array.length-1){
            str=str+",";
        }
    }
    str=str+"]";
    return str;
}//[1,2,3,4,5]

public static void main(String[] args) {
    int[] array={1,2,3,4,5};
    System.out.println(myToString(array));
}

4.2陣列拷貝

代碼示例1

public static int[] copyArray(int[] array){
    int[] copy=new int[array.length];
    for (int i = 0; i < array.length; i++) {
        copy[i]=array[i];
    }
    return copy;
}

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] ret=copyArray(array);
    System.out.println(Arrays.toString(ret));
}

代碼示例2

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] ret=Arrays.copyOf(array,array.length*2);
    System.out.println(Arrays.toString(ret));
}

代碼示例3

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] ret=Arrays.copyOfRange(array,1,3);//[1,3)
    System.out.println(Arrays.toString(ret));
}

代碼示例4

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] copy=new int[array.length];
    System.arraycopy(array,0,copy,0,array.length);
    System.out.println(Arrays.toString(copy));
}//C++/C 已經實作了，特點：快

代碼示例5

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] copy=array.clone();
    System.out.println(Arrays.toString(copy));
}//產生一個副本

4.3找陣列中的最大元素

給定一個整型陣列，找到其中的最大元素（找最小元素同理）

代碼示例

public static int maxNum(int[] array){
    if(array==null) return -1;// 業務上的處理
    if(array.length==0) return -1;
    int max=array[0];
    for (int i = 0; i < array.length; i++) {
        if(max<array[i]){
            max=array[i];
        }
    }
    return max;
}
    
public static void main(String[] args) {
    int[] array={12,8,1,2,10};
    maxNum(array);
    System.out.println(maxNum(array));
}

//執行結果
12

4.4求陣列中元素的平均值

給定一個整型陣列，求平均值

代碼示例

public static double avg(int[] arr){
    int sum=0;
    for (int x : arr) {
        sum += x;
    }
    return (double)sum/(double)arr.length;
}

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6};
    System.out.println(avg(arr));
}

//執行結果
3.5

注意事項:結果要用double來表示，

4.5查找陣列中指定元素(順序查找)

給定一個陣列，再給定一個元素，找出該元素在陣列中的位置，

代碼示例

public static int findNum(int[] array,int key){
    for (int i = 0; i < array.length; i++) {
        if(array[i]==key){
            return i;
        }
    }
    return -1;// 因為陣列的下標 不可能存在負數
}

public static void main(String[] args) {
    int[] array={1,9,4,2,15,17};
    System.out.println(findNum(array,2));
}

//執行結果
3

4.6查找陣列中指定元素(二分查找)

針對有序陣列，可以使用更高效的二分查找，

以升序陣列為例，二分查找的思路是先取中間位置的元素，看要找的值比中間元素大還是小，如果小，就去左邊找；否則就去右邊找，

代碼示例

public static int binarySearch(int[] array,int key){
    int left=0;
    int right=array.length-1;
    while(left<=right){
        int mid=(left+right)/2;
        if(array[mid]>key){
            right=mid-1;
        }else if(array[mid]<key){
            left=mid+1;
        }else{
            return mid;
        }
    }
    return -1;
}

public static void main(String[] args) {
    int[] array={1,2,3,4,15,17};
    System.out.println(binarySearch(array,2));
}

//執行結果
1

4.7檢查陣列的有序性

給定一個整型陣列，判斷是否該陣列是有序的(升序)

public static boolean isUp(int[] array){
    for (int i = 0; i < array.length-1; i++) {// i要小心越界訪問
        if(array[i]>array[i+1]){
            return false;
        }
    }
    return true;
}
    
public static void main(String[] args) {
    int[] array={11,12,13,14,15};
    boolean flg=isUp(array);
    System.out.println(flg);
}

//執行結果
true

4.8陣列排序(冒泡排序)

給定一個陣列，讓陣列升序(降序)排序，

演算法思路

每次嘗試找到當前待排序區間中最小(或最大)的元素，放到陣列最前面(或最后面)，

代碼示例

public static void bubbleSort(int[] array){
    //  i表示趟數
    for (int i = 0; i < array.length-1; i++) {
        boolean flg=false;    //  每趟比較完恢復flg
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j]>array[j+1]){
                int tmp=array[j];
                array[j]=array[j+1];
                array[j+1]=tmp
                flg=true;
            }
        }
        if(flg==false){
            break;
        }
    }
}    

public static void main(String[] args) {
    int[] array={11,2,3,14,15};
    bubbleSort(array);
    System.out.println(Arrays.toString(array));
}

//執行結果
[2, 3, 11, 14, 15]

冒泡排序性能較低，Java中內置了更高效的排序演算法，

public static void main(String[] args) {
    int[] array={11,2,3,14,15};
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));
}

4.9陣列逆序

給定一個陣列，將里面的元素逆序排列，

思路

設定兩個下標，分別指向第一個元素和最后一個元素，交換兩個元素的位置，

然后讓前一個下標自增，后一個下標自減，回圈繼續即可，

代碼示例

public static void reverse(int[] array){
    int i=0;
    int j= array.length-1;
    while(i<j){
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
        i++;
        j--;
    }
}

public static void main(String[] args) {
    int[] array={11,2,3,14,15};
    reverse(array);
    System.out.println(Arrays.toString(array));
}

//執行結果
[15,14,3,2,11]

4.10陣列數字排列

給定一個整型陣列，將所有的偶數放在前半部分，將所有的奇數放在陣列后半部分，

例如

{1，2，3，4}

調整后得到

{4，2，3，1}

基本思路

設定兩個下標分別指向第一個元素和最后一個元素，

用前一個下標從左往右找到第一個奇數，用后一個下標從右往左找到第一個偶數，然后交換兩個位置的元素，依次回圈即可，

代碼示例

public static void func(int[] array){
    int i=0;
    int j= array.length-1;
    while(i<j) {
        while(i<j&&array[i] % 2 == 0){
            i++;
        }//i遇到了奇數
        while(i<j&&array[j] % 2 != 0){
            j--;
        }//j遇到了偶數
        if (array[i] % 2 != 0 && array[j] % 2 == 0) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }
}

public static void main(String[] args) {
    int[] array={1,2,3,4,5};
    func(array);
    System.out.println(Arrays.toString(array));
}

5.二維陣列

二維陣列本質上也就是一維陣列，只不過每個元素又是一個一維陣列，

基本語法

資料型別[][] 陣列名稱 = new 資料型別 [行數][列數] {初始化資料}

代碼示例

public static void main(String[] args) {
    int[][] array={{1,2,3},{4,5,6}};
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.print(array[i][j]+" ");
        }
        System.out.println();
    }    //  列印方法1
    System.out.println("==============");
    for(int[] ret:array){
        for(int x:ret){
            System.out.print(x+" ");
        }
        System.out.println();
    }    //  列印方法2
    System.out.println("==============");
    System.out.println(Arrays.deepToString(array));    //  列印方法3
}

//執行結果
1 2 3 
4 5 6 
==============
1 2 3 
4 5 6 
==============
[[1, 2, 3], [4, 5, 6]]

不規則二維陣列

代碼示例

public static void main(String[] args) {
    int[][] array2=new int[2][];
    array2[0]=new int[3];
    array2[1]=new int[2];
    for (int i = 0; i < array2.length; i++) {
        for (int j = 0; j < array2[i].length; j++) {
            System.out.print(array2[i][j]+" ");
        }
        System.out.println();
    }
}

//執行結果
0 0 0 
0 0