Java中數組操作 java.util.Arrays 類常用方法的使用

任何一門編程語言，數組都是最重要和常用的數據結構之一，但不同的語言對數組的構造與處理是不盡相同的。

Java中提供了java.util.Arrays 類能方便地操作數組，並且它提供的所有方法都是靜態的。下面介紹一下Arrays類最常用的幾個方法。

1.  數組排序

Arrays工具類提供了一個sort方法，只需要一行代碼即可完成排序功能。

2.  數組轉換為字符串

Arrays提供了一個toString方法，可以直接把一個數組轉換為字符串，這樣可以方便觀察數組里的元素。

//來源：公眾號【時光與字節】
//數組排序與轉換為字符串
package BaseCode;
import java.util.Arrays;
public class j4_1028_11 {
    public static void main(String[] args) {
        int[] ff= {11,3,25,71,9};
        System.out.print("數組ff未排序： ");
        for(int n:ff)
            System.out.print(n+"  ");
        Arrays.sort(ff); // 對數組進行排序
        System.out.printf("\n數組ff排序后： ");
        for(int n:ff)
            System.out.print(n+"  ");
        //將數組轉換為字符串
        System.out.printf("\n數組ff轉為字符串： "+Arrays.toString(ff));
    } 
}

運行結果

數組ff未排序：11  3  25  71  9  
數組ff排序后：3  9  11  25  71  
數組ff轉為字符串：[3, 9, 11, 25, 71]

3.  數組元素的填充與替換

Arrays提供了fill方法對數組（或數組指定位置）填充或替換為指定的值。

4.  判斷數組是否相同

Arrays.equals可以比較兩個數組中的元素是否一樣。

//來源：【時光與字節】
//fill方法和equals方法
package BaseCode;
import java.util.Arrays;
public class j4_1028_12 {
    public static void main(String[] args) {
        int[] ff= new int[5];
        Arrays.fill(ff, 5);
        System.out.print("數組全部元素填充為5： ");
        for(int n:ff)
            System.out.print(n+"  ");
        //將數組從第1個元素至第3個元素填充為7
        //含第1個元素，不含第3個元素
        Arrays.fill(ff,1,3,7);
        System.out.print("\n數組指定位置填充為7： ");
        for(int n:ff)
            System.out.print(n+"  ");
        int[] nn= new int[5];
        Arrays.fill(nn, 5);
        System.out.printf("\nff與nn相同："+Arrays.equals(ff, nn));
    }
}

運行結果

數組全部元素填充為5：5  5  5  5  5  
數組指定位置填充為7：5  7  7  5  5  
ff與nn相同：false

5.  復制數組

Arrays類的copyOf()方法和copyRange()方法可以實現對數組的復制。

copyOf(arr, int newlength)

參數newlength為新數組的長度，即從數組arr的第0個位置開始，直到newlength結束，如果newlength大於arr的長度，后面按默認值填充。

copyOfRange(arr, int formIndex, int toIndex)

參數formIndex為從數組arr中取元素的開始位置，toIndex為結束位置，但不包括該位置的元素，如toIndex超出arr的長度，后面按默認值填充。

//來源：公眾號【時光與字節】
//數組的復制，copyOf與copyOfRange的使用
package BaseCode;
import java.util.Arrays;
public class j4_1028_10 {
    public static void main(String[] args) {
        int[] ff= {1,3,5,7,9};
        //Arrays.copyOf復制數組至指定長度，從0開始
        int[] newff1=Arrays.copyOf(ff, 3);
        int[] newff2=Arrays.copyOf(ff, 6);
        System.out.print("copyOf的使用：\n數組newff1： ");
        for(int n:newff1)
            System.out.print(n+"  ");
        System.out.printf("\n數組newff2： ");
        for(int n:newff2)
            System.out.print(n+"  ");
        //Arrays.copyOfRange第二個參數為開始位置
        //第三個參數為結束位置
        int[] newff3=Arrays.copyOfRange(ff, 1, 4);
        int[] newff4=Arrays.copyOfRange(ff, 1, 7);
        System.out.printf("\ncopyOfRange的使用：\n數組newff3： ");
        for(int n:newff3)
            System.out.print(n+"  ");
        System.out.printf("\n數組newff4： ");
        for(int n:newff4)
            System.out.print(n+"  ");
    }
}

