1
public static void sort(Object[] a)
2
public static void sort(Object[] a, int fromIndex, int toIndex)
3
public static <T> void sort(T[] a, Comparator<? super T> c)
4
public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
5

6
public static int binarySearch(Object[] a, Object key)
7
public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
8
public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
9
public static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
10

11
public static boolean equals(Object[] a, Object[] a2)
12

13
public static void fill(Object[] a, Object val)
14
public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
15
public static <T> T[] copyOf(T[] original, int newLength)
16
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
17

18
public static <T> T[] copyOfRange(T[] original, int from, int to)
19
public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
20

21
public static <T> List<T> asList(T... a)
22

23
public static int hashCode(Object a[])
24

25
public static int deepHashCode(Object a[])
26

27
public static boolean deepEquals(Object[] a1, Object[] a2)
28

29
public static String toString(Object[] a)
30

31
public static String deepToString(Object[] a)

1
//在指定下标内，对数组进制默认升序排序，这将改变原数组，下标含头不含尾
2
Integer[] sortArray1 = Arrays.copyOf(arrayTest, arrayTest.length);
3
Arrays.sort(sortArray1,0,5);
4
arrayPrint(sortArray1);
5
//数组内全部排序
6
Arrays.sort(sortArray1);
7
arrayPrint(sortArray1);
8
Integer[] sortArray2 = Arrays.copyOf(arrayTest, arrayTest.length);
9
//使用比较器降序排序，在指定下标范围内
10
Arrays.sort(sortArray2,0,5,(x,y)->y.compareTo(x));
11
arrayPrint(sortArray2);
12
//使用比较器全部降序排序
13
//第二个参数为lambda表达式
14
Arrays.sort(sortArray2,(x,y)->y.compareTo(x));
15
arrayPrint(sortArray2);

1
//以下是多线程算法，处理数组(大多以parallel做为开头的方法，可以充分利用现代CPU多核，处理大规模庞大的数组很有效)
2

3

4
　　　　　//9.
5
        Integer[] arrayPP1 = Arrays.copyOf(arrayTest, arrayTest.length);
6
        arrayPrint(arrayPP1);
7
        //二元迭代，对原数组内容进行二元操作
8
        Arrays.parallelPrefix(arrayPP1,(x,y)->x*y);
9
        arrayPrint(arrayPP1);
10
        Integer[] arrayPP2 = Arrays.copyOf(arrayTest, arrayTest.length);
11
        //在指定下标范围内，对原数组内容进行二元操作，下标含头不含尾
12
        Arrays.parallelPrefix(arrayPP2,0,5,(x,y)->x*y);
13
        arrayPrint(arrayPP2);
14

15
　　　　 //10.
16
        Integer[] arrayPSA = Arrays.copyOf(arrayTest, arrayTest.length);
17
        //对原有数组对每个元素重新赋值，下面例子是 下标*5 然后赋到数组对应元素
18
        Arrays.parallelSetAll(arrayPSA,a->a*5);
19
        arrayPrint(arrayPSA);
20

21
　　　　 //11.
22
        Integer[] arrayPS1 = Arrays.copyOf(arrayTest, arrayTest.length);
23
        //对数组进行升序排序
24
        Arrays.parallelSort(arrayPS1);
25
        arrayPrint(arrayPS1);
26
        //对指定下标范围内的元素进行指定排序方法的排序，含头不含尾
27
        Arrays.parallelSort(arrayPS1,0,5,(x,y)->y.compareTo(x));
28
        arrayPrint(arrayPS1);
29

30
　　　　 //12.
31
        //返回一个Spliterator进行其它操作
32
        Spliterator<Integer> spliterator = Arrays.spliterator(arrayPS1);
33
        //将原有Spliterator切出一部分为新的Spliterator，不可切时返回null
34
        Spliterator<Integer> integerSpliterator = spliterator.trySplit();
35
        // estimateSize 还有几个元素要处理
36
        while(spliterator.estimateSize()>0){
37
            //对每个元素进行处理
38
            spliterator.tryAdvance(x-> System.out.print(x*2+" "));
39
        }
40

41
        System.out.println();
42

43
        //对Spliterator遍历操作
44
        integerSpliterator.forEachRemaining(a-> System.out.print(a+" "));
45
        System.out.println();
46

47
        //还有几个要遍历
48
        System.out.println(integerSpliterator.getExactSizeIfKnown());
49

50
        //表示该Spliterator有那些特性，用于优化
51
        System.out.println(spliterator.characteristics());
52

53

54
    }
55

56
    //懒人癌晚期....
57
    public static void arrayPrint(Object[] oArray){
58
        System.out.println(Arrays.toString(oArray));
59
    }