初識Java（Java陣列-陣列的基本操作)

空零之旅發表於2018-04-10
Java陣列

一、陣列的基本操作

    java.util  包的 Arrays 類包含了用來運算元組（如排序和搜尋）的各種方法。

    1.1  遍歷陣列

    遍歷陣列就是獲取陣列中的每個元素。通常遍歷陣列都是使用 for 迴圈來實現。

    遍歷二維陣列需使用雙層 for 迴圈，通過陣列的 length 屬性可獲得陣列的長度。

    實現將二位陣列中的元素呈梯形輸出 ：

public class Trap{
    public static void main(String[] args){
        int b[][] = new int[][]{ {1} , {2,3} , {4,5,6} };        //定義二維陣列
        for(int k = 0 ; k < b.length ; k++ ){
            for(int c = 0 ; c < b[k].length ; c++){              //迴圈遍歷二維陣列中的每個元素
                System.out.print(b[k][c]);                       //將陣列中的元素輸出
            }
        System.out.println();                                    //輸出空格
        }
    }
}

    執行結果為 ：

1
2 3
4 5 6

    使用 foreach 語句遍歷二維陣列 ：

public class Tautog{
    public static void main(String[] args){
        int arr2[][] = { {4,3} , {1,2} };                  //定義二維陣列
        System.out.println("陣列中的元素是:");
        for( int x[] : arr2){                              //外層迴圈變數為一維陣列
            for( int e : x ){                              //迴圈遍歷每一個陣列元素
                if(e == x.length ){                        //判斷變數是否是二維陣列中的最後一個元素
                    System.out.printl(e);                  //輸出二維陣列的最後一個元素
                }else{
                    System.out.print(e + "、");            //如果不是最後一個元素
                }
            }
    }
}

    執行結果為 ：

陣列中的元素是 :
4 、3 、 1 、 2

    1.2  填充替換陣列元素

    陣列中的元素定義完成後，可通過 Arrays 類的靜態方法 fill() 方法來對陣列中的元素進行替換。該方法通過各種過載形式可完成任意型別的陣列元素的替換。以 int 型陣列為例介紹 fill() 方法的使用方法。

    （  1 ）fill(int[] a , int value )

    該方法可將指定的 int 值分配給 int 型陣列的每個元素。

    語法 ：fill ( int[] a , int value )

    a ：要進行元素替換的陣列 。

    value ：要儲存陣列中所有元素的值 。

    建立一維陣列，通過 fill() 方法填充陣列元素。

import java.util.Arrays;
public class Swap{
    public static void main(String[] args){
        int arr[] = new int[5];                    //建立 int 型陣列
        Arrays.fill(arrr , 8);                     //使用同一個值對陣列進行填充
        for(int i = 0 ; i < arr.lrngth ; i++){     //迴圈遍歷陣列中的元素
            System.out.println("第 " + i + "個元素是："+ arr[i]);
        }
    }
}

    執行結果為 ：

第 0 個元素是：8
第 1 個元素是：8
第 2 個元素是：8
第 3 個元素是：8
第 4 個元素是：8

    1.3  對陣列進行排序

    通過 Arrays 類的靜態 sort() 方法可以實現對陣列的排序。 sort() 方法提供了多種過載形式，可對任意型別的陣列進行升序排序。

    語法 ： Arrays.sort(object)

    object ：指進行排序的陣列名稱 。

     eg： 建立一維陣列，將陣列排序後輸出 ：

import java.util.Arrays;
public class Taxis{
    public static void main(String[] args){
        int arr[] = new int[]{23,42,12,8};            //宣告陣列
        Arrays.sort(arr);                             //將陣列進行排序
        for(int i = 0 ; i < arr.length ; i++){        //迴圈遍歷排序後的陣列
            System.out.println(arr[i]);
        }
    }
}
    執行結果為 ：
8
12
23
42

    Java 中的 String 型別陣列的排序演算法是根據字典編排順序排序的，因此數字排在字母前面，大寫字母排在小寫字母前面。

    1.4  複製陣列

    Arrays 類的 copyOf() 方法與 copyOfRange() 方法可以實現對陣列的複製。copyOf() 方法是複製陣列至指定長度，copyOfRange() 方法則將指定陣列的指定長度複製到一個新陣列中。

    （ 1 ）copyOf() 方法

    該方法提供了多種過載形式，用於滿足不同型別陣列的複製。

    語法 ： copyOf( arr , int newlength )

    arr ：要進行復制的陣列 。

    newlength ：int 型常量，指複製後的新陣列的長度。如果新陣列的長度大於陣列 arr 的長度，則用 0 填充（根據複製陣列的型別來決定填充的值，整形陣列用 0 填充，char 型陣列則使用 null 填充）；如果複製後的陣列長度小於陣列 arr 的長度，則會從陣列 arr 的第一個元素開始擷取至滿足新陣列的長度為止。

    eg：實現將陣列複製得到一個長度為 5 的新陣列，並將新陣列輸出。

import java.util.Arrays;
public class Cope{
    public static void main(String[] args){
        int arr[] = new int[]{23,42,12};                        //定義陣列
        int newarr[] = Arrays.copyOf(arr,5);                    //複製陣列 arr
            for(int i = 0 ; i < newarr.length ; i++ ){          //迴圈變數複製後的新陣列
                System.out.println(newarr[i]);                  //輸出新陣列
            }
    }
}

