Java Stream 详解

前年年底的时候我写了一些关于Java 8 Lambda和Stream的文章，本文应该在那个时候完成。后来忙于项目和写《Scala集合技术手册》(Scala Collections Cookbook)这本书，一直没来得及写Java Stream的文章，现在这篇文章算是对 Java Stream的一个总结吧。

介绍

本节翻译整理自 Javadoc ，并对流的这些特性做了进一步的解释。

List<String> l = new ArrayList(Arrays.asList("one", "two"));Stream<String> sl = l.stream();sl.forEach(s -> l.add("three"));

List<String> l = new ArrayList(Arrays.asList("one", "two"));Stream<String> sl = l.stream();l.add("three");sl.forEach(System.out::println);

List<String> l = new CopyOnWriteArrayList<>(Arrays.asList("one", "two"));Stream<String> sl = l.stream();sl.forEach(s -> l.add("three"));

List<String> l = new ArrayList(Arrays.asList("one", "two", ……));class State {    boolean s;}final State state = new State();Stream<String> sl = l.stream().map(e -> {    if (state.s)        return "OK";    else {        state.s = true;        return e;    } });sl.forEach(System.out::println);

ArrayList<String> results = new ArrayList<>();stream.filter(s -> pattern.matcher(s).matches())      .forEach(s -> results.add(s));  // 副作用代码

List<String>results =    stream.filter(s -> pattern.matcher(s).matches())          .collect(Collectors.toList());  // No side-effects!

(a op b) op c == a op (b op c)

a op b op c op d == (a op b) op (c op d)

1、通过集合的stream()方法或者parallelStream()，比如Arrays.asList(1,2,3).stream()。

2、通过Arrays.stream(Object[])方法, 比如Arrays.stream(new int[]{1,2,3})。

3、使用流的静态方法，比如Stream.of(Object[]),IntStream.range(int, int)或者Stream.iterate(Object, UnaryOperator)，如Stream.iterate(0, n -> n * 2)，或者generate(Supplier<T> s)如Stream.generate(Math::random)。

4、BufferedReader.lines()从文件中获得行的流。

5、Files类的操作路径的方法，如list、find、walk等。

6、随机数流Random.ints()。

7、其它一些类提供了创建流的方法，如BitSet.stream(),Pattern.splitAsStream(java.lang.CharSequence), 和JarFile.stream()。

8、更底层的使用StreamSupport，它提供了将Spliterator转换成流的方法。

List<String> l = Stream.of("a","b","c","b")        .distinct()        .collect(Collectors.toList());System.out.println(l); //[a, b, c]

List<Integer> l = IntStream.range(1,10)        .filter( i -> i % 2 == 0)        .boxed()        .collect(Collectors.toList());System.out.println(l); //[2, 4, 6, 8]

List<Integer> l = Stream.of('a','b','c')        .map( c -> c.hashCode())        .collect(Collectors.toList());System.out.println(l); //[97, 98, 99]

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

String poetry = "Where, before me, are the ages that have gone?\n" +        "And where, behind me, are the coming generations?\n" +        "I think of heaven and earth, without limit, without end,\n" +        "And I am all alone and my tears fall down.";Stream<String> lines = Arrays.stream(poetry.split("\n"));Stream<String> words = lines.flatMap(line -> Arrays.stream(line.split(" ")));List<String> l = words.map( w -> {    if (w.endsWith(",") || w.endsWith(".") || w.endsWith("?"))        return w.substring(0,w.length() -1).trim().toLowerCase();    else        return w.trim().toLowerCase();}).distinct().sorted().collect(Collectors.toList());System.out.println(l); //[ages, all, alone, am, and, are, before, behind, coming, down, earth, end, fall, generations, gone, have, heaven, i, limit, me, my, of, tears, that, the, think, where, without]

List<Integer> l = IntStream.range(1,100).limit(5)        .boxed()        .collect(Collectors.toList());System.out.println(l);//[1, 2, 3, 4, 5]

String[] arr = new String[]{"a","b","c","d"};Arrays.stream(arr)        .peek(System.out::println) //a,b,c,d        .count();

String[] arr = new String[]{"b_123","c+342","b#632","d_123"};List<String> l  = Arrays.stream(arr)        .sorted((s1,s2) -> {            if (s1.charAt(0) == s2.charAt(0))                return s1.substring(2).compareTo(s2.substring(2));            else                return s1.charAt(0) - s2.charAt(0);        })        .collect(Collectors.toList());System.out.println(l); //[b_123, b#632, c+342, d_123]

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

这一组方法用来检查流中的元素是否满足断言。

allMatch只有在所有的元素都满足断言时才返回true,否则flase,流为空时总是返回true

anyMatch只有在任意一个元素满足断言时就返回true,否则flase,

noneMatch只有在所有的元素都不满足断言时才返回true,否则flase,

System.out.println(Stream.of(1,2,3,4,5).allMatch( i -> i > 0)); //true      System.out.println(Stream.of(1,2,3,4,5).anyMatch( i -> i > 0)); //true      System.out.println(Stream.of(1,2,3,4,5).noneMatch( i -> i > 0)); //falseSystem.out.println(Stream.<Integer>empty().allMatch( i -> i > 0)); //true      System.out.println(Stream.<Integer>empty().anyMatch( i -> i > 0)); //false      System.out.println(Stream.<Integer>empty().noneMatch( i -> i > 0)); //true

mapToLong(e -> 1L).sum();

<R,A> R  collect(Collector<? super T,A,R> collector)<R> R  collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

R result = supplier.get();for (T element : this stream)    accumulator.accept(result, element);return result;

List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,                                           ArrayList::addAll);String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,                                     StringBuilder::append)                            .toString();

Stream.of(1,2,3,4,5).forEach(System.out::println);

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

Optional<Integer> total = Stream.of(1,2,3,4,5).reduce( (x, y) -> x +y);Integer total2 = Stream.of(1,2,3,4,5).reduce(0, (x, y) -> x +y);

public static <T> Stream<T>  concat(Stream<? extends T> a, Stream<? extends T> b)

public static <T,C extends Collection<T>> Collector<T,?,C>  toCollection(Supplier<C> collectionFactory)public static ……  toConcurrentMap(……)public static <T> Collector<T,?,List<T>>  toList()public static ……  toMap(……)public static <T> Collector<T,?,Set<T>>  toSet()