java8函数式接口，以及stream流中map、peek、foreach区别

java8常用函数式接口

import java.util.function.Supplier;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;

• Supplier

@FunctionalInterface
public interface Supplier<T> {
    
     T get(); // 无参，有返
}

• Consumer

@FunctionalInterface
public interface Consumer<T> {
    
    void accept(T t);   // 有参，无返
    // 默认方法
}

• Function

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);  // 有参，有返
     // 默认方法、static方法
}

• BiConsumer

@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u);
    // 默认方法
}

• BiFunction

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);
    // 默认方法
}

• Predicate

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
     // 默认方法
}

// Bi开头的，BiConsumer和 BiFunction，都至少接受两个参数。而Consumer和 Function都是一个参数。

java8常用stream API

• filter

stream().filter(Predicate p); 要求传入 Predicate，有参数，且返回布尔值，并生成原类型的stream流。

• map

stream().map(Function mapper); 要求传入Function, 有参数，有返回值。 map会对每一个元素映射为另一个返回值，并生成新类型的stream流。

• peek

stream().peek(Consumer action); 要求传入Consumer，有参数，无返回值。 peek会操作每一个元素，但返回原来的流。

• forEach

stream().forEach(Consumer action)；要求传入Consumer，有参数，无返回值。但forEach不再返回流了，是一个流结束函数。

• collect

stream().collect(); 有两个重载方法参数列表，都不再返回流，而是返回某种集合类型。

    <R> R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);
    <R, A> R collect(Collector collector); 
    // Collector接口中，也规范了supplier(),accumulator(),combiner()方法，本质和上面差不多

• toMap

stream().collect(Collectors.toMap());
Collectors.toMap(), 有三个重载方法参数列表

// 两个Function类型参数 key，value, 实际上是去调用另一个重载方法，throwingMerger()：当key相同时，会抛出异常；
Collector toMap(Function keyMapper, Function valueMapper) {
        return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
}
// 两个Function类型参数 key，value + 一个父类为BiFunction的mergeFunction，BiFunction接收两个参数，聚合后一个返回值：当key相同时，如何合并。
Collector toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) {
        return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}
// 实际上他们都是调用四个参数的重载方法，对传入的mergeFunction，也是使用java.util.Map中的merge方法来合并
Collector toMap(Function keyMapper,Function valueMapper,BinaryOperator mergeFunction,Supplier<M> mapSupplier) {
        BiConsumer accumulator = (map, element) -> map.merge(keyMapper.apply(element),  valueMapper.apply(element), mergeFunction);
        return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
}

• 其他stream流常用API
  stream().distinct()
  stream().count()
  stream().sorted()
  stream().findFirst()
  stream().findAny()
  stream().anyMatch()
  stream().allMatch()
  stream().noneMatch()
  stream().max()
  stream().min()
  .stream().toArray(IntFunction<A[]> generator) // 返回指定类型的数组 A[] toArray(IntFunction<A[]> generator)

Optional中filter、map、ifPresent

• map

Optional.ofNullable(customer).map(Function mapper)

在Optional中，map也是要求传入Function，有参数，有返回值，map返回一个新类型的Optional，

• filter

Optional.ofNullable(customer).filter(Predicate p)

filter也是要求传入 Predicate，有参数，且返回布尔值，返回原类型的Optional，

• ifPresent

Optional.ofNullable(customer).ifPresent(Consumer action);

而ifPresent与forEach类似，要求传入Consumer，有参数，无返回值，且结束后不再返回Optional，结束这个Optional。

Runnable、Closeable 也是函数式接口

（无参数，无返回值）

• Runnable

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

• Closeable

public interface Closeable extends AutoCloseable {
    public void close() throws IOException;
}

匿名内部类

在不熟悉Runnable、Function、Consumer、BiFunction、BiConsumer区别时，可以new Runnable()并按提示生成匿名内部类
例如：

 new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello word！");
    }
});

再按提示转成lambda，但明确这几项函数式接口的参数和返回值后，可以直接写lambda

直接写lambda表达式

• Runnable: 无参数，无返回值。直接写出lambda：

  ()->{System.out.println("hello word！");} 

方法体只有一行省略掉大括号：()->System.out.println(“hello word！”)

• Predicate：有参数，需要返回值（布尔）。直接写出lambda：

  (e)->{return e.getId() > 0;}

参数只有一个可以省略括号，方法体加返回只有一行又可以省略大括号和return关键字：e-> e.getId() > 0

• Function：有参数，有返回值。直接写出lambda：

  (e)->{return e.getId();}

参数只有一个可以省略括号，方法体加返回只有一行又可以省略大括号和return关键字：e->e.getId()

e是上一步函数的返回值作为当前函数参数，又可省略到参数声明，方法引用：Customer::getId

• Consumer：有参数，无返回值。直接写出lambda：

  (e)->{system.out.println(e);}

参数只有一个可以省略括号，但方法体只有一行又可以省略大括号：e->System.out.println(e)

e是上一步函数的返回值作为当前函数参数并又作为参数传入sout，又可省略到参数声明，方法引用：System.out::println

• BiConsumer：有两个参数，无返回值。直接写出lambda：

  (k1, k2)->{System.out.println(k1 + k2);}

参数大于1不能省略小括号，但方法体只有一行又可以省略大括号：(k1, k2)->System.out.println(k1 + k2)

• BiFunction：有两个参数，有返回值。直接写出lambda：

  (k1, k2)->{return k1 + k2;}

参数大于1不能省略小括号，但方法体加返回只有一行又可以省略大括号和return关键字：(k1, k2)->k1 + k2