你用Arrays能干啥?葵花宝典?

前言

该类包含用于操作数组的各种方法（例如排序和搜索）。 此类还包含一个静态工厂，允许将数组视为列表。 如果指定的数组引用为null，则此类中的方法都抛出NullPointerException ，除非另有说明。 包含在此类的方法中的文件包括的实施方式的简要描述。 这些描述应被视为实施说明 ，而不是规范的一部分 。 只要遵守规范本身，实现者就可以随意替换其他算法。
（例如， sort(Object[])使用的算法不一定是sort(Object[]) ，但它必须是稳定的 。）

---

一、Arrays是什么？

Arrays类位于 java.util 包中，主要包含了操作数组的各种方法，其实我们知道其他的一些集合例如List、Set这些集合类还是提供了很多方法的，但是数组它是不属于集合体系下的，它是通过[]进行标识的，它没有提供给用户可操作的任何方法，只提供了一个length 属性.

二、使用步骤

常用方法

源码说:

asList(T... a) 
binarySearch( Object[] a, Object key)
copyOf(Object[] original, int newLength) 
copyOfRange(Object[] original, int from, int to) 
deepEquals(Object[] a1, Object[] a2)
deepHashCode(Object a[]) 
deepToString(Object[] a) 
deepToString(Object[] a, StringBuilder buf, Set<Object[]> dejaVu) {
equals(Object[] a, Object[] a2)
fill(Object[] a, Object val)
hashCode(char a[])
legacyMergeSort(Object[] a) 
parallelPrefix(Object[] array, Object op)
parallelSetAll(Object[] array, IntToObjectFunction generator) 
parallelSort(Object[] a) 
setAll(Object[] array, IntToObjectFunction generator)
sort(Object[] a)
spliterator(Object[] array) 
spliterator(Object[] array, int startInclusive, int endExclusive)
stream(Object[] array)
stream(Object[] array, int startInclusive, int endExclusive) 
swap(Object[] x, int a, int b)
toString(Object[] a)

代码示例:
asList()方法:将数组或者是可变参数转化为List

public static void asList(){
        String [] arr={"n","a","n"};
        List<String> list = Arrays.asList(arr);
        List<String> list1 = Arrays.asList("b","a","o");
        System.out.println(list);
        System.out.println(list1);
        /**
         * [n, a, n]
         * [b, a, o]
         */
    }

对数组进行升序排序:

public static void sort(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.sort(arr);
        for (int i : arr){
            System.out.print(i+" ");
        }
        //-4 3 4 5 8 9
    }

sort​(int[] a, int fromIndex, int toIndex)按升序对数组的指定范围进行排序。

public static void sort1(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.sort(arr,0,3);
        for (int i : arr){
            System.out.print(i+" ");
            //4 5 9 8 3 -4 
        }
    }

Arrays.sort(nums, new Comparator() ) 使用Comparator 指定排序方向 主要看重写的compared方法规定的方法

public void sort() {
    Integer[] nums = {2, 5, 0, 4, 6, -10};
    Arrays.sort(nums, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    });
    for (int i : nums) {
        System.out.print(i + " ");
    }
}
// 输出结果
-10 0 2 4 5 6 

fill​(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素,将数组内的元素全部替换成val

 public static void fill(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.fill(arr,2);
        for (int i : arr){
            System.out.print(i+" ");
            //2 2 2 2 2 2 
        }
    }

fill​(int[] a, int fromIndex, int toIndex, int val)将指定的int值分配给指定的int数组的指定范围的每个元素。

public static void fill1(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.fill(arr,2,5,200);
        for (int i : arr){
            System.out.print(i+" ");
            //9 5 200 200 200 -4 
        }
    }

toString​(int[] a)返回指定数组内容的字符串表示形式。

 public static void tostring(){
        int [] arr ={9,5,4,8,3,-4};
        //[I@6108b2d7
        System.out.println(arr);
        //[9, 5, 4, 8, 3, -4]
        System.out.println(Arrays.toString(arr));
    }

deepToString(Object[][] arrays)返回多维数组的字符串形式

@Test
public void deepToString() {
    int[][] nums = {{2, 5, 0, 4, 6, -10},{2, 5, 0, 4, 6, -10}};
    System.out.println(nums);
    System.out.println(Arrays.deepToString(nums));
}
// 输出结果
[[I@587c290d
[[2, 5, 0, 4, 6, -10], [2, 5, 0, 4, 6, -10]]

binarySearch(Object[] a, Object key)
采用二分查找方式，查找某个特定的key，如果找到返回下标，找不到则返回-1，需要注意的是二分查找要求输入是有序的

 public static void binarysearch(){
        //无序输出
        int a =Arrays.binarySearch(new int[] {1,2,3,9,5}, 4);

        int b=Arrays.binarySearch(new int[] {1,2,3,4,5}, 4);
        System.out.println(a);//-4
        
        
        System.out.println(b);//3
    }

copyOf​(int[] original, int newLength)使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。

public void copyOfRange() {
    int[] ints = Arrays.copyOfRange(new int[]{9, 8, 7,6,5,4,3,2,1}, 0, 5);
    System.out.println(Arrays.toString(ints));
}
// 输出结果
[9, 8, 7, 6, 5]

parallelPrefix使用并行计算，并对数组做计算的功能，由于是一个函数式接口，可以作lambda表达式

public void parallelPrefix() {
    int[] ints = {1, 2, 3, 4, 5};
    //K表示数组第一个值，也就是0号索引，V代表K的下一个索引值，两个索引的值相加
    Arrays.parallelPrefix(ints,(K,V)-> K+V);
    //输出为[1, 3, 6, 10, 15]：流程是1和2相加为3，3和3相加为6，6和4相加为10...以此往后类推
    System.out.println(Arrays.toString(ints));

    int[] Ints = {5,4,3,2,1,0};
    //从1号索引到5号索引之间开始相加数值
    Arrays.parallelPrefix(Ints,1,5,(K,V) -> K + V);
    System.out.println(Arrays.toString(Ints)); //输出为[5, 4, 7, 9, 10, 0]

}

parallelSort使用并行排序+合并排序算法对数组进行排序

public void parallelSort() {
    int[] ints = {2, 3, 4, 5, 1};
    Arrays.parallelSort(ints);
    //输出为：[1, 2, 3, 4, 5]
    System.out.println(Arrays.toString(ints));
    
    int[] Ints = {2, 3, 4, 5, 1,6,8,7};
    //从1到7号索引之间进行排序
    Arrays.parallelSort(Ints,1,7);
    //输出为：[2, 1, 3, 4, 5, 6, 8, 7]
    System.out.println(Arrays.toString(Ints));
}

废话时间：

如果客官觉得食用合适可不可以给一个免费的赞！谢谢谢了！慢走客官！建议打包收藏，下次再来。店小二QQ：309021573，欢迎骚扰！