JDK8特性深刻学习笔记-Lambda表达式（1）

什么是Lambda表达式

在编程语言中，lambda指的是一种运算符，用来表示：

• closures(闭包)
• anonymous functions（匿名函数）

旧的语法经过传递数据来完成，而Lambda表达式更注重于行为。在java中，Lambda表达式是个对象，它们必须依附于一类特别的对象类型 —— 函数式接口（functional interface）

为何须要Lambda表达式

• 在java中，咱们没法将函数做为参数传递的方法，也没法声明返回一个函数的方法。
• javascript中，函数参数是一个函数，返回值是另外一个函数的状况是很是常见的。

Lamdba表达式的做用

• 传递行为，而不单单是值

  • 提高抽象层次
  • API重用性更好
  • 更加灵活

Lambda表达式的基本结构

(type1 arg1, type2 arg2, ..., typeN argN) -> { body }

• Lambda示例

  • (int a, int b) -> {return a + b;}
  • () -> System.out.println("Hello World");
  • (String s) -> {System.out.println(s);}
  • () -> 42
  • () -> {return 4};
• 一个Lambda表达式能够有零个或多个参数
• 参数类型能够明确声明，也可让编译器经过上下文推断。例如：(int a) 与 (a) 效果相同
• 全部参数须要包含在圆括号内，参数之间用逗号相隔。例如：（a, b）或（int a, int b）或 (String a, int b, double c)
• 圆空括号表示参数集合为空。例如() -> 42
• 当只有一个参数，且其类型能够推断时，圆括号()能够省略。例如： a -> return a*a
• Lambda表达式的主题可包含零条或多条语句
• 若是Lambda表达式的主题只有一条语句，花括号{}能够省略。匿名函数的返回类型与该主体表达式一致。
• 若是Lambda表达式的主题包含一条以上的语句，则表达式必须包含在花括号{}中（造成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空。

函数式接口

经过Lambda表达式遍历集合

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

list.forEach(new Consumer<Integer>(){
    @Override
    public void accept(Integer integer){
        System.out.println(integer);
    }
});

Consumer接口

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

关于函数式接口 注解

@FunctionalInterface：凡是接口上带上这个注解，即为函数式接口。一个函数式接口有且只有一个精确的抽象方法。函数式接口的实例能够经过Lamdba表达式的方法引用或构造方法引用来去建立。
若是使用了@FunctionalInterface注解，但却不知足如下两个条件，编译器会返回编译异常：

• 这个类型必须是Interface接口类型
• 这个注解类型必须知足函数式接口的要求：一个函数式接口有且只有一个精确的抽象方法

若是这个抽象方法复写了或者重写了Object类里的public方法，那么这个接口也不属于函数式接口。由于java的任意实现，必定都会有一个来自java.lang.Object的实现。

@FunctionalInterface
public interface MyInterface{
    // 抽象方法
    void test();
    // Object的抽象方法
    String toString();
}

toString()是Object的抽象方法，因此编译器认为MyInterface依然是一个函数式接口。

public class UsingFunctionInterface{
    public void myUsingInterface(MyInterface interface){
        System.out.println("start");
        interface.test();
        System.out.println("end");
    }

    public static void main(String[] args){
        UsingFunctionInterface u = new UsingFunctionInterface();

        // 写法1
        u.myUsingInterface(() -> {
             System.out.println("test print");
        });

        //写法2
        MyInterface myInterface = () -> {
             System.out.println("test print");
        };

        u.myUsingInterface(myInterface);
    }
}

Lamdba表达式弱化了抽象方法名的意义，将方法实现（即->右边的部分，直接做为函数式接口的实现）。

关于函数式接口的特色

• 若是一个接口只有一个抽象方法，那么这个接口就是函数式接口
• 若是咱们在某个接口上声明了@FunctionalInterface，那么编译器就会按照函数式接口的定义来要求该接口
• 若是某个接口只有一个抽象方法，但咱们并无给该接口声明@FunctionalInterface，那么编译器依旧会将该接口看做是函数式接口。
• 函数式接口的实例，能够经过Lamdba表达式、方法的实例、构造方法的实例来建立。

上述的总结：@FunctionalInterface只是帮助编译器检查函数式接口是否合法。

若是一个接口须要用做函数式接口，那么最好加上 @FunctionalInterface。

foreach方法

list.foreach()

foreach的实现

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

foreach最特殊的就是用了default关键字。jdk1.8后，接口里也能够有方法实现。一旦在接口中使用了default关键字作方法的实现，称之为默认方法(default Method)。
默认方法的出现一方面保证了jdk8的新特性的加入，另外一方面保证了jdk8能够向上兼容。

Consumer

Consumer是一个操做，这个操做接受一个单个的输入元素，而且不返回结果。与其余函数式接口不一样的是，它可能会修改接收到的操做。
Consumer的语义是消费者，因此顾名思义，这个类中的抽象方法void accept(T t)的语义为：接受一个类，并将其消费掉，并不关心结果

迭代

外部迭代：指的是利用外部的迭代器，对一个集合进行迭代。
内部迭代：经过集合自己，利用Lambda表达式进行迭代。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
// 外部迭代
for(Integer i : numbers){
    System.out.println(i);
}
// 内部迭代 ： 函数式接口
numbers.forEach(new Consumer<Integer>{
    public void accept(){
        System.out.println(i);
    }
});
// 内部迭代： 函数式接口 + Lambda表达式
numbers.forEach(i -> System.out.println(i) )
// 内部迭代： 方法引用
numbers.forEach(System.out::println)

使用stream作迭代

stream的实现

default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

stream是在Collection接口的默认方法，返回一个串行流。
当spliterator（分割迭代器）方法不能返回一个分割迭代器时（不可变的、延迟的、并发的分割迭代器），stream方法须要被重写。

stream中的map()

<R> Stream<R> map(Function<? super T, ? extends R> mapper); ,map自己的含义是映射，将一个给定的元素映射为另外一个元素并返回一个新的Stream。

List<String> list = Arrays.asList("a", "b", "c");
List<String> list2 = new ArrayList<>();
// Lamdba表达式实现
list.stream().map(i -> i.toUpperCase()).forEach(i -> list2.add(i));
// 方法引用实现
list.stream().map(String::toUpperCase).forEach(list2::add);