JDK8新特性-lambda表达式

什么是lambda表达式

“Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。

将一个变量传入一个匿名函数然后对传入函数进行操作。由于java中并没有脱离类而存在的函数，所以通常独立函数是以一个匿名内部类+一个方法构成的。lambda表达式代替的函数既没有方法名也没有访问修饰符、明确的返回类型声明。

Lambda 表达式的语法

Lambda 表达式需要“函数式接口”的支持

函数式接口

接口中只有一个抽象方法的接口，称为函数式接口。可以使用注解 @FunctionalInterface 修饰可以检查是否是函数式接口

注意：并不是 Lambda 只能给函数式接口使用，而是函数式接口是为 Lambda 而生的。函数式接口就是为 Lambda 定义类型的，你不能用除了函数式接口之外的东西来为 Lambda 定义类型。

Lambda 表达式的基础语法

Java8中引入了一个新的操作符 “->” 该操作符称为箭头操作符或 Lambda 操作符。

箭头操作符将 Lambda 表达式拆分成两部分

左侧：Lambda 表达式的参数列表
右侧：Lambda 表达式中所需执行的功能，即 Lambda 体

语法格式一

无参数，无返回值

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

语法格式二

有一个参数，并且无返回值

(x) -> System.out.println(x)

语法格式三

若只有一个参数，小括号可以省略不写

x -> System.out.println(x)

语法格式四

有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

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

语法格式五

若 Lambda 体中只有一条语句， return 和大括号都可以省略不写

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

语法格式六

Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

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

Lambda 表达式的语法的使用

遍历

LIST

原始的代码

List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d", "e"));
for (String str : list) {
   System.out.println(str);
}

Lambda 表达式

 List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d", "e"));
//使用Lambda 表达式
 list.forEach(str-> System.out.println(str));

MAP

原始代码

Map<String, String> map = new HashMap<String, String>() {{
          put("11", ":11");
          put("22", ":22");
          put("33", ":33");
          put("44", ":44");
      }};
//打印 key+value
      for(Map.Entry<String,String> m:map.entrySet()){
          System.out.println(m.getKey()+m.getValue());
      }

Lambda 表达式

//使用Lambda 更简单
 map.forEach((k, v) -> System.out.println(k + v));

匿名内部类

public class LambdaTest {

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest();
        //原始关键代码进行回调并返回值
        /*int num = lambdaTest.invok(new CallBack() {
            @Override
            public int call(int x, int y) {
                return x + y;
            }
        });*/
       // ------------------------------
        //使用Lambda 更简单更简洁
        int num = lambdaTest.invok((x, y) -> x + y);
        System.out.println(num);
    }

    /**
     * 调用方法
     *
     * @param callBack
     * @return
     */
    public int invok(CallBack callBack) {
        System.out.println("方法执行前");
        int num = callBack.call(1, 2);
        System.out.println("方法执行后");
        return num;
    }

    /**
     * 匿名内部类
     */
    interface CallBack {
        public int call(int x, int y);
    }
}

Java 线程创建

//普通方式创建线程
    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是普通线程");
        }
    });

    // Lambda表达式创建线程
    Thread thread2 = new Thread(() -> System.out.println("我是Lambda线程"));

thread1.start();
    thread2.start();

排序

String[] stringArrays = {"Rafael Nadal", "Novak Djokovic",
                "Stanislas Wawrinka", "David Ferrer",
                "Roger Federer", "Andy Murray",
                "Tomas Berdych", "Juan Martin Del Potro",
                "Richard Gasquet", "John Isner"};

        // 使用匿名内部类根据 name 排序 stringArrays
        Arrays.sort(stringArrays, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1.compareTo(s2));
            }
        });

        //使用Lambda 表达式进行排序
        Arrays.sort(stringArrays,(x,y)->x.compareTo(y));