大概一年多之前，我對java8的理解還僅限一些只言片語的文章之上，后來出于對函數(shù)式編程的興趣，買了本參考書看了一遍，然后放在了書架上，后來，當(dāng)我接手大客戶應(yīng)用的開發(fā)工作之后，java8的一些工具，對我的效率有了不小的提升，因此想記錄一下java"8的一些常用場景，我希望這會(huì)成為一個(gè)小字典，能讓我免于頻繁翻書，但是總能找到自己想找的知識(shí)。

用于舉例的model：

@Data
public class Apple {
    private Long appleId;
    private String appleName;
    private Float appleWeight;
    private Integer appleClassic;
}

這無疑是最常用的功能之一，其實(shí)lambda表達(dá)式的作用，應(yīng)該就是簡潔明了，實(shí)際上是用最短的字符，通過類型推導(dǎo)，語法糖等方式去對編譯器描述清楚這段代碼的功能，這和泛型有點(diǎn)相似，對于編程人員來說，一定程度上也提高了編程效率和代碼可讀性。

如常用的lambda表達(dá)式：
process(()->System.out.println("this is so cool!"))

例如對蘋果重量排序：

   List apples = Lists.newArrayList();
        for (int i = 1; i < 10; i++) {
            Apple apple = new Apple();
            apples.add(apple);
        }
        apples.sort(Comparator.comparing(Apple::getAppleWeight));


反序：
        apples.sort(Comparator.comparing(Apple::getAppleWeight).reversed());


重量相同時(shí)：比較等級：



  apples.sort(Comparator
                .comparing(Apple::getAppleWeight)
                .reversed()



謂詞復(fù)合查詢：


  Predicate a = apple -> apple.getAppleWeight() > 10;
        weight10.or(apple -> apple.getAppleClassic() > 2)
                .and(apple -> StringUtils.equalsIgnoreCase(apple.getAppleName(), "優(yōu)質(zhì)蘋果"));
                
可以看做（a||b）&&c


函數(shù)復(fù)合：


        Function f = a -> a.getAppleWeight() + 1;
        Function g = a -> a * 2;
        Function h = f.andThen(g);
        
    數(shù)學(xué)寫作 h=g(f(x))

  Function g = a -> a.getAppleWeight() + 1;
        Function f = a -> a * 2;
        Function h = f.compose(g);
 數(shù)學(xué)寫作 h=f(g(x))

小結(jié)：java8實(shí)際上想傳遞函數(shù)，函數(shù)是什么？是一個(gè)映射，可以看做x->y,輸入x然后映射到值y的過程，
java無法擺脫一切皆是對象的思想，因此函數(shù)式依附在對象上傳遞的，因此也有了下面的說法，方法引用，以及函數(shù)式接口，讓函數(shù)隨著對象傳遞，為了函數(shù)式編程，甚至專門寫一個(gè)接口---對象來傳遞函數(shù)。然而，函數(shù)才是主角。

方法引用十分簡單，其實(shí)也是將方法作為參數(shù)傳遞。使用::域作用符，將一段方法傳遞。
舉例：Apple::getAppleId

 String::subString
 System.out::println

利用java進(jìn)行函數(shù)式編程主要就是利用函數(shù)式接口,但是函數(shù)式接口在java8之前就有一些了,就例如多線程的runnable,但是8以前是沒有l(wèi)ambda表達(dá)式的,所以只能使用匿名內(nèi)部類,在用過lambda表達(dá)式的人看來,那是相當(dāng)臃腫的,8更新了lambda表達(dá)式,這就使函數(shù)式編程更上一層樓.

java8的函數(shù)式接口為我們傳遞函數(shù)提供了工具，我們可以自己定義函數(shù)式接口，然后讓其他人，或者是java API調(diào)用。
關(guān)于函數(shù)接口，需要記住的就是兩件事：
函數(shù)接口是行為的抽象；
函數(shù)接口是數(shù)據(jù)轉(zhuǎn)換器。

在我接觸到j(luò)ava8流式處理的時(shí)候，我的第一感覺是流式處理讓集合操作變得簡潔了許多，通常我們需要多行代碼才能完成的操作，借助于流式處理可以在一行中實(shí)現(xiàn)。其本質(zhì)是，將一些原本開發(fā)者需要做的處理如迭代等，放在了java庫里，讓我們只關(guān)心自己的業(yè)務(wù)邏輯，比如我們希望對一個(gè)包含整數(shù)的集合中篩選出所有的偶數(shù)，并將其封裝成為一個(gè)新的List返回，那么在java8之前，我們需要通過如下代碼實(shí)現(xiàn)：

過去：
List evens = new ArrayList<>();
for (final Integer num : nums) {
    if (num % 2 == 0) {
        evens.add(num);
    }
}

stream實(shí)現(xiàn)：
List evens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());



