JDK新特性-Lambda表達式的神操作

作者：牧小農 2021-05-05 11:31:15

Java8 引入 Lambda表達式是接收了函數式編程語言的思想，和指令式編程相比，函數式編程強調函數的計算比指令的執行重要。引入 Lambda表達式是接收了函數式編程語言的思想，和指令式編程相比，函數式編程強調函數的計算比指令的執行重要。

[[397312]]

一、Lambda表達式的介紹

Lambda表達式是 Java8 中最重要的新功能之一。使用 Lambda 表達式可以替代只有一個抽象函數的接口實現，告別匿名內部類，代碼看起來更簡潔易懂。Lambda表達式同時還提升了對集合、框架的迭代、遍歷、過濾數據的操作。
lambda表達式可以替代只有一個抽象函數的接口實現，告別匿名內部類，代碼看起來更簡潔易懂
lambda表達式同時還提升了對集合、框架的迭代、遍歷、過濾數據的操作
lambda可以極大的減少代碼冗余，同時代碼的可讀性要好過冗長的內部類，匿名類

例如以前我們使用匿名內部類來實現代碼：

Runnable runnable = new Runnable() { 
       @Override 
       public void run() { 
           System.out.println("running1 ....."); 
       } 
   }; 
   runnable.run();

使用lambda表達式實現更簡潔的代碼：

Runnable runnable3 = ()-> System.out.println("running2...."); 
    runnable3.run();

lambda表達式語法：

LambdaParameters -> LambdaBody

在這里插入圖片描述

args -> expr或者(object … args)-> {函數式接口抽象方法實現邏輯}

1、()參數的個數，根據函數式接口里面抽象的參數個數來決定，當參數只有一個的時候，()可以省略

2、當expr邏輯非常簡單的時候，{}和return可以省略

案例說明：

public static void main(String[] args) throws Exception { 
      Callable<String> c1 = new Callable() { 
          @Override 
          public String call() throws Exception { 
              return "muxiaonong"; 
          } 
      }; 
      System.out.println(c1.call()); 
 
      Callable<String> c2 = ()->{return "muxiaonong2";}; 
      System.out.println(c2.call()); 
 
      //邏輯很簡單的時候省略 {} 和 return 
      Callable<String> c3 = ()->"muxiaonong3"; 
      System.out.println(c3.call()); 
  }

二、Lambda表達式的特點

函數式編程
參數類型自動推斷
代碼量少，簡潔

三、Lambda表達式案例

實現方式列表：

()->{} 
       ()->{System.out.println(1);} 
       ()->System.out.println(1) 
       ()->{return 100;} 
       ()->100 
       ()->null 
       (int x)->{return x+1;} 
       (int x)->x+1 
       (x)->x+1 
       x->x+1

案例1：線程實現方式：

public static void main(String[] args) { 
      //匿名內部類方式 
      new Thread(new Runnable() { 
          @Override 
          public void run() { 
              System.out.println("runing1.........."); 
          } 
      }); 
 
      //Lambda表達式方式 
      new Thread(() -> {System.out.println("runing2.....");}).start(); 
  }

案例2：集合遍歷實現方式

public static void main(String[] args) { 
      List<String> list = Arrays.asList("java","python","scala","javascript"); 
 
      //普通匿名內部類方式 
      Collections.sort(list, new Comparator<String>() { 
          @Override 
          public int compare(String o1, String o2) { 
              return o1.length() - o2.length(); 
          } 
      }); 
 
      //Lambda方式 
      Collections.sort(list,(a,b) -> a.length() - b.length()); 
      list.forEach(System.out::println); 
  }

四、Lambda表達式的應用場景

重要的事情說三遍：任何有函數式接口的地方 * 3

什么是函數式接口：只有一個抽象方法(Object類中的方法除外)的接口是函數式接口

五、Lambda表達式實際應用

5.1 無參實體類模擬

模擬數據庫連接層：

@FunctionalInterface 
public interface StudentDao { 
    void insert(Student student); 
}

實體類

/** @Author mxn 
 * @Description 學生實體類 
 * @Date 10:19 2020/11/7 
 * @Param  
 * @return  
 **/ 
