Java8新特性（一）-Lambda表示式

一，Java8新特性簡介

1，速度更快

2，程式碼更少（增加了新的語法Lambda表示式）

3，強大的Stream API

4,便於並行

5，最大化減少空指標異常Optional

 

二，Lambda表示式

1，為什麼使用Lambda表示式

 Lambda 是一個匿名函式，我們可以把 Lambda表示式理解為是一段可以傳遞的程式碼（將程式碼像資料一樣進行傳遞）。可以寫出更簡潔、更靈活的程式碼。作為一種更緊湊的程式碼風格，使Java的語言表達能力得到了提升。 

 

2，Lambda表示式的關鍵：從匿名類到 Lambda 的轉換

示例：

3，Lambda表示式語法

Lambda表示式在Java 語言中引入了一個新的語法元

素和操作符。這個操作符為 “->” ， 該操作符被稱 

為 Lambda 操作符或剪頭操作符。它將 Lambda 分為 

兩個部分：

左側： 指定了 Lambda 表示式需要的所有引數

右側： 指定了 Lambda 體，即 Lambda 表示式要執行

的功能。

（1）語法格式一：無參，無返回值，Lambda 體只需一條語句

  示例：Runnable r1 = () -> System.out.println("Hello Lambda!");

（2）語法格式二：Lambda 需要一個引數 

  示例：Consumer<String> con = （x） -> System.out.println(x);

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

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

（4）語法格式四：Lambda 需要兩個引數，並且有返回值 

  示例：

 Comparator<Integer> com = (x, y) -> {

   System.out.println("函式式介面");

   return Integer.compare(x, y);

  };

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

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

（6）Lambda 表示式的引數列表的資料型別可以省略不寫，因為JVM編譯器通過上下文推斷出，資料型別，即“型別推斷”

  示例：

Comparator<Integer> com = (Integer 

x,

Integer 

y) -> {  //Integer 型別可以省略

   System.out.println("函式式介面");

   return Integer.compare(x, y);

  };

型別推斷：Lambda 表示式中的引數型別都是由編譯器推斷 得出的。 Lambda 表示式中無需指定型別，程式依然可 以編譯，這是因為 javac 根據程式的上下文，在後臺 推斷出了引數的型別。 Lambda 表示式的型別依賴於上 下文環境，是由編譯器推斷出來的。這就是所謂的 “型別推斷”

 

三，函式式介面

1，什麼是函式式介面

（1）只包含一個抽象方法的介面，稱為函式式介面。

（2）你可以通過 Lambda 表示式來建立該介面的物件。（若 Lambda 表示式丟擲一個受檢異常，那麼該異常需要在目標介面的抽象方 法上進行宣告）。 

（3）我們可以在任意函式式介面上使用 @FunctionalInterface 註解， 這樣做可以檢查它是否是一個函式式介面，同時 javadoc 也會包 含一條宣告，說明這個介面是一個函式式介面。

 

2，自定義函式介面

3，作為引數傳遞的Lambda表示式

作為引數傳遞 Lambda 表示式：為了將 Lambda 表示式作為引數傳遞，接
收Lambda 表示式的引數型別必須是與該 Lambda 表示式相容的函式式介面
的型別。 

 

4，Java 內建四大核心函式式介面 

（1），Consumer<T> : 消費型介面

  void accept(T t);

示例：

//Consumer<T> 消費型介面 :
 @Test
 public void test1(){
  happy(10000, (m) -> System.out.println("你們剛哥喜歡大寶劍，每次消費：" + m + "元"));
 }
 public void happy(double money, Consumer<Double> con){
  con.accept(money);
 }

 

（2），Supplier<T> : 供給型介面  T get(); 

示例：

//Supplier<T> 供給型介面 :
 @Test
 public void test2(){
  List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
  for (Integer num : numList) {
   System.out.println(num);
  }
 }
 //需求：產生指定個數的整數，並放入集合中
 public List<Integer> getNumList(int num, Supplier<Integer> sup){
  List<Integer> list = new ArrayList<>();
  for (int i = 0; i < num; i++) {
   Integer n = sup.get();
   list.add(n);
  }   
  return list;
 }

