java8常用内置函数的总结（代码示例）

常用的函数接口记录方便以后翻吧

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

1. 将现有数据结构转化成Stream

Stream<Integer> s = Stream.of(1, 2, 3, 4, 5); Stream<Integer> s = Arrays.stream(arr); Stream<Integer> s = aList.stream();

1. 通过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;     } }

1. 通过其他方法返回

Stream<String> lines = Files.lines(Path.get(filename)) ...

map方法

<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方法

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方法

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);

以上就是java8常用内置函数的总结（代码示例）的详细内容，更多内容请关注技术你好其它相关文章！