public class Student { 
} 
 public static void main(String[] args) { 
        StudentDao sd1 = new StudentDao() { 
            @Override 
            public void insert(Student student) { 
                System.out.println("插入學生1"); 
            } 
        }; 
 
        StudentDao sd2 = (student)->{ 
            System.out.println("student: "+student); 
        }; 
 
        StudentDao sd3 = (Student student)-> System.out.println("student3:"+student); 
 
        sd1.insert(new Student()); //輸出 插入學生1 
        sd2.insert(new Student());// 輸出 
        sd3.insert(new Student());// 輸出 
    }

5.2 有參實體類模擬

實體類

/** @Author mxn 
 * @Description  
 * @Date 10:26 2020/11/7 
 * @Param 
 * @return 
 **/ 
public class Teacher { 
}

接口模擬層

@FunctionalInterface 
public interface TeacherDao { 
    int get(Teacher teacher); 
}

實現層

 public static void main(String[] args) { 
        TeacherDao td1 = new TeacherDao() { 
            @Override 
            public int get(Teacher teacher) { 
                return 1; 
            } 
        }; 
        TeacherDao td2 = (teacher)->{return 2;}; 
        TeacherDao td3 = (Teacher teacher)->{return 3;}; 
        TeacherDao td4 = (teacher)->4; 
        TeacherDao td5 = (Teacher teacher)->5; 
 
        System.out.println(td1.get(new Teacher()));//輸出 1 
        System.out.println(td2.get(new Teacher()));//輸出 2 
        System.out.println(td3.get(new Teacher()));//輸出 3 
        System.out.println(td4.get(new Teacher()));//輸出 4 
        System.out.println(td5.get(new Teacher()));//輸出 5 
}

六、函數式接口

Supplier：代表一個輸出

Consumer：代表一個輸入

BiConsumer：代表兩個輸入

Function：代表一個輸入，一個輸出(一般輸入和輸出是不同類型的)

UnaryOperator：代表一個輸入，一個輸出(輸入和輸出是相同類型的)

BiFunction：代表兩個輸入，一個輸出(一般輸入和輸出是不同類型的)

BinaryOperator：代表兩個輸入，一個輸出(輸入和輸出是相同類型的)

在Java中提供了一系列的函數式接口，用來接受后續傳入的邏輯，但是對輸入和輸出有要求

6.1 Supplier：代表一個輸出

Supplier<String> s1 = ()->{return "muxiaonong";}; 
    Supplier<String> s2 = ()->"muxiaonong2"; 
    System.out.println(s1.get());//輸出 muxiaonong 
    System.out.println(s2.get());//輸出 muxiaonong2

6.2 Consumer：代表一個輸入

Consumer<String> c11 = (str) -> System.out.println(str); 
   c11.accept("beijing");//輸出 beijing

6.3 BiConsumer：代表兩個輸入

BiFunction<String,String,Integer> bf = (a,b)->a.length()+b.length(); 
     System.out.println(bf.apply("大吉大利", "今晚吃雞"));//輸出一個字符串長度 8

6.4 Function：代表一個輸入，一個輸出

//  Function<String,Integer>  用來接收后面的函數的實現，規定必須有一個輸入(String)有一個輸出(Integer) 
 Function<String,Integer> f1 = (str)->{return str.length();}; 
 System.out.println(f1.apply("abcdefg"));//輸出長度 7

七、方法的引用

方法引用是用來直接訪問類或者實例的已經存在的方法或者構造方法，方法引用提供了一種引用而不執行方法的方式，如果抽象方法的實現恰好可以使用調用另外一個方法來實現，就有可能可以使用方法引用

7.1 方法引用的分類

7.2 靜態方法引用

靜態方法引用： 如果函數式接口的實現恰好可以通過調用一個靜態方法來實現，那么就可以使用靜態方法引用

/** 
 * @program: lambda 
 * @ClassName Test2 
 * @description: 
 * @author: muxiaonong 
 * @create: 2020-10-28 22:15 
 * @Version 1.0 
 **/ 
public class Test2 { 
    //無參靜態方法 
     static String put(){ 
            System.out.println("put....."); 
            return "put"; 
        } 
 
    //有參靜態方法 
    public static void getSize(int size){ 
            System.out.println(size); 
        } 
 
     //有參 有返回值靜態方法 
     public static String toUpperCase(String str){ 
            return str.toUpperCase(); 
        } 
 
