簡單瞭解JAVA8的新特性

時間 2019-11-20

標籤簡單瞭解 java8 java 特性欄目 Java 简体版

原文原文鏈接

JAVA8新特性會顛覆整個JAVA程序員的編程習慣java

甚至若是您堅守JAVA7以前的編程習慣，從此你看比較年輕的程序員寫的JAVA代碼都會沒法理解程序員

因此爲了保證不脫鉤，我以爲有必要學習JAVA8的新特性，何況，這會極大得提升CPU效率和編碼效率編程

咱們來簡單瞭解一下JAVA8的新特性框架

我以爲主要有兩個比較重要的，一是Lambda表達式，二是集合類的stream操做eclipse

關於這兩點，我寫了幾個小DEMO，附上註釋，應該可以迅速掌握編程語言

若是你們好奇更多的JAVA8新特性，請自行閱讀更加專業的知識，敏捷開發不求甚解是個人編程態度。函數式編程

順便說一句，JAVA8目前只有最新版eclipse MARs支持編譯函數

即便您下載了JAVA8的JDK和JRE，myeclipse目前還不支持對JAVA8的編譯學習

也就是說下面的代碼會在myeclipse下面報錯的。編碼

package com.newflypig.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestJava {
    public static void main(String[] args) {
        // java8 的新特性，lambda表達式，相似於匿名內部類
        Thread testThread = new Thread(() -> {
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("aa");
            list.add("bb");
            list.add("cc");
            list.forEach(s -> {
                System.out.println(s);
                ;
            });

            list.stream().filter(s -> s.length() == 2).forEach(s -> {
                System.out.println(s);
            });
        });

        System.out.println("======================================");

        distinct("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9");

        testThread.run();
    }

    // 新特性，不定參數
    private static void distinct(String... numbers) {
        List<String> list = Arrays.asList(numbers);
        List<Integer> listInt = list.stream()
            .map(s -> Integer.parseInt(s))         // 將集合流中的元素一一映射爲一個新的元素，並生成到新的輸出流中
            .filter(a -> isPrime(a))             // 過濾，lambda表達式
            .distinct()                         // stream的高級方法，去除重複
            .collect(Collectors.toList());        // 將整理好的輸出流收集到新的listInt集合中        
        /**
         * 你可能會以爲在這個例子裏，List list被迭代了好屢次，
         * map，filter，distinct都分別是一次循環，效率會很差。
         * 實際並不是如此。這些返回另外一個Stream的方法都是「lazy」的，而最後返回最終結果的collect方法則是「eager」的。
         * 在遇到eager方法以前，lazy的方法不會執行。
         * 
         * 當遇到eager方法時，前面的lazy方法纔會被依次執行。
         * 並且是管道貫通式執行。這意味着每個元素依次經過這些管道。
         * 例若有個元素「3」，首先它被map成整數型3；
         * 而後經過filter，發現是素數，被保留下來；又經過distinct，
         * 若是已經有一個3了，那麼就直接丟棄，若是尚未則保留。這樣，3個操做其實只通過了一次循環。
         * 
         * 除collect外其它的eager操做還有forEach，toArray，reduce等
         */
        
        
        listInt
            .stream()
            .forEach(i -> {                         // stream的forEach，相似於Collections.forEach
                System.out.println(i);
            });
        
        
        
        int sum=listInt
            .stream()
            .reduce((isum,item)->isum+item)
            .get();
        int min=listInt
            .stream()
            .reduce((a,b)->a<b?a:b)
            .get();
        int max=listInt
            .stream()
            .reduce((a,b)->a>b?a:b)
            .get();
        /**
         * reduce方法接受一個函數，這個函數有兩個參數，
         * 第一個參數是上次函數執行的返回值（也稱爲中間結果），
         * 第二個參數是stream中的元素，這個函數把這兩個值相加，
         * 獲得的和會被賦值給下次執行這個函數的第一個參數。
         * 要注意的是：第一次執行的時候第一個參數的值是Stream的第一個元素， 第二個參數是Stream的第二個元素。
         * 這個方法返回值類型是Optional，這是Java8防止出現NPE(NULL POINT ELEMENT)的一種可行方法，
         * 這裏就簡單的認爲是一個容器，其中可能會包含0個或者1個對象。
         */
        System.out.println(sum+"\t"+min+"\t"+max);
    }
    
    

    private static boolean isPrime(int a) {
        boolean flag = true;
        for (int i = 2; i <= a / 2; i++) {
            if (a % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}