Java8 01 Lambda

1、Lambda表达式概述

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

2、Lambda表达式语法

⑴ 操作符

->

该操作符称为Lambda操作符或箭头操作符，它将Lambda分为两个部分：
左半部分：Lambda表达式所需要的参数
右半部分：Lambda表达式要执行的功能(方法体)

⑵ 语法格式

① 无参数，无返回值

() -> System.out.println(“Hello Lambda！”);

② 需要一个参数

(i) -> System.out.println(i);
或
i -> System.out.println(i);【省略了小括号】

③ 需要两个参数，有返回值

(x, y) -> {return null;};

④ 执行语句只有一条，可以省略大括号

() -> System.out.println(“Hi”);
或
() -> {System.out.println(“Hi”);};

⑤ 类型推断

(x, y) -> {System.out.println(x + y);};
或
(int x, int y) -> {System.out.println(x + y);};

    由于参数类型都是由编译器推断得出的，所以在Lambda表达式中无需指定类型，程序依然可以正常被编译
    因为javac会根据程序的上下文，在后台推断出了参数的类型
    Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的，这就是“类型推断”

3、函数式接口

⑴ 概念

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

⑵ 使用场景

可以通过Lambda表达式来创建该接口对象

⑶ FunctionalInterface注解

    可以在函数式接口上使用@FunctionalInterface注解，这样可以检查它是否是一个函数式接口（有且仅有一个抽象方法，否则会报错）
    同时javadoc也会包含一条声明，用以说明该接口是一个函数式接口

4、JDK8提供的四大核心函数式接口

⑴ Consumer

Consumer<T>

消费型接口

抽象方法：
void accept(T t);
传递参数

示例：

 Consumer<String> consumer = (str) -> {System.out.println(str);};
 consumer.accept("Hello！");

⑵ Supplier

Supplier<T>

供给型接口

抽象方法：
T get();
返回值

示例：

Supplier<Integer> supplier = () -> {return 10;};
System.out.println(supplier.get());

⑶ Function

Function<T, R>

函数型接口

抽象方法：
R apply(T t);
传递参数，返回值

示例：

Function<Integer, String> function = (i) -> {return "参数是：" + i;};
System.out.println(function.apply(10));

⑷ Predicate

Predicate<T>

断言型接口

抽象方法：
boolean test(T t);
传递参数，返回判断的结果

示例：

 Predicate<Integer> predicate = (i) -> {return i >= 10;};
 System.out.println(predicate.test(10));

5、其他JDK8提供的函数式接口

⑴ BiFunction

BiFunction<T, U, R>

抽象方法：
R apply(T t, U u);
传递两个参数，返回值

示例：

  BiFunction<Integer, Integer, String> biFunction = (x, y) -> {return "结果为：" + (x + y);};
  System.out.println(biFunction.apply(1, 1));

⑵ UnaryOperator

UnaryOperator<T> extends Function<T, T>

抽象方法：
T apply(T t);
传递参数，返回相应类型的结果

示例：

  UnaryOperator<Integer> unaryOperator = (i) -> {return i + 9;};
  Integer result = unaryOperator.apply(1);
  System.out.println(result);

⑶ BinaryOperator

BinaryOperator<T> extends BiFunction<T,T,T>

抽象方法：
T apply(T t1, T t2);
传递两个相同类型的参数，返回相同类型的返回值

示例：

  BinaryOperator<Integer> biOperator = (x, y) -> {return x + y;};
  Integer result = biOperator.apply(1, 1);
  System.out.println(result);

⑷ BiConsumer

BiConsumer<T, U>

抽象方法：
void accept(T t, U u);
传递两个参数

示例：

  BiConsumer<String, Integer> biConsumer = (s, i) -> {System.out.println(s + i);};
  biConsumer.accept("结果是：",10);

⑸ ToIntFunction

ToIntFunction<T>

抽象方法：
int applyAsInt(T value);
传递参数，返回int类型返回值

示例：

  ToIntFunction<String> toIntFunction = (str) -> {
      try {
          return Integer.parseInt(str);
      } catch (NumberFormatException e) {
          return 0;
      }
  };
  int result = toIntFunction.applyAsInt("10a");
  System.out.println(result);

⑹ ToLongFunction

ToLongFunction<T>

抽象方法：
long applyAsLong(T value);
传递参数，返回long类型返回值

示例：

  ToLongFunction<Long> toLongFunction = (l) -> {return l;};
  long result = toLongFunction.applyAsLong(1L);
  System.out.println(result);

⑺ ToDoubleFunction

ToDoubleFunction<T>

抽象方法：
double applyAsDouble(T value);
传递参数，返回double类型返回值

示例：

  ToDoubleFunction<Double> toDoubleFunction = (d) -> {return Math.PI * d;};
  double result = toDoubleFunction.applyAsDouble(10D);
  System.out.println(result);

⑻ IntFunction

IntFunction<R>

抽象方法：
R apply(int value);
传递int类型参数，返回指定类型返回值

示例：

   IntFunction<String> inFunction = (i) -> {return  String.format("参数为：%d", i);};
   String result = inFunction.apply(10);
   System.out.println(result);

⑼ LongFunction

LongFunction<R>

抽象方法：
R apply(long value);
传递long类型参数，返回指定类型返回值

示例：

  LongFunction<String> longFunction = (l) -> {return String.valueOf(l);};
  String result = longFunction.apply(1L);
  System.out.println(result);

⑽ DoubleFunction

DoubleFunction<R>

抽象方法：
R apply(double value);
传递double类型参数，返回指定类型返回值

示例：

  DoubleFunction<Double> doubleFunction = (d) -> {return Math.E * d;};
  double result = doubleFunction.apply(10);
  System.out.println(result);

6、方法引用，构造引用和数组引用

⑴ 方法引用

⒈ 概念

如果传递给Lambda表达式的方法已经有实现了，则可以使用方法引用

⒉ 语法

使用操作符 :: 将对象名或类名与方法名分割开

三种情况：
对象(变量名)::实例方法名
类名::静态方法名
类名::实例方法名

⒊ 示例

① 对象::实例方法名

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

② 类名::静态方法名

  Integer::sum

   /**
     * @since 1.8
     */
    public static int sum(int a, int b) {
        return a + b;
    }

③ 类名::实例方法名

  String::compareTo

public int compareTo(String anotherString) {}

⑵ 构造引用

⒈ 概念

在创建对象的时候，可以通过构造引用来实现

⒉ 语法

类名::new

⒊ 示例

  Function<String, Person> person = Person::new;
    即
  Function<String, Person> function = (name) -> {return new Person(name);};

 【Person】
    public class Person {
        private String name;
        public Person(String name) {
            this.name = name;
        }
    }

⑶ 数组引用

⒈ 语法

    类型[]::new

⒉ 示例

    Function<Integer, String[]> array = String[]::new;
      即
    Function<Integer, String[]> function = (len) -> {return new String[len];};