我們需要取出10個(gè)等級高于3的蘋果，跳過其中兩個(gè)，按重量排序，去重，然后取出蘋果的Name,然后取出名字的每個(gè)字符：
 List appleName = apples.parallelStream()
                .filter(a -> a.getAppleClassic() < 2)
                .sorted(Comparator.comparing(Apple::getAppleWeight))
                .map(Apple::getAppleName)
                .map(s -> s.split(""))
                .limit(10)
                .skip(2)
                .distinct()
                .flatMap(Arrays::stream)
                .collect(Collectors.toList());   
                
構(gòu)造AppleId ApppleName Map:
        Map appleIdMap = apples.stream()
                .collect(Collectors.toMap(Apple::getAppleId, Apple::getAppleName, (s, s2) -> s.length() > s2.length() ? s : s2));
       
       
 謂詞查找：      
 if (appleName.stream().anyMatch(a -> StringUtils.equalsIgnoreCase(a, "一級蘋果")));
        if (appleName.stream().allMatch(a -> StringUtils.equalsIgnoreCase(a, "一級蘋果")));
        if (appleName.stream().noneMatch(a -> StringUtils.equalsIgnoreCase(a, "一級蘋果")));
     


短路查找：
        appleName.stream()
                .filter(a -> StringUtils.equalsIgnoreCase(a, "一級蘋果"))
                .findAny()
                .ifPresent(System.out::println);
findfirst在并行時(shí)限制多一些，如果不在意返回的是哪個(gè)元素，使用findAny。
                
       
求和：         
    apples.stream()
    .map(Apple::getAppleWeight)
    .reduce(0F, (a, b) -> a + b);

計(jì)數(shù)：
        apples.stream().count();

                

使用stream的好處：
1.更簡潔，更易讀
2.可復(fù)合，更靈活
3.可并行

Optional著重為解決java的NPE問題是Java8提供的為了解決null安全問題的一個(gè)API。善用Optional可以使我們代碼中很多繁瑣、丑陋的設(shè)計(jì)變得十分優(yōu)雅。

使用Optional，我們就可以把下面這樣的代碼進(jìn)行改寫：
public static String getName(User u) {
    if (u == null)
        return "Unknown";
    return u.name;
}

不過，千萬不要改寫成這副樣子。

public static String getName(User u) {
    Optional user = Optional.ofNullable(u);
    if (!user.isPresent())
        return "Unknown";
    return user.get().name;
}

這樣才是正確使用Optional的姿勢。那么按照這種思路，我們可以安心的進(jìn)行鏈?zhǔn)秸{(diào)用，而不是一層層判斷了。
public static String getName(User u) {
    return Optional.ofNullable(u)
                    .map(user->user.name)
                    .orElse("Unknown");
}
看一段代碼：

public static String getChampionName(Competition comp) throws IllegalArgumentException {
    if (comp != null) {
        CompResult result = comp.getResult();
        if (result != null) {
            User champion = result.getChampion();
            if (champion != null) {
                return champion.getName();
            }
        }
    }
    throw new IllegalArgumentException("The value of param comp isn"t available.");
}
讓我們看看經(jīng)過Optional加持過后，這些代碼會(huì)變成什么樣子。
public static String getChampionName(Competition comp) throws IllegalArgumentException {
    return Optional.ofNullable(comp)
            .map(c->c.getResult())
            .map(r->r.getChampion())
            .map(u->u.getName())
            .orElseThrow(()->new IllegalArgumentException("The value of param comp isn"t available."));
}

還有很多不錯(cuò)的使用姿勢，比如為空則不打印可以這么寫：

string.ifPresent(System.out::println);

參考資料：《Java 8 in Action: Lambdas, streams, and functional-style programming》 Raoul-gabriel Urma (作者), Mario Fusco (作者), Alan Mycroft (作者)

作者：文爍
點(diǎn)擊 閱讀更多 查看更多詳情