運行結果

copyOf的使用：
數組newff1：1  3  5  
數組newff2：1  3  5  7  9  0  
copyOfRange的使用：
數組newff3：3  5  7  
數組newff4：3  5  7  9  0  0

6.  元素查詢

Arrays類的binarySearch 方法可以查詢元素出現的位置，返回元素的索引。但是注意，使用binarySearch進行查找之前，必須使用sort進行排序。並且如果數組中有多個相同的元素，查找結果是不確定的。

binarySearch(arr, object key)

如果key在數組中，則返回搜索值的索引；否則返回-1或者負的插入點值。

所謂插入點值就是第一個比key大的元素在數組中的索引，而且這個索引是從1開始的。

binarySearch(arr, int fromIndex, int endIndex, object key);

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

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

其搜索結果可分為以下四種情況：

1. 該搜索鍵不在范圍內，且大於范圍（數組）內元素，返回 –(toIndex + 1)；

2. 該搜索鍵不在范圍內，且小於范圍（數組）內元素，返回–(fromIndex + 1)；

3. 該搜索鍵在范圍內，但不是數組元素，由1開始計數，返回負的插入點索引值；

4. 該搜索鍵在范圍內，且是數組元素，由0開始計數，返回搜索值的索引值；

可參看下面的示例代碼及注釋

//來源：公眾號【時光與字節】
//查找數組元素：binarySearch 方法的使用
package BaseCode;
import java.util.Arrays;
public class j4_1028_13 {
    public static void main(String[] args) {
        int[] fn= {1,3,5,7,9};
        Arrays.sort(fn);//查找前先排序
        int cx1=Arrays.binarySearch(fn,5);//返回2 ,找到了關鍵字，索引從0開始
        //未找到6，返回的是負的插入點值，
        //6在數組中的插入點是元素7的索引，
        //元素7的索引從1開始算就是4，所有返回-4
        int cx2=Arrays.binarySearch(fn,6);//未找到，返回-4，插入點7的索引是4
        int cx3=Arrays.binarySearch(fn,4);//未找到，返回-3，插入點5的索引是3
        System.out.println("不指定查找范圍示例：");
        System.out.println("數組fn的內容："+Arrays.toString(fn));
        System.out.printf("[5]找到：cx1=%d%n", cx1);
        System.out.printf("[6][4]未找到：cx2=%d, cx3=%d%n", cx2,cx3);

        //在數組的指定位置查找元素,參數范圍（1,3）包含的數組元素為[3,5]
        //該搜索鍵不在范圍內，且大於范圍（數組）內元素，返回 –(toIndex + 1)。
        int cx4=Arrays.binarySearch(fn,1,3,10);
        //該搜索鍵不在范圍內，且小於范圍（數組）內元素，返回–(fromIndex + 1)；
        int cx5=Arrays.binarySearch(fn,1,3,-3);
        //該搜索鍵在范圍內，但不是數組元素，由1開始計數，返回負的插入點索引值
        int cx6=Arrays.binarySearch(fn,1,3,4);
        //該搜索鍵在范圍內，且是數組元素，由0開始計數，返回搜索值的索引值
        int cx7=Arrays.binarySearch(fn,1,3,5);
        System.out.println("-------------------------");
        System.out.println("用參數指定查找范圍示例：");
        System.out.println("第一種情況：cx4= "+cx4);
        System.out.println("第二種情況：cx5= "+cx5);
        System.out.println("第三種情況：cx6= "+cx6);
        System.out.println("第四種情況：cx7= "+cx7);
    }
}

運行結果

不指定查找范圍示例：
數組fn的內容：[1, 3, 5, 7, 9]
[5]找到：cx1=2
[6][4]未找到：cx2=-4, cx3=-3
-------------------------
用參數指定查找范圍示例：
第一種情況：cx4= -4
第二種情況：cx5= -2
第三種情況：cx6= -3
第四種情況：cx7= 2