0-优质博客

Lambda表达式的理解

1. 概述

Lambda表达式，也可称为闭包。类似于JavaScript中的闭包，它是推动Java8发布的最重要的新特性。

2. 示例

我们可以把Lambda表达式理解为一段可以传递的代码（将代码像数据一样进行传递）。Lambda允许把函数作为一个方法的参数，使用Lambda表达式可以写出更简洁、更灵活的代码，而其作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

  1. public class LambdaDemo {
  2.     /**
  3.      * 成员内部类
  4.      */
  5.     class MyThread01 implements Runnable{
  6.         @Override
  7.         public void run() {
  8.             System.out.println("成员内部类：用Lambda语法创建线程吧!");
  9.         }
  10.     }
  12.     /**
  13.      * 静态内部类
  14.      */
  15.     static class MyThread02 implements Runnable{
  16.         @Override
  17.         public void run() {
  18.             System.out.println("静态内部类：对啊，用Lambda语法创建线程吧!");
  19.         }
  20.     }
  22.     public static void main(String[] args) {
  24.         /**
  25.          * 局部内部类
  26.          */
  27.         class MyThread03 implements Runnable{
  28.             @Override
  29.             public void run() {
  30.                 System.out.println("局部内部类：用Lambda语法创建线程吧!");
  31.             }
  32.         }
  34.         /**
  35.          * 匿名内部类
  36.          */
  37.         Runnable runnable = new Runnable(){
  39.             @Override
  40.             public void run() {
  41.                 System.out.println("匿名内部类：求求你，用Lambda语法创建线程吧!");
  42.             }
  43.         };
  44.         //成员内部类方式
  45.         LambdaDemo lambdaDemo = new LambdaDemo();
  46.         MyThread01 myThread01 =lambdaDemo.new MyThread01();
  47.         new Thread(myThread01).start();
  48.         //静态内部类方式
  49.         MyThread02 myThread02 = new MyThread02();
  50.         new Thread(myThread02).start();
  51.         //局部内部类
  52.         MyThread03 myThread03 = new MyThread03();
  53.         new Thread(myThread03).start();
  54.         //匿名内部类的方式
  55.         new Thread(runnable).start();
  56.     }
  57. }
  1. new Thread(() -> System.out.println("使用Lambda就对了")).start();

3. 语法

  1. (parameters) -> expression
  2. 或
  3. (parameters) ->{ statements; }
  5. 1.可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  6. 2.可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  7. 3.可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  8. 4.可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
  1. @Test
  2. public void test01(){
  3.     Runnable runnable=()-> System.out.println("Runnable 运行");
  4.     runnable.run();//结果：Runnable 运行
  5. }
  1. @Test
  2. public void test02(){
  3.     Consumer<String> consumer=(x)-> System.out.println(x);
  4.     consumer.accept("Hello Consumer");//结果：Hello Consumer
  5. }
  1. public void test03(){
  2.     Consumer<String> consumer=x-> System.out.println(x);
  3.     consumer.accept("Hello Consumer");//结果：Hello Consumer
  4. }
  1. @Test
  2. public void test04(){
  3.     Comparator<Integer> com=(x, y)->{
  4.         System.out.println("函数式接口");
  5.         return Integer.compare(x,y);
  6.     };
  7.     System.out.println(com.compare(2,4));//结果：-1
  8. }
  1. @Test
  2. public void test05(){
  3.     Comparator<Integer> com=(x, y)-> Integer.compare(x,y);
  4.     System.out.println(com.compare(4,2));//结果：1
  5. }
  1. @Test
  2. public void test06(){
  3.     Comparator<Integer> com=(Integer x, Integer y)-> Integer.compare(x,y);
  4.     System.out.println(com.compare(4,2));//结果：1
  5. }