Arrays用法整理(操作数组的工具类)

本文将整理  java.util.Arrays  工具类比较常用的方法： 最常用的方法就是asList,sort,toString,equals,copyOf了

本文介绍的方法基于JDK 1.7 之上。 

Arrays.asList(arr).contains(targetValue); 检查数组里面是否包含某个元素

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
for (int i = 0; i < list.size(); i++) {
    list.remove(i);
}
System.out.println(list);

输出结果为：[b, d]     因为当数组删除一个元素后，它的长会缩小，index相当于向后移动一位，这是个严重的问题。当你想通过index来删除多个元素时候，这种方法是不可取的。改成迭代器删除即可

1.  asList方法  

   @SafeVarargs
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

   使用该方法可以返回一个固定大小的List,不能操作元素(添加 删除) ，如： 

List<String> stringList = Arrays.asList("Welcome", "To", "Java", "World!");
List<Integer> intList = Arrays.asList(1, 2, 3, 4);

可改为  ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

2. binarySearch方法  

binarySearch方法支持在整个数组中查找，如： 

1. int index = Arrays.binarySearch(new int[] { 1, 2, 3, 4, 5, 6, 7 }, 6);  

用二进制搜索算法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（sort 方法）。如果没有对数组进行排序，则结果是不明确的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个

方法1 : binarySearch(object[ ], object key);
如果key在数组中，则返回搜索值的索引；否则返回-1或者"-"(插入点)。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素索引。

int a[] = new int[] {1, 3, 4, 6, 8, 9};
int x1 = Arrays.binarySearch(a, 5);
int x2 = Arrays.binarySearch(a, 4);
int x3 = Arrays.binarySearch(a, 0);
int x4 = Arrays.binarySearch(a, 10);
System.out.println("x1:" + x1 + ", x2:" + x2);//x1:-4, x2:2
System.out.println("x3:" + x3 + ", x4:" + x4);//x3:-1, x4:-7
1.不存在时由1开始计数；
2.存在时由0开始计数。

以及在某个区间范围内查找， 如： 

方法2:  binarySearch(object[ ], int fromIndex, int endIndex, object key);

如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或者"-"(插入点)。
eg：
1.该搜索键在范围内，但不在数组中，由1开始计数；
2.该搜索键在范围内，且在数组中，由0开始计数；
3.该搜索键不在范围内，且小于范围内元素，由1开始计数；
4.该搜索键不在范围内，且大于范围内元素，返回-(endIndex + 1);（特列）

int a[] = new int[] {1, 3, 4, 6, 8, 9};
int x1 = Arrays.binarySearch(a, 1, 4, 5);
int x2 = Arrays.binarySearch(a, 1, 4, 4);
int x3 = Arrays.binarySearch(a, 1, 4, 2);
int x4 = Arrays.binarySearch(a, 1, 3, 10);
System.out.println("x1:" + x1 + ", x2:" + x2);//x1:-4, x2:2
System.out.println("x3:" + x3 + ", x4:" + x4);//x3:-2, x4:-4

3. copyOf及copyOfRange方法 
 

String[] names2 = { "Eric", "John", "Alan", "Liz" };
String[] copy = Arrays.copyOf( names2, 3 );// [Eric, John, Alan]
String[] rangeCopy = Arrays.copyOfRange( names2, 2, names2.length );// [Alan,  Liz]

4. sort方法 

Arrays.sort(names, 0, 2);  //只排序前两个   [John, Liz, Eric, Alan]  
Arrays.sort(names);//全部排序    [Alan, Eric, John, Liz]  

另外，Arrays的sort方法也可以结合比较器，完成更加复杂的排序。

1. public static <T> void sort(T[] a, Comparator<? super T> c) {  
2.     if (LegacyMergeSort.userRequested)  
3.         legacyMergeSort(a, c);  
4.     else  
5.         TimSort.sort(a, c);  
6. } 

5. toString方法 

static String toString(Object[] a)   方法可以方便我们打印出数组内容

String[] names = { "Liz", "John", "Eric", "Alan" };
Arrays.sort(names);
System.out.println(Arrays.toString(names)); //控制台将打印出 [Alan, Eric, John, Liz] 

6. deepToString方法 
如果需要打印二维数组的内容： 
int[][] stuGrades = { { 80, 81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } }; 
如果直接用

System.out.println(Arrays.toString(stuGrades));

那么得到的结果类似于 
     [[I@35ce36, [I@757aef, [I@d9f9c3]} 
这个时候得用 deepToString 方法才能得到正确的结果[[80, 81, 82], [84, 85, 86], [87, 88, 89]] 

System.out.println(Arrays.deepToString(stuGrades));

7. equals方法  
使用Arrays.equals来比较1维数组是否相等。 

String[] a= new String[]{"1","2"};
String[] b= new String[]{"1","2"};
System.out.println( java.util.Arrays.equals( a, b ) );

8. deepEquals方法  
Arrays.deepEquals能够去判断更加复杂的数组是否相等。 

int[][] stuGrades1 = { { 80, 81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };
int[][] stuGrades2 = { { 80, 81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };
System.out.println(Arrays.deepEquals(stuGrades1, stuGrades2));

9. fill方法 

static void fill(int[] a, int val)   //将指定的 int 值分配给指定 int 型数组的每个元素。
int[] array1 = new int[8];
 Arrays.fill(array1, 8);
System.out.print( Arrays.toString(array1) ); //输出[8, 8, 8, 8, 8, 8, 8, 8]