java8新特性 Stream

今天我們來學習一下java8的新特性，歡迎關注點贊。想要獲取學習資料添加qq : 1184905186

一、接口的默認方法

Java 8允許我們給接口添加一個非抽象的方法實現，只需要使用 default關鍵字即可，這個特徵又叫做擴展方法，示例如下：

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Formula接口在擁有calculate方法之外同時還定義了sqrt方法，實現了Formula接口的子類只需要實現一個calculate方法，默認方法sqrt將在子類上可以直接使用

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

二、Lambda 表達式

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

只需要給靜態方法 Collections.sort 傳入一個List對象以及一個比較器來按指定順序排列。通常做法都是創建一個匿名的比較器對象然後將其傳遞給sort方法。

• 在Java 8 中你就沒必要使用這種傳統的匿名對象的方式了，Java 8提供了更簡潔的語法，lambda表達式：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");


        Collections.sort(names,(String a,String b)->{

            return a.compareToIgnoreCase(b);
        });

        System.out.println(names);

對於函數體只有一行代碼的，你可以去掉大括號{}以及return關鍵字，但是你還可以寫得更短點：

Collections.sort(names,( a, b)->  a.compareToIgnoreCase(b));

三.Stream 接口

java.util.Stream 表示能應用在一組元素上一次執行的操作序列。Stream 操作分爲中間操作或者最終操作兩種，最終操作返回一特定類型的計算結果，而中間操作返回Stream本身，這樣你就可以將多個操作依次串起來。Stream 的創建需要指定一個數據源，比如 java.util.Collection的子類，List或者Set， Map不支持。Stream的操作可以串行執行或者並行執行。
首先看看Stream是怎麼用，首先創建實例代碼的用到的數據List：

List<String> list = new ArrayList<>();
        list.add("android");
        list.add("anna");
        list.add("mike");
        list.add("xenia");

        Java 8擴展了集合類，可以通過 Collection.stream() 或者 Collection.parallelStream() 來創建一個Stream。下面幾節將詳細解釋常用的Stream操作：
Filter 過濾

        過濾通過一個predicate接口來過濾並只保留符合條件的元素，該操作屬於中間操作，所以我們可以在過濾後的結果來應用其他Stream操作（比如forEach）。forEach需要一個函數來對過濾後的元素依次執行。forEach是一個最終操作，所以我們不能在forEach之後來執行其他Stream操作。

        list.stream().filter((a)->a.startsWith("a")).forEach(System.out::println);

Sort 排序

排序是一箇中間操作，返回的是排序好後的Stream。如果你不指定一個自定義的Comparator則會使用默認排序。

         List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");
        list.stream().sorted((a, b) -> a.compareToIgnoreCase(b)).forEach(System.out::println);
        //不會對原有的集合造成影響
        System.out.println(list);

Map 映射

        中間操作map會將元素根據指定的Function接口來依次將元素轉成另外的對象，下面的示例展示了將字符串轉換爲大寫字符串。你也可以通過map來講對象轉換成其他類型，map返回的Stream類型是根據你map傳遞進去的函數的返回值決定的。

 List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        
        list.stream().map(String::toUpperCase).sorted((a, b) -> a.compareToIgnoreCase(b)).forEach(System.out::println);
        //不會對原有的集合造成影響
        System.out.println(list);

Match 匹配

    Stream提供了多種匹配操作，允許檢測指定的Predicate是否匹配整個Stream。所有的匹配操作都是最終操作，並返回一個boolean類型的值。

       
        List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        //任意元素是 x 開頭
        boolean anyMatch = list.stream().anyMatch((a) -> a.startsWith("x"));
        System.out.println("anyMatch: "+anyMatch);
        //所有元素是 x 開頭
        boolean allMatch = list.stream().allMatch((a) -> a.startsWith("x"));
        System.out.println("allMatch: "+allMatch);
        //沒有元素是 g 開頭
        boolean noneMatch = list.stream().noneMatch((a) -> a.startsWith("g"));
        System.out.println("noneMatch: "+noneMatch);

        //不會對原有的集合造成影響
        System.out.println(list);

anyMatch: true
allMatch: false
noneMatch: true
[android, xenia, anna, mike]

Count 計數

計數是一個最終操作，返回Stream中元素的個數，返回值類型是long。

        List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        list.stream().filter((a) -> a.startsWith("a")).count();//2

Reduce 規約

這是一個最終操作，允許通過指定的函數來講stream中的多個元素規約爲一個元素，規越後的結果是通過Optional接口表示的：

 List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        Optional<String> a1 = list.stream().filter((a) -> a.startsWith("a")).reduce((a, b) -> a + "%%%" + b);//2
        System.out.println(a1);//Optional[android%%%anna]

並行Streams

前面提到過Stream有串行和並行兩種，串行Stream上的操作是在一個線程中依次完成，而並行Stream則是在多個線程上同時執行。

下面的例子展示了是如何通過並行Stream來提升性能：

首先我們創建一個沒有重複元素的大表

        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

1. 串行排序

        long t0 = System.nanoTime();
        System.out.println(values.stream().sorted().count());
        long t1 = System.nanoTime();

        long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
        System.out.printf("sequential sort took: %d ms",millis);//843ms

2. 並行排序

        long t0 = System.nanoTime();
        System.out.println(values.parallelStream().sorted().count());

        long t1 = System.nanoTime();

        long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
        System.out.printf("parallel sort took: %d ms", millis);//370ms

上面兩個代碼幾乎是一樣的，但是並行版的快了50%之多，唯一需要做的改動就是將stream()改爲parallelStream()。