一,当我们使用stream的时候,需要包括如下的三个步骤.
简单说，对 Stream 的使用就是实现一个 filter-map-reduce 过程，产生一个最终结果，或者导致一个副作用（side effect）。
获取一个数据源（source）→ 数据转换→执行操作获取想要的结果
二,有多种方式生成 Stream Source
从 Collection 和数组
Collection.stream()
Collection.parallelStream()
Arrays.stream(T array) or Stream.of()
从 BufferedReader
java.io.BufferedReader.lines()
静态工厂
java.util.stream.IntStream.range()
java.nio.file.Files.walk()
自己构建
java.util.Spliterator
其它
Random.ints()
BitSet.stream()
Pattern.splitAsStream(java.lang.CharSequence)
JarFile.stream()
三,流的操作类型分为两种
Intermediate:namely,中间过渡操作,可以有多个.如下的都属于此种类型:
map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
Terminal:namely,终端操作,只有一个.如下的都属于此种类型:
forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
Short-circuiting：(短路)
{还有一种操作被称为 short-circuiting。用以指：
对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。
当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。}
anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
四,流的构造与转换
1,构造流的几种常见方法
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
2,数值流的构造
IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);
3,流转换为其它数据结构
// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
五,java.util.function 中
Function的使用
该接口有两个方法,如下所示:
// 1,Compute the result of applying the function to the input argument
R
apply(T t)
// 2,Combine with another function returning a function which performs both functions.
default <V> Function<T,V>
compose(Function<? super R,? extends V> after)
static void modifyTheValue(int valueToBeOperated,Function<Integer, Integer> function){
int newValue = function.apply(valueToBeOperated);
System.out.println(newValue);
}
public static void main(String[]args){
int valueToBeOper=20;
int incr=2;
new Demo3().modifyTheValue(valueToBeOper,p->p+incr);
}
//运行结果是 22
Supplier 接口的使用.
里面只有这么一个方法:
T get();
举栗子:
public void method2(){
Random seed=new Random();
Supplier<Integer> ran= seed::nextInt;
Stream.generate(ran).limit(10).forEach(System.out::println);
}
运行结果:
-730632575
-1501251296
-296435633
1018244280
-1996563966
-864662929
-501794018
1316711404
-346781493
-907325722
六,用 Collectors 来进行 reduction 操作
java.util.stream.Collectors 类的主要作用就是辅助进行各类有用的 reduction 操作，例如转变输出为 Collection，把 Stream 元素进行归组。
groupingBy/partitioningBy //分组,分成几个部分
如下是举栗子
public void method7(){
Map<Integer,List<People>> peopleGroups=Stream.generate(new PersonSupplier()).limit(100).collect(Collectors.groupingBy(People::getAge));
Iterator iterator=peopleGroups.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<Integer,List<People>> integerListEntry=(Map.Entry)iterator.next();
System.out.println("Age:"+integerListEntry.getKey()+"="+integerListEntry.getValue().size());
}
}
运行结果如下:
Age:67=1
Age:51=1
Age:84=1
Age:54=1
Age:38=1
Age:73=1
Age:91=1
Age:77=1
Age:30=1
Age:78=1
public void method8(){
Map<Boolean,List<People>> children=Stream.generate(new PersonSupplier()).limit(100).collect(Collectors.partitioningBy(p->p.getAge()<18));
System.out.println("Children` number is :"+children.get(true).size());
System.out.println("Adult`s number is :"+children.get(false).size());
}
运行结果如下:
Children` number is :21
Adult`s number is :79
七,java.util.stream 中的Stream接口的说明.
A sequence of elements supporting sequential and parallel aggregate operations.
namely,该接口的功能是:对元素支持序列和并发的聚合操作
如下是我们常用到的一些方法:
1,boolean
allMatch(Predicate<? super T> predicate) //Returns whether all elements of this stream match the provided predicate.
2,boolean
anyMatch(Predicate<? super T> predicate) //Returns whether any elements of this stream match the provided predicate.
3,static <T> Stream.Builder<T>
builder() //Returns a builder for a Stream.
4,<R,A> R
collect(Collector<? super T,A,R> collector) //Performs a mutable reduction operation on the elements of this stream using a Collector.
5,static <T> Stream<T>
concat(Stream<? extends T> a, Stream<? extends T> b)
//Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
6,long
count() //Returns the count of elements in this stream.
7,Stream<T>
distinct() //Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.
8,static <T> Stream<T>
empty() //Returns an empty sequential Stream.
9,Stream<T>
filter(Predicate<? super T> predicate) //Returns a stream consisting of the elements of this stream that match the given predicate.
10,Optional<T>
findAny() //Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
11,Optional<T>
findFirst() //Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty.
12,<R> Stream<R>
flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
//Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
13,DoubleStream
flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
//Returns an DoubleStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
14,IntStream
flatMapToInt(Function<? super T,? extends IntStream> mapper)
//Returns an IntStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
15,LongStream
flatMapToLong(Function<? super T,? extends LongStream> mapper)
//Returns an LongStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
16,void
forEach(Consumer<? super T> action) //Performs an action for each element of this stream.
17,void
forEachOrdered(Consumer<? super T> action)
Performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order.
18,static <T> Stream<T>
generate(Supplier<T> s)
Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.
19,static <T> Stream<T>
iterate(T seed, UnaryOperator<T> f)
//Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
20,Stream<T>
limit(long maxSize) //Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
21,<R> Stream<R>
map(Function<? super T,? extends R> mapper) //Returns a stream consisting of the results of applying the given function to the elements of this stream.
22,DoubleStream
mapToDouble(ToDoubleFunction<? super T> mapper) //Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
23,IntStream
mapToInt(ToIntFunction<? super T> mapper) //Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
24,LongStream
mapToLong(ToLongFunction<? super T> mapper) //Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
25,Optional<T>
max(Comparator<? super T> comparator) //Returns the maximum element of this stream according to the provided Comparator.
26,Optional<T>
min(Comparator<? super T> comparator) //Returns the minimum element of this stream according to the provided Comparator.
27,boolean
noneMatch(Predicate<? super T> predicate) Returns whether no elements of this stream match the provided predicate.
28,static <T> Stream<T>
of(T... values) //Returns a sequential ordered stream whose elements are the specified values.
29,static <T> Stream<T>
of(T t) //Returns a sequential Stream containing a single element.
30,Stream<T>
peek(Consumer<? super T> action)
//Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
31,Stream<T>
skip(long n) //Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
32,Stream<T>
sorted() //Returns a stream consisting of the elements of this stream, sorted according to natural order.
33,Stream<T>
sorted(Comparator<? super T> comparator) //Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.
34,Object[]
toArray() //Returns an array containing the elements of this stream.
八,java.util.stream 中的Collectors 类.
常用的方法:
1,toSet() //Returns a Collector that accumulates the input elements into a new Set.
2,toList() //Returns a Collector that accumulates the input elements into a new List.
3,toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
//Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
4,toCollection(Supplier<C> collectionFactory)
//Returns a Collector that accumulates the input elements into a new Collection, in encounter order.
5,partitioningBy(Predicate<? super T> predicate)
//Returns a Collector which partitions the input elements according to a Predicate, and organizes them into a Map<Boolean, List<T>>.
6,maxBy(Comparator<? super T> comparator) //Returns a Collector that produces the maximal element according to a given Comparator, described as an Optional<T>.
7,static <T> Collector<T,?,Optional<T>>
minBy(Comparator<? super T> comparator)
//Returns a Collector that produces the minimal element according to a given Comparator, described as an Optional<T>.
8,joining() //Returns a Collector that concatenates the input elements into a String, in encounter order.
9,groupingBy(Function<? super T,? extends K> classifier)
//Returns a Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function, and returning the results in a Map.
10,counting()
Returns a Collector accepting elements of type T that counts the number of input elements.
九,java.util.function包中的 Predicate 类.
Static utility methods pertaining to Predicate instances. namely,一些与或非异或等的操作集合.
常用的方法如下:
1,static <T> Predicate<T>
and(Iterable<? extends Predicate<? super T>> predicates)
//Returns a predicate that evaluates to true if all of the component predicates evaluate to true.
2,static <T> Predicate<T>
and(Predicate<? super T>... predicates)
//Returns a predicate that evaluates to true if all of the component predicates evaluate to true.
3,static <T> Predicate<T>
isEqual(Object target)
//Returns a predicate who's result matches Objects.equals(target, t).
4,static <T> Predicate<T>
isSame(Object target)
//Returns a predicate that who's result is target == object.
5,static <T> Predicate<T>
or(Iterable<? extends Predicate<? super T>> predicates)
//Returns a predicate that evaluates to true if any of the component predicates evaluate to true.
6,static <T> Predicate<T>
or(Predicate<? super T>... predicates)
//Returns a predicate that evaluates to true if any of the component predicates evaluate to true.
7,static <T> Predicate<T>
xor(Iterable<? extends Predicate<? super T>> predicates)
//Returns a predicate that evaluates to false if all or none of the component predicates evaluate to true.
8,static <T> Predicate<T>
xor(Predicate<? super T>... predicates)
//Returns a predicate that evaluates to false if all or none of the component predicates evaluate to true.
十,在java.util.function包中的接口 Consumer中,
An operation which accepts a single input argument and returns no result. Unlike most other functional interfaces, Consumer is expected to operate via side-effects.
namely,接受单个参数,不会返回结果.
1,void
accept(T t) //Accept an input value.
2,default Consumer<T>
chain(Consumer<? super T> other) //Returns a Consumer which performs in sequence the apply methods of multiple Consumers.
附:
flatMap的一个很好的例子:
List<String> output = reader.lines().
flatMap(line -> Stream.of(line.split(REGEXP))).
filter(word -> word.length() > 0).
collect(Collectors.toList());
