java8中Lambda表达式详解及函数式接口介绍

博客地址：http://www.pipima.top/

Lambda表达式

作为Java8 中最重要的新功能，使用 Lambda 表达式可以避免使用匿名内部类，代码看起来更简洁易懂。Lambda表达式还支持对集合、框架的迭代、遍历、过滤数据的操作

Lambda表达式特点

1. 函数式编程
2. 参数类型自动推断
3. 代码量少，简洁

Lambda表达式使用场景

任何有函数式接口的地方

函数式接口

只有一个抽象方法（Object类中的方法除外）的接口是函数式接口

主要函数式接口

Supplier 代表一个输出

Consumer 代表一个输入
BiConsumer 代表两个输入

Function 代表一个输入，一个输出（一般输入和输出是不同类型的）
UnaryOperator 代表一个输入，一个输出（输入和输出是相同类型的）

BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的）
BinaryOperator 代表两个输入，一个输出（输入和输出是相同类型的）

Lamdba表达式语法

args -> expr
或者
(Object… args) -> {函数式接口抽象方法实现逻辑}

()里面参数的个数，根据函数式接口里面抽象方法的参数个数来决定。

当只有一个参数的时候，()可以省略

当expr逻辑非常简单的时候，{}和return可以省略

Lambda表达式示例

() -> {}                             // 无参，无返回值
() -> { System.out.println(1); }   // 无参，无返回值
() -> System.out.println(1) // 无参，无返回值（上面的简写）
() -> { return 100; }      // 无参，有返回值
() -> 100                        // 无参，有返回值（上面的简写）
() -> null                       // 无参，有返回值（返回null）
(int x) -> { return x+1; }  // 单个参数，有返回值
(int x) -> x+1                // 单个参数，有返回值（上面的简写）
(x) -> x+1                  // 单个参数，有返回值（不指定参数类型，多个参数必须用括号）
x -> x+1                     // 单个参数，有返回值（不指定参数类型）

注意事项

(x, int y) -> x+y   
(x, final y) -> x+y 
Object obj = () -> “hello”   
Object obj = (Supplier<?>)() -> "hello"
不需要也不允许使用throws语句来声明它可能会抛出的异常

Lambda表达式

1. 看参数
2. 看返回值

demo

import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author mapp
 * @des
 * @date 2019/3/5
 */
public class App {
    static int get() {
        return 500;
    }
    public static void main(String[] args) throws Exception {
        Runnable r1 = () -> {
            System.out.println("1");
        };
        r1.run();

        Callable<String> c1 = () -> "1";
        System.out.println(c1.call());
        Supplier<String> s = () -> "1";
        System.out.println(s.get());
        // 一个输入，一个输出
        Function<Integer, String> f1 = (a) -> {return String.valueOf(a);};
        System.out.println(f1.apply(100));;
        // 两个输入，一个输出
        BiFunction<String, String, Integer> f2 = (a, b) -> a.length() + b.length();
        System.out.println(f2.apply("hello", "world"));
        UserMapper userMapper = (user) -> System.out.println("User");
        userMapper.insert(new User());

        Foo foo = () -> 200;
        Foo foo1 = () -> get();
        System.out.println(foo.get());
        System.out.println(foo1.get());
    }
}

//自定义一个函数式接口 FunctionalInterface:标注为该接口是一个函数式接口 可以使用lambda表达式
@FunctionalInterface
interface UserMapper {
    void insert(User user);
}
class User {
}
interface Foo {
    int get();
}
```### Lambda表达式
lambda表达式是 Java8 中最重要的新功能之一。使用 Lambda 表达式可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作
<!--more-->

### Lambda表达式特点
1. 函数式编程
2. 参数类型自动推断
3. 代码量少，简洁

### Lambda表达式使用场景
任何有函数式接口的地方

### 函数式接口
只有一个抽象方法（Object类中的方法除外）的接口是函数式接口

### 主要函数式接口
```java
Supplier 代表一个输出

Consumer 代表一个输入
BiConsumer 代表两个输入

Function 代表一个输入，一个输出（一般输入和输出是不同类型的）
UnaryOperator 代表一个输入，一个输出（输入和输出是相同类型的）

BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的）
BinaryOperator 代表两个输入，一个输出（输入和输出是相同类型的）

Lamdba表达式语法

args -> expr
或者
(Object… args) -> {函数式接口抽象方法实现逻辑}

()里面参数的个数，根据函数式接口里面抽象方法的参数个数来决定。

当只有一个参数的时候，()可以省略

当expr逻辑非常简单的时候，{}和return可以省略

Lambda表达式示例

() -> {}                             // 无参，无返回值
() -> { System.out.println(1); }   // 无参，无返回值
() -> System.out.println(1) // 无参，无返回值（上面的简写）
() -> { return 100; }      // 无参，有返回值
() -> 100                        // 无参，有返回值（上面的简写）
() -> null                       // 无参，有返回值（返回null）
(int x) -> { return x+1; }  // 单个参数，有返回值
(int x) -> x+1                // 单个参数，有返回值（上面的简写）
(x) -> x+1                  // 单个参数，有返回值（不指定参数类型，多个参数必须用括号）
x -> x+1                     // 单个参数，有返回值（不指定参数类型）

注意事项

(x, int y) -> x+y   
(x, final y) -> x+y 
Object obj = () -> “hello”   
Object obj = (Supplier<?>)() -> "hello"
不需要也不允许使用throws语句来声明它可能会抛出的异常

Lambda表达式

1. 看参数
2. 看返回值

demo

import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author mapp
 * @des
 * @date 2019/3/5
 */
public class App {
    static int get() {
        return 500;
    }
    public static void main(String[] args) throws Exception {
        Runnable r1 = () -> {
            System.out.println("1");
        };
        r1.run();

        Callable<String> c1 = () -> "1";
        System.out.println(c1.call());
        Supplier<String> s = () -> "1";
        System.out.println(s.get());
        // 一个输入，一个输出
        Function<Integer, String> f1 = (a) -> {return String.valueOf(a);};
        System.out.println(f1.apply(100));;
        // 两个输入，一个输出
        BiFunction<String, String, Integer> f2 = (a, b) -> a.length() + b.length();
        System.out.println(f2.apply("hello", "world"));
        UserMapper userMapper = (user) -> System.out.println("User");
        userMapper.insert(new User());

        Foo foo = () -> 200;
        Foo foo1 = () -> get();
        System.out.println(foo.get());
        System.out.println(foo1.get());
    }
}

//自定义一个函数式接口 FunctionalInterface:标注为该接口是一个函数式接口 可以使用lambda表达式
@FunctionalInterface
interface UserMapper {
    void insert(User user);
}
class User {
}
interface Foo {
    int get();
}