一、案例引入
案例需求：
- 创建一个集合，存储多个姓名字符串元素；
- 把集合中所有以“张”开头的元素存储到一个新的集合；
- 把上述集合中长度为3的元素存储到一个新的集合；
- 遍历后打印上一步得到的集合
传统方法：
public class StreamDemo {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//把集合中所有以"张"开头的元素存储到一个新的集合
ArrayList<String> zhangList = new ArrayList<String>();
for(String s : list) {
if(s.startsWith("张")) {
zhangList.add(s);
}
}
// System.out.println(zhangList);
//把"张"开头的集合中的长度为3的元素存储到一个新的集合
ArrayList<String> threeList = new ArrayList<String>();
for(String s : zhangList) {
if(s.length() == 3) {
threeList.add(s);
}
}
// System.out.println(threeList);
//遍历上一步得到的集合
for(String s : threeList) {
System.out.println(s);
}
}
}Stream改进后：
public class StreamDemo {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//Stream流来改进
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
}
}二、Stream流概述
（一）Stream流思想
（二）Stream流的三类方法
1、获取Stream流
创建一条流水线，把数据放到流水线上准备对其进行操作
2、中间方法
流水线上对数据进行操作，一次操作完后还可以继续对其进行操作
3、终结方法
一系列中间方法操作完成后的最后一个操作，一个Stream流只能有一个终结方法
三、Stream流的生成
1、Collection体系集合
使用默认方法stream()生成流：default Stream<E> stream()
2、Map体系集合
把Map转成Set集合，间接生成流
3、数组
通过Arrays中的静态方法stream生成流
4、同种数据类型的多个数据
通过Stream接口的静态方法of（T…values）
示例：
public class StreamDemo {
public static void main(String[] args) {
//Collection体系的集合可以使用默认方法stream()生成流
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
//Map体系的集合间接的生成流
Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
//数组可以通过Arrays中的静态方法stream生成流
String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Arrays.stream(strArray);
//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);
}
}四、Stream流中间操作方法
中间操作代表执行该操作后依然可以继续执行其他操作。
常见方法
| 方法名 | 说明 |
| Stream<T> filter(Predicate predicate) | 用于对流中的数据进行过滤 |
| Stream<T> limit(long maxSize) | 返回此流中的元素组成的流，截取前指定参数个数的数据 |
| Stream<T> skip(long n) | 跳过指定参数个数的数据，返回由该流的剩余元素组成的流 |
| static <T> Stream<T> concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
| Stream<T> distinct() | 返回由该流的不同元素（根据Object.equals(Object) ）组成的流 |
filter示例：
//需求1：把list集合中以张开头的元素在控制台输出
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
//需求2：把list集合中长度为3的元素在控制台输出
list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
//需求3：把list集合中以张开头的，长度为3的元素在控制台输出
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);limit&skip示例：
//需求1：取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("--------");
//需求2：跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(System.out::println);
System.out.println("--------");
//需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(System.out::println);concat&distinct示例：
//需求1：取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//需求2：跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
Stream.concat(s1,s2).forEach(System.out::println);
//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);五、Stream流终结操作方法
执行完此方法之后,Stream流将不能再执行其他操作。
常见方法
| 方法名 | 说明 |
| void forEach(Consumer action) | 对此流的每个元素执行操作 |
| long count() | 返回此流中的元素数 |
示例：
//需求1：把集合中的元素在控制台输出
list.stream().forEach(System.out::println);
//需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
long count = list.stream().filter(s -> s.startsWith("张")).count();
System.out.println(count);六、Stream流的收集操作
对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。
1、常用方法
| 方法名 | 说明 |
| R collect(Collector collector) | 把结果收集到集合中 |
2、工具类Collectors提供的具体收集方法
| 方法名 | 说明 |
| public static <T> Collector toList() | 把元素收集到List集合中 |
| public static <T> Collector toSet() | 把元素收集到Set集合中 |
| public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
Collector toList示例：
//需求1：得到名字为3个字的流
Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
//需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
List<String> names = listStream.collect(Collectors.toList());
for(String name : names) {
System.out.println(name);
}Collector toSet示例：
//需求3：得到年龄大于25的流
Stream<Integer> setStream = set.stream().filter(age -> age > 25);
//需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
Set<Integer> ages = setStream.collect(Collectors.toSet());
for(Integer age : ages) {
System.out.println(age);
}Collector toMap示例：
//需求5：得到字符串中年龄数据大于28的流
Stream<String> arrayStream = Stream.of(strArray).filter(s ->
Integer.parseInt(s.split(",")[1]) > 28);
//需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")
[0], s -> Integer.parseInt(s.split(",")[1])));
Set<String> keySet = map.keySet();
for (String key : keySet) {
Integer value = map.get(key);
System.out.println(key + "," + value);
}七、总结
1、Stream基于函数式编程思想，使用 Stream 流可以让开发者以一种更简洁、更易读的方式表达数据处理的逻辑，对一个整数集合进行过滤、映射和求和操作；传统的方式可能需要使用多个循环和中间变量，而使用 Stream 流可以在一条语句中完成。
2、中间操作会返回一个新的 Stream 流，允许进行链式操作。
3、Stream 流可以很方便地实现并行处理，以充分利用多核处理器的优势，提高程序的执行效率。
4、传统的集合遍历通常使用for循环或者迭代器，而 Stream 流提供了更简洁的forEach方法来遍历集合。
5、通过map、flatMap等操作可以方便地对集合中的元素进行转换。通过reduce、collect等操作可以实现数据的聚合。例如使用collect方法将流中的元素收集到一个新的集合中。