(3)，Function<T, R> : 函式型介面   R apply(T t);

示例：

//Function<T, R> 函式型介面：
 @Test
 public void test3(){
  String newStr = strHandler("\t\t\t 我大尚矽谷威武 ", (str) -> str.trim());
  System.out.println(newStr);
  String subStr = strHandler("我大尚矽谷威武", (str) -> str.substring(2, 5));
  System.out.println(subStr);
 }
 //需求：用於處理字串
 public String strHandler(String str, Function<String, String> fun){
  return fun.apply(str);
 }

(4)，Predicate<T> : 斷言型介面  boolean test(T t);

示例：

//Predicate<T> 斷言型介面：
 @Test
 public void test4(){
  List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
  List<String> strList = filterStr(list, (s) -> s.length() > 3);
  for (String str : strList) {
   System.out.println(str);
  }
 }
 //需求：將滿足條件的字串，放入集合中
 public List<String> filterStr(List<String> list, Predicate<String> pre){
  List<String> strList = new ArrayList<>();
  for (String str : list) {
   if(pre.test(str)){
    strList.add(str);
   }
  }
  return strList;
 }

5,其它介面

6，方法引用和構造器引用

方法引用：

當要傳遞給Lambda體的操作，已經有實現的方法了，可以使用方法引用！

（實現抽象方法的引數列表，必須與方法引用方法的引數列表保持一致！ ）

方法引用：使用操作符 “::” 將方法名和物件或類的名字分隔開來。

如下三種主要使用情況：

（1）物件::例項方法

例如：

@Test
 public void test1(){
  PrintStream ps = System.out;
  Consumer<String> con = (str) -> ps.println(str);
  con.accept("Hello World！");
 
  System.out.println("--------------------------------");
 
  Consumer<String> con2 = ps::println;
  con2.accept("Hello Java8！");
 
  Consumer<String> con3 = System.out::println;
 }
@Test
 public void test2(){
  Employee emp = new Employee(101, "張三", 18, 9999.99);
 
  Supplier<String> sup = () -> emp.getName();
  System.out.println(sup.get());
 
  System.out.println("----------------------------------");
 
  Supplier<String> sup2 = emp::getName;
  System.out.println(sup2.get());
 }

（2）類::靜態方法

例如：

@Test
 public void test3(){
  BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
  System.out.println(fun.apply(1.5, 22.2));
 
  System.out.println("--------------------------------------------------");
  BiFunction<Double, Double, Double> fun2 = Math::max;
  System.out.println(fun2.apply(1.2, 1.5));
 }
@Test
 public void test4(){
  Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 
  System.out.println("-------------------------------------");  
  Comparator<Integer> com2 = Integer::compare;
 }
（3）類::例項方法
例如：
@Test
 public void test5(){
  BiPredicate<String, String> bp = (x, y) -> x.equals(y);
  System.out.println(bp.test("abcde", "abcde"));
 
  System.out.println("-----------------------------------------");
  BiPredicate<String, String> bp2 = String::equals;
  System.out.println(bp2.test("abc", "abc"));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun = (e) -> e.show();
  System.out.println(fun.apply(new Employee()));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun2 = Employee::show;
  System.out.println(fun2.apply(new Employee()));   
 }

 

注意：

 * ①方法引用所引用的方法的引數列表與返回值型別，需要與函式式介面中抽象方法的引數列表和返回值型別保持一致！

 * ②若Lambda 的引數列表的第一個引數，是例項方法的呼叫者，第二個引數(或無參)是例項方法的引數時，格式： ClassName::MethodName

 

構造器引用：構造器的引數列表，需要與函式式介面中引數列表保持一致！

格式： ClassName::new

與函式式介面相結合，自動與函式式介面中方法相容。

可以把構造器引用賦值給定義的方法，與構造器引數

列表要與介面中抽象方法的引數列表一致！

陣列引用：