Stream流相关方法

流创建

1.转换成流：对于集合，可以使用集合类中的stream()方法或者parallelStream()方法将集合转换成流。
2.创建流：
给定n个元素产生流

static <T> Stream<T> of(T ...values)
Stream<String> ofTest = Stream.of("123", "kkk", "msn");

OR

String[] arr = {"give", "me", "five"};
Stream<String> ofTest = Stream.of(arr);

使用Arrays.stream()

static <T> Stream<T> stream(T[] array, int from, int to)
Stream<String> arraysTest = Arrays.stream(arr, 0 ,2);
//print结果:arraysTest:s,sad

产生一个空流

static <T> Stream<T> empty()
Stream<String> emptyTest() = Stream.empty();

产生无限流

static <T> Stream<T> generate(Suplier<T> s)
Stream<String> echos = Stream.generate(() -> "Echo");

产生无限流2，这个方法以第一个参数作为开头，第二个参数作为操作函数

static <T> Stream<T> iterator(T seed, UnaryOperator<T>f)
Stream<BigInteger> integers = Stream.iterate(BigInteger.ONE, n->n.multiply(BigInteger.TWO));

Stream<String> stringIterator = Stream.iterate("give", n -> n+"me");
//print出来结果为：integers:1,2,4,8,16,32,64,128,256,512,...
//stringIterator:give,giveme,givememe,givemememe,...

Pattern产生流,String

Stream<String> splitAsStream(CharSequence input)
Stream<String> patternTest = Pattern.compile("\\PL+").splitAsStream("give8me8five");
//print:give,me,five

文件流,String

static Stream<String> lines(Path path) //cs默认utf-8
static Stream<String> lines(Path path, Charset cs)
Stream<String> filesTest = Files.lines(path,StandardCharset.UTF_8);

流转换

filter:只包含当前流中满足断言条件的元素

Stream<T> filter(Predicate <? super T> predicate)
long count = words.stream().filter(w -> w.length() > 6).count();

map:流中的元素一对一操作

<R> Stream<R> map(Function<? super T, ? extends R> mapper)
Stream<String> patternTest = Stream<String> patternTest = Pattern.compile("\\PL+").splitAsStream("give8me8five").map(String::toUpperCase);

flatMap：扁平化

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
 List<String> teamEngland = Arrays.asList("Alex", "Bell", "Broad");
 List<String> teamNewZeland = Arrays.asList("Kane", "Nathan", "Vettori");
 List<List<String>> players = new ArrayList<>();
 players.add(teamEngland);
 players.add(teamNewZeland);
 Stream<String> flatMapPlayers = players.stream()
                                       .flatMap(pList -> pList.stream());
 Stream<String> flatMapPlayers2 = teamEngland.stream().map(word -> word.split("")).flatMap(Arrays::stream);
//print结果：flatMapTest:Alex,Bell,Broad,Kane,Nathan,Vettori
				     flatMapTest2:A,l,e,x,B,e,l,l,B,r,...

抽取流，链接流：
limit：包含前maxSize个元素
skip：跳过前n
concat：将流b放在流a后面

Stream<T> limit(long maxSize)
Stream<T> skip(long n)
Stream<T> concat(Stream<? extends T>a, Stream<? extends T> b)

Optional

具体学习链接
https://www.oschina.net/translate/understanding-accepting-and-leveraging-optional-in?lang=chs&page=2#

使用约简操作会产生Optional对象
分别产生这个流的最大元素和最小元素，使用由给定比较器定义的排序规则，如果这个流为空，会产生一个空的Optional对象。终结操作

Optional< T > max(Comparator< ? super T > comparator) 
Optional< T > min (Comparator< ? super T > comparator) 

分别产生这个流的第一个和任意一个元素，如果这个流为空，会产生一个空的Optional对象。终结操作

 Optional< T > findFirst()
 Optional< T > findAny()

flatMap也可以产生Optional对象

其他终结操作

java.util.stream.Stream8

void forEach(Consumer<? super T> action)
flatMapPlayers.forEach(System.out::println);
//print结果：
Alex
Bell
Broad
Kane
Nathan
Vettori

Object[] toArray()
Object[] s1 = flatMapPlayers.toArray();

<A> A[] toArray(intFunction<A[]> generator)
String[] s2 = flatMapPlayers.toArray(String[]::new);

<R,A>R collect(Collector<? super T,A,R> collector)
//将结果收集到集合

收集流至集合

使用Collectors.*

Supplier, Consumer