共计 4003 个字符，预计需要花费 11 分钟才能阅读完成。
常用的函数接口记录方便以后翻吧
接口
参数
返回类型
说明
Predicate<T>
T
boolean
输入某个值，输出 boolean 值，用于对某值进行判定
Consumer<T>
T
void
输入某值，无输出。用于消费某值
Function<T,R>
T
R
输入某类型值，输出另种类型值，用于类型转化等
Supplier<T>
None
T
无输入，输出某值，用于生产某值
UnaryOperator<T>
T
T
输入某类型值，输出同类型值，用于值的同类型转化，如对值进行四则运算等
BinaryOperator<T>
(T,T)
T
输入两个某类型值，输出一个同类型值，用于两值合并等
Predicates
Predicates 是包含一个参数的布尔值接口。其包括一些缺省方法，组合他们使用可以实现复杂的业务逻辑 (如：and, or, negate)。示例代码如下：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test(“foo”); // true
predicate.negate().test(“foo”); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
Functions
Functions 接口接收一个参数并产生一个结果。其缺省方法通常被用来链接多个功能一起使用 (compose, andThen)。
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply(“123”); // “123”
Suppliers
Suppliers 接口生成一个给定类型结果。和 Functions 不同，其没有接收参数。
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
Consumers
Consumers 表现执行带有单个输入参数的操作。
Consumer<Person> greeter = (p) -> System.out.println(“Hello, ” + p.firstName);
greeter.accept(new Person(“Luke”, “Skywalker”));
Comparators
Comparators 是从 java 旧版本升级并增加了一些缺省方法。
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person(“John”, “Doe”);
Person p2 = new Person(“Alice”, “Wonderland”);
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0
Stream 常用方法
创建 Stream
将现有数据结构转化成 Stream
Stream<Integer> s = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> s = Arrays.stream(arr);
Stream<Integer> s = aList.stream();
通过 Stream.generate() 方法：
// 这种方法通常表示无限序列
Stream<T> s = Stream.generate(SuppLier<T> s);
// 创建全体自然数的 Stream
class NatualSupplier implements Supplier<BigInteger> {
BigInteger next = BigInteger.ZERO;
@Override
public BigInteger get() {
next = next.add(BigInteger.ONE);
return next;
}
}
通过其他方法返回
Stream<String> lines = Files.lines(Path.get(filename))
…
map 方法
把一种操作运算映射到 Stream 的每一个元素上，从而完成一个 Stream 到另一个 Stream 的转换 map 方法接受的对象是 Function 接口，这个接口是一个函数式接口：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
@FunctionalInterface
public interface Function<T, R> {
// 将 T 转换为 R
R apply(T t);
}
使用：
// 获取 Stream 里每个数的平方的集合
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.map(n -> n * n).forEach(System.out::println);
flatMap
map 方法是一个一对一的映射，每输入一个数据也只会输出一个值。
flatMap 方法是一对多的映射，对每一个元素映射出来的仍旧是一个 Stream，然后会将这个子 Stream 的元素映射到父集合中：
Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
List<Integer> integerList = inputStream.flatMap((childList) -> childList.stream()).collect(Collectors.toList());
// 将一个“二维数组”flat 为“一维数组”
integerList.forEach(System.out::println);
filter 方法
filter 方法用于过滤 Stream 中的元素，并用符合条件的元素生成一个新的 Stream。filter 方法接受的参数是 Predicate 接口对象，这个接口是一个函数式接口：
Stream<T> filter(Predicate<? super T>) predicate;
@FunctionInterface
public interface Predicate<T> {
// 判断元素是否符合条件
boolean test(T t);
}
使用
// 获取当前 Stream 所有偶数的序列
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.filter(n -> n % 2 == 0).forEach(System.out::println);
limit、skip
limit 用于限制获取多少个结果，与数据库中的 limit 作用类似，skip 用于排除前多少个结果。
sorted
sorted 函数需要传入一个实现 Comparator 函数式接口的对象，该接口的抽象方法 compare 接收两个参数并返回一个整型值，作用就是排序，与其他常见排序方法一致。
distinct
distinct 用于剔除重复，与数据库中的 distinct 用法一致。
findFirst
findFirst 方法总是返回第一个元素，如果没有则返回空，它的返回值类型是 Optional<T> 类型，接触过 swift 的同学应该知道，这是一个可选类型，如果有第一个元素则 Optional 类型中保存的有值，如果没有第一个元素则该类型为空。
Stream<User> stream = users.stream();
Optional<String> userID = stream.filter(User::isVip).sorted((t1, t2) -> t2.getBalance() – t1.getBalance()).limit(3).map(User::getUserID).findFirst();
userID.ifPresent(uid -> System.out.println(“Exists”));
min、max
min 可以对整型流求最小值，返回 OptionalInt。
max 可以对整型流求最大值，返回 OptionalInt。
这两个方法是结束操作，只能调用一次。
allMatch、anyMatch、noneMatch
allMatch：Stream 中全部元素符合传入的 predicate 返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate 返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate 返回 true
reduce 方法
reduce 方法将一个 Stream 的每一个元素一次作用于 BiFunction，并将结果合并。reduce 方法接受的方法是 BinaryOperator 接口对象。
Optional<T> reduce(BinaryOperator<T> accumulator);
@FuncationalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
// Bi 操作，两个输入，一个输出
T apply(T t, T u);
}
使用：
// 求当前 Stream 累乘的结果
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
int r = ns.reduce((x, y) -> x * y ).get();
System.out.println(r);
