Java Arrays類的幾種方法詳解

原文轉載： http://blog.csdn.net/u014082714/article/details/49924419

Arrays的常用方法

代碼：

package myArrays;
import java.util.*;
public class Arrays1 {
     public static void main(String[] args) {

         int[] a=new int[]{3,4,5,6};
         int[] a1=new int[]{3,4,5,6};
System.out.println(Arrays.equals(a, a1));         //判斷a和a1是否相等,輸出true

        int[] b=Arrays.copyOf(a, 6);
System.out.println(Arrays.equals(b, a1));         //輸出false
System.out.println(Arrays.toString(b));            //把數組轉換成字符串輸出

        Arrays.fill(b, 2,5,1);                     //把第二個到第四個元素賦爲1
System.out.println(Arrays.toString(b));

        Arrays.sort(b);                //對b進行排序
System.out.println(Arrays.toString(b));

System.out.println(Arrays.binarySearch(b, 3));                  //使用二分查找法查找3的位置
 }
}

此外，在System類裏也包含了一個static void arraycopy(object src,int srcpos,object dest,int destpos,int length)方法。

src：原數組

srcpos：原數組中的起始位置

dest：目標數組

destpos：目標數據中的起始位置

length：要複製的數組元素數量

java.util 下的 Arrays 類沒有 public 的構造函數，所以註定我們只能拿這個類作爲工具類來使用。
這個類給我們提供了處理原生類型（long、int、short、byte、double、float、char、boolean）的數組的功能，
包括排序，填充，比較等功能，查看源碼還能看到java使用的排序算法（快速排序算法）。

下面具體說一下Arrays類的幾個用法：
1. 排序
// 重載 sort 方法 傳入各種類型的數值數組

public static void sort(long[] a) {
 sort1(a, 0, a.length);
}
public static void sort(long[] a, int fromIndex, int toIndex) {
 rangeCheck(a.length, fromIndex, toIndex);
 sort1(a, fromIndex, toIndex - fromIndex);
}

這裏以對 long 型數組進行排序爲例子，在排序的時候都是先進行了數組下標越界檢查，這也就是我們在寫程序的時候經常會遇到的錯誤了。這個rangeCheck方法也可以拿來咱們自己用。
排序方法中調用的 sort1 方法就是具體的快速排序算法的實現了。除了對 long 型數組進行排序的功能外，
java 提供了 8中原生類型的重載的排序方法。這個設計的思想大家也可以借鑑一下。

2. 填充
填充方法可以把數組中的從起始下標到結束下標中間的數值都填充成你期望的值。看下面的源代碼（以填充 int 型數組爲例）

public static void fill(int[] a, int val) {
 fill(a, 0, a.length, val);
}
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
 rangeCheck(a.length, fromIndex, toIndex);
 for (int i = fromIndex; i < toIndex; i++)
  a[i] = val;
}

同樣的數組下標越界檢查，填充代碼。

3. 比較
以比較兩個double型數組爲例子，下面是源碼

public static boolean equals(double[] a, double[] a2) {
 if (a == a2)
  return true;

 if (a == null || a2 == null)
  return false;
 int length = a.length;
 if (a2.length != length)
  return false;
 for (int i = 0; i < length; i++)
  if (Double.doubleToLongBits(a[i]) != Double.doubleToLongBits(a2[i]))
   return false;
 return true;
}

如果兩個double型數組 的物理地址相同，或者都是NULL或者兩個數組的對應的元素都相同，則返回true，兩個數組相等，否則兩個數組不相等。
注意比較兩個數組的對應元素的時候的代碼 Double.doubleToLongBits(a[i]) != Double.doubleToLongBits(a2[i])，爲什麼要用這個比較方法呢，如果大家看了
int 型數組的比較的時候 都是直接比的值，不用做任何轉換。

Two doubles d1 and d2 are considered equal if:
new Double(d1).equals(new Double(d2))
(Unlike the == operator, this method considers NaN equals to itself, and 0.0d unequal to -0.0d.)

如果 new Double(d1).equals(new Double(d2)) 成立，那麼認爲 double型數值 d1 和 d2 是相等，不同於 == 運算符，這個方法認爲 NaN 和它自身是相等的，並且
0.0d 和 -0.0d 是不相等的。

真是夠複雜的 大家可以注意幾點，
== 運算符 和 equals 方法：一個是比的內存地址，一個是通過重構的 Object 的 public boolean equals(Object obj)；方法對比
NaN 的意思是 not a number，用來定義一個不是數字的結果，這個常量在Double 和 Float 兩個類中都有定義，定義內容如下：
public static final double NaN = 0.0d / 0.0;

4.查找
查找的功能是在指定的數組中根據參數查找，返回找到的位置。以long 型數組爲例
public static int binarySearch(long[] a, long key)
查看源碼可知，java中的查找算法是 折半查找（binary search algorithm）這也是查找算法中最有效率的一種算法。
值得注意的是 目標數組必須是經過排序的，如果未經過排序的話，會返回意料之外的值。
// binary search algorithm 折半查找法

public static int binarySearch(long[] a, long key) {
 int low = 0;
 int high = a.length - 1;
 while (low <= high) {
  int mid = (low + high) >> 1;
  long midVal = a[mid];
  if (midVal < key) {
   low = mid + 1;
  } else if (midVal > key) {
   high = mid - 1;
  } else {
   return mid; // key found
  }
 }
 return -(low + 1); // key not found.
}

原文轉載：http://blog.csdn.net/u014082714/article/details/49924419