java8--lambda

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;
    
    }