    執行結果為 ：

23
42
12
0
0

    （ 2 ）copyOfRange() 方法

    該方法提供了多種過載形式。

    語法 ： copyOfRange(arr , int fromIndex , int toIndex )

    arr ：要進行復制的陣列物件 。

    fromIndex ：指定開始複製陣列的索引位置。fromIndex 必須在 0 至整個陣列的長度之間。新陣列包括索引是 fromIndex 的元素。

    toIndex ：要複製範圍的最後索引位置。可大於陣列 arr 的長度。新陣列不包括索引是 toIndex 的元素。

    eg ： 建立一維陣列，將陣列中索引位置是 0~3 之間的元素複製到新陣列中，輸出新陣列。

import java.util.Arrays;
public class Repeat{
    public static void main(String[] args){
        int arr[] = new int[]{23,42,12,84,10};            //定義陣列
        int newarr[] = Arrays.copyOfRange(arr , 0 ,3);    //複製陣列
        for(int i = 0 ; i < newarr.length ; i++){         //迴圈遍歷複製後的新陣列
            System.out.println(newarr[i]);
        }
    }
}

    執行結果為 ：

23
42
12

    1.5  陣列查詢

    Arrays 類的 binarySearch() 方法，可使用二分搜尋法來搜尋指定陣列，以獲得指定物件。該方法返回要搜尋元素的索引值。binarySearch() 方法提供了多種過載形式，用於滿足各種型別陣列的查詢需要。

    兩種引數型別 ：

    （ 1 ）binarySearch(Object[] , Object key)

    語法 ：binarySearch(Object[] a , Object key)

    a ：要搜尋的陣列 。

    key ：要搜尋的值 。

    如果 key 包含在陣列中，則返回搜尋值的索引；否則返回 -1 或 “ - ”(插入點)。插入點是搜尋鍵將要插入陣列的那一點，即第一個大於此鍵的元素索引。

    eg ：查詢陣列元素

int arr[] = new int[]{4,25,10};                    //建立並初始化陣列
Arrays.sort(arr);                                  //進行排序
int index = Arrays.binarySearch(arr, 0, 1, 8);

    變數 index 的值是元素 " 8 "在陣列 arr 中索引在 0~1 內的索引位置。由於在指定的範圍內並不存在元素“ 8 ” ， index 的值是“ - ”(插入點)。如果對陣列進行排序，元素“ 8 ”應該在“ 25 ”的前面。因此插入點應是元素“ 25 ”的索引值 2 ，所以 index 的值是 -2 。

    如果陣列中的所有元素都小於指定的鍵，則為 a.length(注意，這保證了當且僅當此鍵被找到時，返回的值將大於等於 0 )。

    必須在進行此呼叫之前對陣列進行排序（通過 sort() 方法）。如果沒有對陣列進行排序，則結果是不確定的。如果陣列包含多個帶有指定值的元素，則無法保證找到的是哪一個。

    eg ：建立一維陣列，實現查詢元素 4 在陣列 ia 中的索引位置。

import java.util.Arrays;
public class Example{
    public static void main(String[] args){
        int ia[] = new int[]{1,8,9,4,5};                    //定義陣列
        Arrays.sort(ia);                                    //進行排序
        int index = Arrays.binarySearch(ia,4);              //查詢陣列 ia 中元素 4 的索引位置
        System.out.println("4 的索引位置是："+index);        //輸出索引值
    }
}
    執行結果為 ：4 的索引位置是 1

    （ 2 ）binarySearch(Object[] , int fromIndex , int  toIndex ,Object key )

    語法 ：binarySearch(Object[] a , int fromIndex ,int toIndex , Object key)

    a ：要進行檢索的陣列 。

    fromIndex ：指定範圍的開始處索引（包含）。

    toIndex ：指定範圍的結束處索引（不包含）。

    key ：要搜尋的元素 。

    在使用該方法之前同樣要對陣列進行排序，來獲得準確的索引值。如果要搜尋的元素 key 在指定的範圍內，則返回搜尋鍵的索引；否則返回 -1 或 “ - ”(插入點)。如果範圍中的所有元素都小於指定的鍵，則為 toIndex （注意，這保證了當且僅當此鍵被找到時，返回的值將大於等於 0 ）。

    如果指定的範圍大於或等於陣列的長度，則會報出 ArrayIndexOutOfBoundsException 異常。

    eg ：建立 String 陣列，實現查詢元素 “ cd ”在指定範圍的陣列 str 中的索引位置。

import java.util.Arrays;
public class Rakel{
    public static void main(String[] args){
        String str[] = new String[]{"ab","cd","ef","yz"};        //定義 String 型陣列
        Arrays.sort(str);                                        //排序
        int index = Arrays.binarySearch(str, 0 ,2 ,"cd");        //在指定範圍內搜尋
        System.out.println("cd 的索引位置是：" + index);
    }
}
    執行結果為 ： cd 的索引位置是： 1


相關文章