Java 8 Guide E3

/ 技术笔记 / 0 条评论 / 241浏览

本篇接着上篇来, 继续学习java8新特性
Java 8 简明教程

Stream 介绍

Stream (流) 操作算是对集合的大大增强, 很多之前很复杂需要很多代码量的逻辑在此终结.

  1. 一个Collection(集合)可以通过调用 stream()parallelStream() 两个方法获得 stream
  1. 流的操作分为 中间操作终止操作

中间操作

Filter

Stream<T> filter(Predicate<? super T> predicate);

Filter接收一个 Predicate<? super T> 接口的参数进行过滤操作

Sorted

Stream<T> sorted(Comparator<? super T> comparator);  
Stream<T> sorted();

sorted()方法自然排序. 即调用对象本身的compareTo()方法排序.
sorted(Comparator<? super T> comparator); 接受一个 Comparator对象进行排序

Map

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
IntStream mapToInt(ToIntFunction<? super T> mapper);
LongStream mapToLong(ToLongFunction<? super T> mapper);
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
<U> Stream<U> mapToObj(IntFunction<? extends U> mapper);

map有上述几个方法, 可以转换为指定的类型, 方法参数都是接受一个 xxxFunction 的转换器. 下面有一个演示.

list.stream()
        .filter(s -> s.startsWith("1"))
        .sorted(String::compareTo)
        .mapToInt(Integer::valueOf)
        .mapToObj(String::valueOf)
        .mapToLong(Long::valueOf);

终止操作

Match

boolean anyMatch(Predicate<? super T> predicate);
boolean allMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);

Match方法有三个, 都接受一个 Predicate 条件来决定返回true or false

Count

long count();

count()计算集合大小, 这个方法很简单.

Reduce

有了Map, 那肯定是有Reduce, 不过Reduce是一个终止操作. 它接收一个 xxxOperator 的操作函数.

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);
T reduce(T identity, BinaryOperator<T> accumulator);
Optional<T> reduce(BinaryOperator<T> accumulator);

下面有一个操作的演示.

list.stream()
        .sorted((s1, s2) -> s1.compareTo(s2) > 0 ? -1 : 0)
        .reduce((i, j) -> i + "#" + j)
        .ifPresent(System.out::println);

System.out.println("---------------------------");
final String join = "#";
String joinReduce = list.stream()
        .reduce(join, (s1, s2) -> s1 + join + s2);
System.out.println(joinReduce);

所有操作的代码

public static void main(String[] args) {

    ArrayList <String> list = new ArrayList <>();
    list.add("11");
    list.add("12");
    list.add("13");
    list.add("14");

    Comparator<String> comparator = String::compareTo;
    Predicate<String> predicate = s -> s.startsWith("1");
    IntUnaryOperator intUnaryOperator = i -> i + 1;
    ToIntFunction<String> toIntFunction = Integer::valueOf;
    IntConsumer consumer = System.out::println;

    list.stream()
            .filter(predicate)
            .sorted(comparator)
            .mapToInt(toIntFunction)
            .map(intUnaryOperator)
            .forEach(consumer);


    boolean anyMatch = list.stream()
            .filter(s -> s.startsWith("1"))
            .sorted(String::compareTo)
            .mapToInt(Integer::valueOf)
            .mapToObj(String::valueOf)
            .mapToLong(Long::valueOf)
            .anyMatch(i -> i > 10);
    System.out.println(anyMatch);

    long count = list.stream().count();
    System.out.println(count);

    list.stream()
            .sorted((s1, s2) -> s1.compareTo(s2) > 0 ? -1 : 0)
            .reduce((i, j) -> i + "#" + j)
            .ifPresent(System.out::println);

    System.out.println("---------------------------");
    final String join = "#";
    String joinReduce = list.stream()
            .reduce(join, (s1, s2) -> s1 + join + s2);
    System.out.println(joinReduce);

}