Java学习笔记之十二Java8增强的工具类：Arrays的用法整理总结详解编程语言

本文将整理 java.util.Arrays 工具类比较常用的方法： 
本文介绍的方法基于JDK 1.7 之上。 
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);

   
2. binarySearch方法 

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

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

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

public static int binarySearch(int[] a, int fromIndex, int toIndex, 
                                   int key) { 
        rangeCheck(a.length, fromIndex, toIndex); 
        return binarySearch0(a, fromIndex, toIndex, key); 
    }

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

3. copyOf及copyOfRange方法 

如： 

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

4. sort方法 

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

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

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

5. toString方法 
Arrays的toString方法可以方便我们打印出数组内容。 
如： 

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));

那么得到的结果类似于 
     [[[email protected], [[email protected], [[email protected]]} 
这个时候得用 deepToString 方法才能得到正确的结果[[80, 81, 82], [84, 85, 86], [87, 88, 89]] 

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

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

String[] names1 = { "Eric", "John", "Alan", "Liz" }; 
 
String[] names2 = { "Eric", "John", "Alan", "Liz" }; 
 
System.out.println(Arrays.equals(names1, names2));

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方法 

int[] array1 = new int[8]; 
Arrays.fill(array1, 1); 
//[1, 1, 1, 1, 1, 1, 1, 1] 
System.out.println(Arrays.toString(array1));

以下将举例介绍几种常用的方法：

1.java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

2. 给数组赋值：通过fill方法。

3. 对数组排序：通过sort方法,按升序。

4.比较数组：通过equals方法比较数组中元素值是否相等。

5. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

 1 import java.util.Arrays; 
 2  
 3 public class TestArrays { 
 4  
 5 public static void output(int[] array) { 
 6  
 7 if (array!=null) { 
 8  
 9 for (int i = 0; i < array.length; i++) { 
10  
11 System.out.print(array[i]+" "); 
12  
13 } 
14  
15 } 
16  
17 System.out.println(); 
18  
19 } 
20  
21 public static void main(String[] args) { 
22  
23 int[] array = new int[5]; 
24  
25 //填充数组 
26  
27 Arrays.fill(array, 5); 
28  
29 System.out.println("填充数组：Arrays.fill(array, 5)："); 
30  
31 TestArrays.output(array); 
32  
33   
34  
35 //将数组的第2和第3个元素赋值为8 
36  
37 Arrays.fill(array, 2, 4, 8); 
38  
39 System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)："); 
40  
41 TestArrays.output(array); 
42  
43   
44  
45 int[] array1 = {7,8,3,2,12,6,3,5,4}; 
46  
47 //对数组的第2个到第6个进行排序进行排序 
48  
49 Arrays.sort(array1,2,7); 
50  
51 System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)："); 
52  
53 TestArrays.output(array1); 
54  
55   
56  
57 //对整个数组进行排序 
58  
59 Arrays.sort(array1); 
60  
61 System.out.println("对整个数组进行排序：Arrays.sort(array1)："); 
62  
63 TestArrays.output(array1); 
64  
65   
66  
67 //比较数组元素是否相等 
68  
69 System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"/n"+Arrays.equals(array, array1)); 
70  
71 int[] array2 = array1.clone(); 
72  
73 System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"/n"+Arrays.equals(array1, array2)); 
74  
75   
76  
77 //使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确） 
78  
79 Arrays.sort(array1); 
80  
81 System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"/n"+Arrays.binarySearch(array1, 3)); 
82  
83 //如果不存在就返回负数 
84  
85 System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："+"/n"+Arrays.binarySearch(array1, 9)); 
86  
87 } 
88  
89 }

输出结果：

 填充数组：Arrays.fill(array, 5)：
 
5 5 5 5 5
 
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
 
5 5 8 8 5
 
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
 
7 8 2 3 3 6 12 5 4
 
对整个数组进行排序：Arrays.sort(array1)：
 
2 3 3 4 5 6 7 8 12
 
比较数组元素是否相等:Arrays.equals(array, array1):
 
false
 
克隆后数组元素是否相等:Arrays.equals(array1, array2):
 
true
 
元素3在array1中的位置：Arrays.binarySearch(array1, 3)：
 
1
 
元素9在array1中的位置：Arrays.binarySearch(array1, 9)：
 
-9