java8--lambda

一、lambda概述

1、函数式接口：接口中只有一个需要被实现的抽象函数

2、函数式接口注解：@FunctionalInterface 表示这个接口是一个函数式接口。为了避免后来的人在接口中增加新的接口函数，导致其有多个接口函数需要被实现，变成非函数式接口。

3、lambda表达式本质是匿名方法

4、Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

二、lambda表达式语法

2.1、lambda表达式结构

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ ->”，该操作符被称为 Lambda 操作符或

箭头操作符。

它将 Lambda 分为两个部分：

左侧： 指定了 Lambda 表达式需要的方法参数列表

右侧： 指定了 Lambda 体，即 Lambda 表达式要执行的功能。

2.2、lambda表达式使用说明

（1）一个 Lambda 表达式可以有零个或多个参数，参数的类型既可以明确声明，也可以根据上下文来推断

（2）圆括号内，方法参数列表之间用逗号相隔

（3）当只有一个参数，且其类型可推导时，圆括号（）可省略

（4）Lambda 表达式的主体可包含零条或多条语句，如果 Lambda 表达式的主体只有一条语句，花括号{}可省略，如果有返回值，return也可以省略。匿名函数的返回类型与该主体表达式一致

（5）如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与

代码块的返回类型一致，若没有返回则为空

三、lambda表达式使用实例

  

   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import org.junit.Test;
     
    
   

    

     

    
    

     

      import org.omg.CORBA.CODESET_INCOMPATIBLE;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import java.io.InputStream;
     
    
   

    

     

    
    

     

      import java.lang.annotation.Annotation;
     
    
   

    

     

    
    

     

      import java.util.Comparator;
     
    
   

    

     

    
    

     

      import java.util.function.Consumer;
     
    
   

    

     

    
    

     

      import java.util.function.Function;
     
    
   

    

     

    
    

     

      import java.util.function.Supplier;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      public class Demo1{
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    @Test
     
    
   

    

     

    
    

     
    public void testConsumer(){
     
    
   

    

     

    
    

     

      // 原始写法
     
    
   

    

     

    
    

     

              Consumer<String> consumer = new Consumer<String>() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public void accept(String s) {
     
    
   

    

     

    
    

     

                      System.out.println(s);
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              };
     
    
   

    

     

    
    

     

      // lambda第一种写法
     
    
   

    

     

    
    

     

              Consumer<String> consumer1 = s -> System.out.println(s);
     
    
   

    

     

    
    

     

      // lambda第二种写法
     
    
   

    

     

    
    

     

              Consumer<String> consumer2 = System.out::println;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      // 调用lambda函数式编程的方法
     
    
   

    

     

    
    

     

              consumer2.accept("helle");
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    @Test
     
    
   

    

     

    
    

     
    public void test2(){
     
    
   

    

     

    
    

     

      // 原始写法
     
    
   

    

     

    
    

     

              Supplier<String> supplier = new Supplier<String>() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public String get() {
     
    
   

    

     

    
    

     
                return "Hello";
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              };
     
    
   

    

     

    
    

     

      // lambda写法
     
    
   

    

     

    
    

     

              Supplier<String> supplier1 = ()->"hello";
     
    
   

    

     

    
    

     

      // 调用lambda函数式编程的方法
     
    
   

    

     

    
    

     

              supplier1.get();
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    @Test
     
    
   

    

     

    
    

     
    public void test3() {
     
    
   

    

     

    
    

     
        // 原始写法
     
    
   

    

     

    
    

     

              Function<String, Integer> func = new Function<String, Integer>() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public Integer apply(String s) {
     
    
   

    

     

    
    

     
                return s.length();
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              };
     
    
   

    

     

    
    

     

      // 第一种lambda写法
     
    
   

    

     

    
    

     

              Function<String,Integer> func2 = s -> s.length();
     
    
   

    

     

    
    

     

      // 第二种lambda写法
     
    
   

    

     

    
    

     

              Function<String,Integer> fun3 = String::length;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    @Test
     
    
   

    

     

    
    

     
    public void test4(){
     
    
   

    

     

    
    

     

      // 原始写法
     
    
   

    

     

    
    

     

              Comparator<Integer> comparator = new Comparator<Integer>() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public int compare(Integer o1, Integer o2) {
     
    
   

    

     

    
    

     
                return Integer.compare(o1,o2);
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              };
     
    
   

    

     

    
    

     

      // lambda第一种写法
     
    
   

    

     

    
    

     

              Comparator<Integer> comparator1 = (o1,o2)-> Integer.compare(o1,o2);
     
    
   

    

     

    
    

     

      // lambda第二种写法
     
    
   

    

     

    
    

     

              Comparator<Integer> comparator2 = Integer::compare;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    @Test
     
    
   

    

     

    
    

     
    public void test5(){
     
    
   

    

     

    
    

     

      // 原始写法
     
    
   

    

     

    
    

     

              Comparator<String> comparator = new Comparator<String>() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public int compare(String o1, String o2) {
     
    
   

    

     

    
    

     
                return o1.length()>o2.length() ? 1:-1;
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              };
     
    
   

    

     

    
    

     

      // lambda写法
     
    
   

    

     

    
    

     

              Comparator<String> comparator1 = (str1,str2)-> str1.length()>str2.length()?1:-1;
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          }
     
    
  
 

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/96874860