导读：
概括讲，可以将Stream流操作分为3种类型：
- 创建Stream --开始管道
- Stream中间处理 --中间管道
- 终止Steam --终止管道
每个Stream管道操作类型都包含若干API方法，先列举下各个API方法的功能介绍。
- 开始管道
主要负责新建一个Stream流，或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流。
| API | 功能说明 |
|---|---|
| stream() | 创建出一个新的stream串行流对象 |
| parallelStream() | 创建出一个可并行执行的stream流对象 |
| Stream.of() | 通过给定的一系列元素创建一个新的Stream串行流对象 |
- 中间管道
负责对Stream进行处理操作，并返回一个新的Stream对象，中间管道操作可以进行叠加。
| API | 功能说明 |
|---|---|
| filter() | 按照条件过滤符合要求的元素， 返回新的stream流 |
| map() | 将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流 |
| flatMap() | 将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为1个或者多个新类型的元素，返回新的stream流 |
| limit() | 仅保留集合前面指定个数的元素，返回新的stream流 |
| skip() | 跳过集合前面指定个数的元素，返回新的stream流 |
| concat() | 将两个流的数据合并起来为1个新的流，返回新的stream流 |
| distinct() | 对Stream中所有元素进行去重，返回新的stream流 |
| sorted() | 对stream中所有的元素按照指定规则进行排序，返回新的stream流 |
| peek() | 对stream流中的每个元素进行逐个遍历处理，返回处理后的stream流 |
- 终止管道
顾名思义，通过终止管道操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。
| API | 功能说明 |
|---|---|
| count() | 返回stream处理后最终的元素个数 |
| max() | 返回stream处理后的元素最大值 |
| min() | 返回stream处理后的元素最小值 |
| findFirst() | 找到第一个符合条件的元素时则终止流处理 |
| findAny() | 找到任何一个符合条件的元素时则退出流处理，这个对于串行流时与findFirst相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑 |
| anyMatch() | 返回一个boolean值，类似于isContains(),用于判断是否有符合条件的元素 |
| allMatch() | 返回一个boolean值，用于判断是否所有元素都符合条件 |
| noneMatch() | 返回一个boolean值， 用于判断是否所有元素都不符合条件 |
| collect() | 将流转换为指定的类型，通过Collectors进行指定 |
| toArray() | 将流转换为数组 |
| iterator() | 将流转换为Iterator对象 |
| foreach() | 无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑 |
举例练习：
package com.wei.demo01;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@SpringBootTest
class DemoApplicationTests {
/**
* stream foreach 遍历流
*/
@Test
public void test1(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi");
st.forEach(name -> System.out.println(name));
}
/**
* filter过滤流
*/
@Test
public void test2(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
Stream<String> z = st.filter(name -> name.startsWith("z") && name.length() == 3);
z.forEach(name-> System.out.println(name));
}
/**
* map map流 一对一转换
*/
@Test
public void test3(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
st.map(str -> str += str.toUpperCase()).forEach(str -> System.out.println(str));
}
/**
* count 统计流
* 相当于size 统计元素个数
* 返回long值
*/
@Test
public void test4(){
Stream<String> st = Stream.of("1", "2", "3", "4", "5", "6");
long ct = st.map(str -> Integer.parseInt(str))
.filter(str -> str >= 3)
.count();
System.out.println(ct);
}
/**
* limit 截取流
* 截取前几个，n=2,截取前两个打印
*/
@Test
public void test5(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
st.limit(3).forEach(str -> System.out.println(str));
}
/**
* skip 跳跳流
* 跳过前几个元素
*/
@Test
public void test6(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
st.skip(2).forEach(str -> System.out.println(str));
}
/**
* concat 合并流
* 把两个流合并起来
*/
@Test
public void test7(){
Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
Stream<String> st1 = Stream.of("1", "2", "3", "4", "5", "6");
Stream<String> concat = Stream.concat(st, st1);
concat.forEach(str -> System.out.println(str));
}
/**
* 问题是：从给定句子中返回单词长度大于5的单词列表，按长度倒序输出，最多返回3个
*
*
* * 【常规方式】
* * 从给定句子中返回单词长度大于5的单词列表，按长度倒序输出，最多返回3个
* *
* * @param sentence 给定的句子，约定非空，且单词之间仅由一个空格分隔
* * @return 倒序输出符合条件的单词列表
*
*/
public static List<String> test8(String juzi){
String[] words = juzi.split(" ");
List<String> list = new ArrayList<>();
for (String word:words
) {
if (word.length() > 5){
list.add(word);
}
}
list.sort((o1, o2) -> o2.length() - o1.length());
System.out.println(list);
if (list.size() > 3) {
list = list.subList(0, 3);
}
return list;
}
public static void main(String[] args) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long startTime = System.currentTimeMillis();
List<String> strings = test8("i love you so much amercian haahhahah zhognguo meiguo xiaoriben suoheng");
long endTime = System.currentTimeMillis();
long resultTime1 = endTime - startTime;
String format = simpleDateFormat.format(resultTime1);
System.out.println(format);
System.out.println(strings);
long startTime1 = System.currentTimeMillis();
List<String> strings1 = test9("i love you so much amercian haahhahah zhognguo meiguo xiaoriben suoheng");
long endTime2 = System.currentTimeMillis();
long resultTime = endTime2 - startTime1;
String format1 = simpleDateFormat.format(resultTime);
System.out.println(format1);
System.out.println(strings1);
}
/**
* 利用流的思想解决以上问题
*/
@Test
public static List<String> test9(String juzi){
return Arrays.stream(juzi.split(" "))
.filter(word -> word.length() > 5)
.sorted((o1, o2) -> o2.length() - o1.length())
.limit(3)
.collect(Collectors.toList());
}
/**
* flatMap是 一对多
* 从多层转向单层 就要用faltMap
* 单层到单层 一对一，就要用map
*/
@Test
public void stringToIntFlatmap() {
List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
// 使用流操作
List<String> results = sentences.stream()
.flatMap(sentence -> Arrays.stream(sentence.split(" ")))
.collect(Collectors.toList());
System.out.println(results);
}
}