Java順序員的日常—— Arrays工具類的運用

這個類在日常的開發中，還是十分常用的。明天就總結一下Arrays工具類的常用辦法。最常用的就是asList,sort,toStream,equals,copyOf了。另外可以深化學習下Arrays的排序算法，這個還是十分有用的。

一切的辦法都是在上面的類中停止測試的:

public class ArraysTest {
    String[] array = new String[]{"a","c","2","1","b"};
    Integer[] ints = new Integer[]{5,1,4,3,2};
    ...
}

asList

這個辦法可以把數組轉換成List,List提供了很多的操作辦法，更便於運用。

    @Test
    public void test1(){
        List<String> lists = Arrays.asList(array);
    }

sort排序和parallelSort並行排序

sort比擬常用了，依據元素依照自然排序規則排序，也可以設置排序元素的起始地位。

    @Test
    public void sort(){
       /* Arrays.sort(array);
        for(String str : array){
            System.out.println(str);
        }*/
        Arrays.sort(array,2,5);
        System.out.println(Arrays.deepToString(array));//[a, c, 1, 2, b]
    }

parallelSort則采用並行的排序算法排序.但是我自己測試，能夠數據量太小，速度上並沒有分明的變化。

binarySearch

查找目的元素所在的地位，留意需求先停止排序。

    @Test
    public void binarySearch(){
        //binarySearch需求保證是排好序的
        System.out.println(Arrays.binarySearch(array,"c"));//-6
        Arrays.sort(array);
        System.out.println(Arrays.binarySearch(array,"c"));//4
    }

copyOf

拷貝數組，第一種用法，假如目的長度不夠，會運用0停止補位。第二種用法，支持拷貝目的起始地位到完畢為止的數組。

    @Test
    public void copyOf(){
        //假如位數不夠，需求補位
        Integer[] result = Arrays.copyOf(ints,10);
        for(int i : result){
            System.out.println(i);
        }
        System.out.println("----------------------------------------->");
        //假如位數夠，就取最小的數組
        result = Arrays.copyOf(ints,3);
        for(int i : result){
            System.out.println(i);
        }
        System.out.println("----------------------------------------->");
        //
        result = Arrays.copyOfRange(ints,2,4);
        for(int i : result){
            System.out.println(i);
        }
    }

deepEquals深度比擬、deepHashCode生成hashcode、deepToString深度打印

這幾個辦法根本都是采用遞歸的寫法運用。

    @Test
    public void deepTest(){
        String[] array2 = new String[]{"a","c","2","1","b"};
        System.out.println(Arrays.deepEquals(array,array2));//深度比擬兩個數組能否相反

        System.out.println(Arrays.deepHashCode(array));
        System.out.println(Arrays.deepHashCode(array2));//假如兩個數組deepEquals，那麼他們的hashcode一定相反

        //格式化輸入數組
        System.out.println(Arrays.deepToString(array));
    }

equals比擬

比照兩個數組能否相等

    @Test
    public void equals(){
        String[] array2 = new String[]{"a","c","2","1","b"};

        //1 比照援用能否相反
        //2 比照能否存在null
        //3 比照長度能否相反
        //4 挨個元素比照
        System.out.println(Arrays.equals(array,array2));
    }

fill

基於目的元素填充數組

    @Test
    public void fill(){
        Arrays.fill(array,"test");
        System.out.println(Arrays.deepToString(array));//[test, test, test, test, test]
    }

toString

打印數組元素

    @Test
    public void string(){
        System.out.println(Arrays.toString(array));//[a, c, 2, 1, b]
    }

toStream

把數組轉換成stream,然後可以運用java8的stream特性了。

    @Test
    public void toStream(){
        Arrays.stream(array).forEach(s-> System.out.println(s));
    }

parallelPrefix

這個有點像spark的reduceByKey，即依據傳入的辦法一次計算：

    @Test
    public void parallelPrefix(){
        Arrays.parallelPrefix(ints,(x,y)->(x+y));
        System.out.println(Arrays.deepToString(ints));//[5, 6, 10, 13, 15]
    }

parallelSetAll

這個辦法相當於stream.map會挨個元素遍歷執行辦法

    @Test
    public void parallelSetAll(){
        Arrays.parallelSetAll(ints,x->x*x);
        System.out.println(Arrays.toString(ints));//[0, 1, 4, 9, 16]
    }

setAll

這個辦法與下面相似，只不過不是並行的

    @Test
    public void setAll(){
        Arrays.setAll(ints,x->x*2);
        System.out.println(Arrays.toString(ints));
    }