Java8新特性 Lambda表达式

Lambda表达式

一、函数式接口

1. 定义

• 只包含一个抽象方法的接口，称为函数式接口

• 可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口

2. 举例

(1) JDK中的函数式接口

(2) 自定义函数式接口

二、Lambda表达式的使用

1. 介绍

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）

2. 举例

@Test
public void test(){
    //匿名实现类的方式
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }
    };

    //Lambda表达式的写法
    Comparator<Integer> com2 = (Integer o1, Integer o2) -> Integer.compare(o1,o2);

    //二者效果一模一样
}

3. 格式

(Integer o1, Integer o2) -> Integer.compare(o1,o2);

• **-> **称为 lambda操作符 或 箭头操作符
• 箭头左边：lambda形参列表，其实就是函数式接口中的抽象方法的形参列表
• 箭头右边：lambda体，其实就是重写的抽象方法的方法体

4. 使用

• Lambda表达式的本质：作为函数式接口的实例，即Lambda表达式必须作用在函数式接口的基础上
• 以前用匿名实现类表示的现在都可以用Lambda表达式来写

(1) 无参、无返回值

@Test
public void test(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("周杰伦");
        }
    };

    //对应的Lambda表达式
    Runnable r2 = () -> {
        System.out.println("周杰伦");
    };
}

(2) 有参、有返回值

@Test
public void test(){
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    };

    //对应的Lambda表达式
    Comparator<Integer> com2 = (o1,o2) -> {
        return o1.compareTo(o2);
    };
}

(3) 其余注意事项

• 箭头左边的参数列表的数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

• 箭头左边的参数列表若只需要一个参数时，小括号可以省略

• 箭头右边的 Lambda体 只有一条语句时，大括号可以省略

• 箭头右边的 Lambda体 只有一条return语句时，若省略了大括号，return关键字也必须省略

  @Test
  public void test(){
      //匿名实现类的方式
      Comparator<Integer> com1 = new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
              return Integer.compare(o1,o2);
          }
      };
      
      //对应的Lambda表达式
      Comparator<Integer> com1 = (Integer o1, Integer o2) -> {
          return o1.compareTo(o2);
      };
  
      //更简化的Lambda表达式
      Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
  }
  

三、Java内置函数式接口

在 java.util.function 包下定义了 Java 8 的丰富的函数式接口

1. 四大核心函数式接口

(1) 测试消费型接口

//1. 定义方法
public void happyTime(double money, Consumer<Double> con){
    con.accept(money);
}

@Test
public void test1(){
    //2. 调用方法
    happyTime(500, new Consumer<Double>() {
        @Override
        public void accept(Double aDouble) {
            System.out.println("money值为：" + aDouble);
            //money值为：500.0
        }
    });

    //3. 对应的Lambda表达式
    happyTime(400, money -> System.out.println("money值为：" + money));
    //money值为：400.0
}

(2) 测试断定型接口

//1. 定义方法
//根据给定的规则，过滤集合中的字符串，此规则由断定型接口Predicate的方法决定
public List<String> filterString(List<String> list, Predicate<String> pre) {

    ArrayList<String> filterList = new ArrayList<>();

    for(String s : list){
        if(pre.test(s)){
            filterList.add(s);
        }
    }

    return filterList;
}

@Test
public void test2(){
    List<String> list = Arrays.asList("夏季", "春季", "冬天");

    //2. 调用方法
    List<String> filterStrs = filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.contains("季");
        }
    });

    //3. 对应的Lambda表达式
    List<String> filterStrs1 = filterString(list,s -> s.contains("季"));

    System.out.println(filterStrs1); //[夏季, 春季]
}

2. 其他函数式接口