    //兩個入參，一個返回值靜態方法 
    public static Integer getLength(String str,String str2){ 
        return str.length()+str2.length(); 
    } 
 
      public static void main(String[] args) { 
        //無參靜態方法-普通調用 
        System.out.println(put());//輸出put 
        //無參靜態方法-原生調用 
        Supplier<String> s1 = ()-> Test2.put(); 
        System.out.println(s1.get());//輸出put 
        //無參靜態方法-靜態方法引用 
        Supplier<String> s2 = Test2::put; 
        System.out.println(s2.get());//輸出put 
        //無參靜態方法-內部類調用 
        Supplier<String> s3 = Fun::hehe; 
        System.out.println(s3.get()); //輸出hehe 
 
        // 有參靜態方法-靜態方法引用 
        Consumer<Integer> c1 = Test2::getSize; 
        Consumer<Integer> c2 = (size)-> Test2.getSize(size); 
        c1.accept(123); 
        c2.accept(111); 
 
        //有參有返回值靜態方法 
        Function<String,String> f1 = (str)->str.toUpperCase(); 
        Function<String,String> f2 = (str)-> Test2.toUpperCase(str); 
        Function<String,String> f3 = Test2::toUpperCase; 
        Function<String,String> f4 = Test2::toUpperCase; 
 
        System.out.println(f1.apply("abc"));//輸出 ABC  
        System.out.println(f2.apply("abc"));//輸出 ABC  
        System.out.println(f3.apply("abc"));//輸出 ABC  
        System.out.println(f4.apply("abc"));//輸出 ABC  
 
        // 兩個參數 一個返回值 函數式接口 
         BiFunction<String,String,Integer> bf = (a, b)->a.length()+b.length(); 
        BiFunction<String,String,Integer> bf2 = Test2::getLength; 
        System.out.println(bf2.apply("abc", "def"));//輸出 6 
        System.out.println(bf.apply("abc", "def"));//輸出 6 
 
    } 
 
    //內部類 
    class Fun { 
        public static String hehe(){ 
            return "hehe"; 
        } 
 
        public static String toUpperCase(String str){ 
            return str.toUpperCase(); 
        } 
 
    } 
 
}

7.3 實例方法引用

實例方法引用： 如果函數式接口的實現恰好可以通過調用一個實例的實例方法來實現，那么就可以使用實例方法引用

public class Test3 { 
    //實例無參方法 
    public String put(){ 
        return "put..."; 
    } 
 
    //實例有參方法 
    public void getSize(int size){ 
        System.out.println("size:"+size); 
    } 
 
    //實例有參有返回值方法 
    public String toUpperCase(String str){ 
        return  str.toUpperCase(); 
    } 
    public static void main(String[] args) { 
        //實例無參方法返回-普通調用 
        System.out.println(new Test3().put());//輸出 put... 
        Supplier<String> s1 = ()->new Test3().put(); 
        Supplier<String> s2 = ()->{return new Test3().put();}; 
        Supplier<String> s3 = new Test3()::put; 
        System.out.println(s1.get());//輸出 put... 
        System.out.println(s2.get());//輸出 put... 
        System.out.println(s3.get());//輸出 put... 
 
        //唯一的創建一個test3對象 
        Test3 test = new Test3(); 
 
        Consumer<Integer> c1 = (size)->new Test3().getSize(size); 
        Consumer<Integer> c2 = new Test3()::getSize; 
        Consumer<Integer> c3 = test::getSize; 
 
 
        c1.accept(123);//輸出 size:123 
        c2.accept(123);//輸出 size:123 
        c3.accept(123);//輸出 size:123 
 
        Function<String,String> f1 = (str)->str.toUpperCase(); 
        Function<String,String> f2 = (str)->test.toUpperCase(str); 
        Function<String,String> f3 = new Test3()::toUpperCase; 
        Function<String,String> f4 = test::toUpperCase; 
        System.out.println(f1.apply("abc"));//輸出 ABC 
        System.out.println(f2.apply("abc"));//輸出 ABC 
        System.out.println(f3.apply("abc"));//輸出 ABC 
        System.out.println(f4.apply("abc"));//輸出 ABC 
    } 
}

7.4 對象方法引用

對象方法引用： 抽象方法的第一個參數類型剛好是實例方法的類型，抽象方法剩余的參數恰好可以當做實例方法的參數。如果函數式接口的實現能由上面說的實例方法調用來實現的話，那么就可以使用對象方法引用

