Java Lambda學習

Java Lamdba學習

1. 前言

最近開放項目的時候總感覺許多時候代碼冗餘，所以打算好好研究研究lamdba來讓代碼看起來更簡介

2. 初探Lambda

最經典的莫過於集合排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Good> goods = new ArrayList<>();
        goods.add(new Good("Apple", 30));
        goods.add(new Good("Pear", 10));
        goods.add(new Good("Banana", 20));
        System.out.println("before sort");
        goods.forEach(g -> System.out.println(g));

        /**
        **通過lambda進行比較排序，代替Compator的作用
        */
        Collections.sort(goods, (p1, p2) -> Integer.compare(p1.value, p2.value));
        System.out.println("after sort");
        goods.forEach(g -> System.out.println(g));

    }

    private static class Good {
        String name;
        int value;

        public Good(String name, int value) {
            this.name = name;
            this.value = value;
        }
        @Override
        public String toString() {
            return name + "->" + value;
        }
    }
}

• 當lambda的參數爲1個的時候可以省略小括號，當lambda的函數體只有一條的時候也可以省略大括號

• 在編譯器可以推斷出類型的時候，可以省略參數類型，因爲這的compator的參數類型只能是Good,所以p1和p2的數據類型一定爲Good,故可以省略參數類型。

• 不僅在編寫compator的時候可以採用lambda表達式，例如list的foreach也可以使用lambda表達式，例如打印列表的每一個元素。

3.Lambad應用

首先定義一個篩選類

    private static class GoodFilter {
        public void printSomeGood(List<Good> goods, Predicate<Good> p) {
            /**
            * 列表的foreach+java.util.function的Predicate篩選
            */
            goods.forEach(g -> {
                if (p.test(g))
                    System.out.println(g);
            });
        }

    }

進行篩選操作

    Predicate<Good> expensive = g -> g.value >= 20;
    Predicate<Good> cheap = g -> g.value < 20;
    GoodFilter filter = new GoodFilter();
    System.out.println("Expensive Goods list");
    filter.printSomeGood(goods, expensive);
    System.out.println("Cheap Goods list");
    filter.printSomeGood(goods, cheap);

• Predicate爲java.util.function包中函數，該包下的其他函數請自行百度學習
• 與以前定義接口和接口實現的大量代碼相比較，無疑簡潔很多。

4. Stream API 介紹

Stream 就如同一個迭代器（Iterator），單向，不可往復，數據只能遍歷一次，遍歷過一次後即用盡了，就好比流水從面前流過，一去不復返。而和迭代器又不同的是，Stream可以並行化操作，迭代器只能命令式地、串行化操作.

    /**
    * 流式操作，先篩選，再將符合條件的元素轉化爲其value值，最後相加打印
    */
    int sum = goods.stream()
                .filter(g -> g.value >= 20)
                .mapToInt(g -> g.value)
                .sum();
    System.out.println(sum);

     /**
    * 流式操作，先篩選，再將符合條件的商品轉化爲其姓名，最後應用變爲小寫的操作，最後通過foreach打印
    */

    List<String> ret = goods.stream()
             .filter(g -> g.value >= 20)
             .map(g -> g.name)
             .map(String::toLowerCase)
             .collect(Collectors.toList());
    ret.forEach(p->System.out.println(p));

• 要注意的是goods的元素並沒有改變，每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換）。