java8新特性1--Lambda表達式

一、Lambda表達式是什麼？

Lambda表達式有兩個特點

一是匿名函數，二是可傳遞。

匿名函數的應用場景是

通常是在需要一個函數，但是又不想費神去命名一個函數的場合下使用Lambda表達式。lambda表達式所表示的匿名函數的內容應該是很簡單的，如果複雜的話，乾脆就重新定義一個函數了，使用lambda就有點過於執拗了。

可傳遞使用場景是

就是將Lambda表達式傳遞給其他的函數，它當做參數，Lambda作爲一種更緊湊的代碼風格，使Java的語言表達能力得到提升。

二、Lambda表達式語法

Lambda表達式在Java語言中引入了一個新的語法元素和操作符。這個操作符爲"->"，該操作符被稱爲Lambda操作符或箭頭操作符，它將Lambda分爲兩個部分：

左側：指定了Lambda表達式所需要的所有參數
右側：指定了Lambda體，即Lambda表達式所要執行的功能。

常見的語法格式

語法格式一：無參，無返回值，Lambda體只需要一條語句。

Runnable r = () -> System.out.println("Hello Lambda!");

語法格式二：Lambda需要一個參數

Consumer<String> con = (x) -> System.out.println(x);

語法格式三：Lambda只需要一個參數時，參數的小括號可以省略

Consumer<String> con = x -> System.out.println(x);

語法格式四：Lambda需要兩個參數，並且有返回值

Comparator<Integer> com = (x, y) -> {
        System.out.println("函數式接口");
        return Integer.compare(x, y);
};

語法格式五：當Lambda體只有一條語句時，return與大括號可以省略

Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

語法格式六：數據類型可以省略，因爲可由編譯器推斷得出，稱爲類型推斷

BinaryOperator<Long> operator = (Long x, Long y) -> {
    System.out.println("實現函數接口方法");
    return x + y;
};

三、Lambda表達式實戰

實戰1：線程

public class Test {
    public static void main(String[] args) {
        // Java8之前：
        new Thread(new Runnable() {
            public void run() {
                System.out.println("hello world");
            }
        }).start();
        // Java8方式：
        new Thread(() -> System.out.println("hello world")).start();
}

實戰2：集合元素的遍歷

public class Test2 {
    public static void main(String[] args) {
        // Java8之前：
        List<String> list1 = Arrays.asList("a", "b", "c", "d");
        for (String str : list1) {
            System.out.println(str);
        }
        // Java 8之後：
        List list2 = Arrays.asList("a", "b", "c", "d");
        list2.forEach(n -> System.out.println(n));
        // 使用Java 8的方法引用更方便，方法引用由::雙冒號操作符標示，
        list2.forEach(System.out::println);
    }
}

實戰3：map函數

map函數可以說是函數式編程裏最重要的一個方法了。map的作用是將一個對象變換爲另外一個。

import java.util.Arrays;
import java.util.List;
public class Test3 {
    public static void main(String[] args) {
        map();
    }
    public static void map() {
        List<Double> cost = Arrays.asList(10.0, 20.0, 30.0);
        cost.stream().map(x -> x + x * 0.05).forEach(x -> System.out.println(x));
    }
}

實戰4： reduce函數

map的作用是將一個對象變爲另外一個，而reduce實現的則是將所有值合併爲一個。

import java.util.Arrays;
import java.util.List;
 
public class Test4 {
 
    public static void main(String[] args) {
        mapReduce();
    }
 
    public static void mapReduce() {
        List<Double> cost = Arrays.asList(10.0, 20.0, 30.0);
        double allCost = cost.stream().map(x -> x + x * 0.05).reduce((sum, x) -> sum + x).get();
        System.out.println(allCost);
    }
}

實戰5：過濾

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class Test5 {
 
    public static void main(String[] args) {
        filter();
    }
    public static void filter() {
        List<Double> cost = Arrays.asList(10.0, 20.0, 30.0, 40.0);
        List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());
        filteredCost.forEach(x -> System.out.println(x));
    }
}

實戰6：Predicate過濾

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
 
public class Test6 {
 
    public static void filter(List<String> languages, Predicate<String> condition) {
        languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
    }
 
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java", "Python", "scala", "Shell", "R");
        System.out.println("Language starts with J: ");
        filter(languages, x -> x.startsWith("J"));
        System.out.println("\nLanguage ends with a: ");
        filter(languages, x -> x.endsWith("a"));
        System.out.println("\nAll languages: ");
        filter(languages, x -> true);
        System.out.println("\nNo languages: ");
        filter(languages, x -> false);
        System.out.println("\nLanguage length bigger three: ");
        filter(languages, x -> x.length() > 4);
    }
}