/** @Author mxn 
 * @Description //TODO 對象方法引用 
 * @Date 14:26 2020/11/7 
 * @Param  
 * @return  
 **/ 
public class Test4 { 
    public static void main(String[] args) { 
        Consumer<Too> c1 = (too)->new Too().foo(); 
        c1.accept(new Too());//輸出 foo 
 
        Consumer<Too> c2 = (Too too) ->new Too2().foo(); 
        c2.accept(new Too());//輸出 foo---too2 
 
        Consumer<Too> c3 = Too::foo; 
        c3.accept(new Too());//輸出 foo 
 
        BiConsumer<Too2,String> bc = (too2,str)->new Too2().show(str); 
        BiConsumer<Too2,String> bc2 = Too2::show; 
        bc.accept(new Too2(),"abc"); 
        bc2.accept(new Too2(),"def"); 
 
        BiFunction<Exec,String,Integer> bf1 = (e,s)->new Exec().test(s); 
        bf1.apply(new Exec(),"abc"); 
        BiFunction<Exec,String,Integer> bf2 = Exec::test; 
        bf2.apply(new Exec(),"def"); 
    } 
} 
 
class Exec{ 
    public int test(String name){ 
        return 1; 
    } 
 
} 
 
class Too{ 
    public Integer fun(String s){ 
        return 1; 
    } 
    public void foo(){ 
        System.out.println("foo"); 
    } 
} 
class Too2{ 
    public Integer fun(String s){ 
        return 1; 
    } 
    public void foo(){ 
        System.out.println("foo---too2"); 
    } 
 
    public void show(String str){ 
        System.out.println("show ---too2"+str); 
    } 
}

7.5 構造方法引用

構造方法引用：如果函數式接口的實現恰好可以通過調用一個類的構造方法來實現，那么就可以使用構造方法引用

/** @Author mxn 
 * @Description //TODO 構造方法引用 
 * @Date 14:27 2020/11/7 
 * @Param  
 * @return  
 **/ 
public class Test5 { 
    public static void main(String[] args) { 
        Supplier<Person> s1 = ()->new Person(); 
        s1.get();//輸出 調用無參的構造方法 
        Supplier<Person> s2 = Person::new; 
        s2.get();//輸出 調用無參的構造方法 
 
        Supplier<List> s3 = ArrayList::new; 
        Supplier<Set> s4 = HashSet::new; 
        Supplier<Thread> s5 = Thread::new; 
        Supplier<String> s6 = String::new; 
 
        Consumer<Integer> c1 = (age)->new Account(age); 
        Consumer<Integer> c2 = Account::new; 
        c1.accept(123);// 輸出 age 參數構造123 
        c2.accept(456);//輸出 age 參數構造456 
 
        Function<String,Account> f1 = (str)->new Account(str); 
        Function<String,Account> f2 = Account::new; 
        f1.apply("abc");//輸出 str 參數構造abc 
        f2.apply("def");//輸出 str 參數構造def 
 
    } 
} 
 
class Account{ 
    public Account(){ 
        System.out.println("調用無參構造方法"); 
    } 
 
    public Account(int age){ 
        System.out.println("age 參數構造" +age); 
    } 
 
    public Account(String str){ 
        System.out.println("str 參數構造" +str); 
    } 
} 
 
class Person{ 
    public Person(){ 
        System.out.println("調用無參的構造方法"); 
    } 
}

八、小結

Java8 引入 Lambda表達式是接收了函數式編程語言的思想，和指令式編程相比，函數式編程強調函數的計算比指令的執行重要。引入 Lambda表達式是接收了函數式編程語言的思想，和指令式編程相比，函數式編程強調函數的計算比指令的執行重要。引入 Lambda表達式是接收了函數式編程語言的思想，和指令式編程相比，函數式編程強調函數的計算比指令的執行重要。
lambda表達式可以使代碼看起來簡潔，但一定程度上增加了代碼的可讀性以及調試的復雜性，所以在使用時應盡量是團隊都熟悉使用，要么干脆就別用，不然維護起來是件較痛苦的事，今天的小知識就到這里了，有問題的小伙伴可以在下方進行留言，大家加油!

責任編輯：姜華來源：牧小農