本文主要是介绍Java Stream流与使用操作指南，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
《JavaStream流与使用操作指南》Stream不是数据结构,而是一种高级的数据处理工具,允许你以声明式的方式处理数据集合,类似于SQL语句操作数据库,本文给大家介绍JavaStream流与使用...
一、什么是stream流
Java 8引入的Stream API是处理集合数据的一种全新方式，它代表了对数据元素序列进行函数式操作的抽象。Stream不是数据结构，而是一种高级的数据处理工具，允许你以声明式的方式处理数据集合，类似于SQL语句操作数据库。
Stream的核心特点：
- 声明式编程：只需说明"做什么"而非"如何做"，代码更简洁易读
- 函数式风格：与Lambda表达式完美结合，操作更灵活
- 管道操作：多个操作可以连接起来形成数据处理流水线
- 内部迭代：不同于集合的外部迭代(使用for-each)，Stream在内部处理迭代过程
- 延迟执行：中间操作不会立即执行，只有遇到终结操作才会触发计算
- 不可复用：一个Stream只能被消费一次
二、创建stream流
1.单列集合创建stream流
// 1.单列集合创建stream流
List<String> list = Arrays.asList("张三", "李四", "王五", "赵六", "钱七");
list.stream().forEach(e -> System.out.println("e = " + e));2.双列集合创建stream流
// 2.双列集合创建stream流
HashMap<String, Integer> map = new HashMap<>();
map.put("aaa", 111);
map.put("bbb", 222);
map.put("ccc", 333);
map.put("ddd", 444);
map.put("eee", 555);
// 遍历所有的key
map.keySet().stream().forEach(e -> System.out.println("e = " + e));
// 遍历所有的键值对
map.entrySet().stream().forEach(e -> System.out.println("e = " + e));
// 遍历所有的值
map.values().stream().forEach(e -> System.out.println("e = " + e));3.数组创建stream流
// 3.数组创建stream流
int[] array1 = {1, 2, 3};
String[] array2 = {"a", "b", "c"};
Arrays.stream(array1).forEach(e -> System.out.println("e = " + e));4.零散数据创建stream流
// 4.零散数据创建stream流
Stream.of(1, 2, 3, 4, 5).forEach(e -> System.out.println("e = " + e));
// stream接口中静态方法of的细节
// 方法的形参是一个可变参数，可以传递一堆零散的数据（同一类型），也可以传递数组
// 传递的数组必须是引用数据类型的，如果传递基本数据类型，会把数组当做一个元素
Stream.of(array1).forEach(e -> System.out.println("e = " + e)); // 结果[I@4dd8dc3
Stream.of(array2).forEach(e -> System.out.println("e = " + e));5.创建并行流
// 5.创建并行流
list.parallelStream().forEach(e -> System.out.println("e = " + e)); // 顺序会打乱6.创建无限流
// 6.创建无限流
Stream.generate(Math::random).limit(10).forEach(e -> System.out.println("e = " + e));
Stream.iterate(0, n -> n + 2).limit(10).forEach(e -> System.out.println("e = " + e));三、流的中间操作
中间操作返回一个新的Stream，可以链式调用多个中间操作。
注意点：
一、中间方法，返回新的stream流，原来的stream流只能使用一次，建议使用链式编程
二、修改stream流中的数据，不会影响原来集合或数组中的数据
1.过滤操作
// 1.过滤操作
// filter: 过滤元素
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 100, 100);
List<Integer> list2 = Arrays.asList(100, 200, 30, 40, 50, 60, 70, 80, 90, 100, 200, 1000, 100000);
list1.stream().filter(n -> n % 2 == 0).forEach(e -> System.out.println("e = " + e));
// distinct: 去重
// 依赖于hashCode和equals方法，底层使用的是hashset
list1.stream().distinct().forEach(e -> System.out.println("e = " + e));2.映射操作
// 2.映射操作
List<String> list3 = Arrays.asList("张三-13", "李四-14", "王五-15", "赵六-16", "钱七-17");
list3.stream().map(s -> Integer.valueOf(s.split("-")[1])).forEach(e -> System.out.println("map = " + e));
List<List<Integer>> numberLists = Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4, 5),
Arrays.asList(6)
);
// flatMap 可以处理嵌套集合或需要"展平"数据结构的情况，将每个元素转换为一个流(Stream)，然后把所有流合并成一个流
// 当你需要处理嵌套结构或一对多转换时，使用flatMap；当只是简单的一对一转换时，使用map
numberLists.stream().map(s -> s.stream()).forEach(stream -> System.out.println("stream = " + stream)); // 输出3个流对象的地址值 java.util.stream.ReferencePipeline$Head@3b9a45b3
numberLists.stream().flatMap(s -> s.stream()).forEach(s -> System.out.println("flatMap = " + s)); // 输出 1 2 3 4 5 63.截取/跳过操作
// 3.截取/跳过操作
// limit: 限制元素数量
list1.stream().limit(4).forEach(e -> System.out.println("e = " + e));
// skip: 跳过前N个元素
list1.stream().skip(5).forEach(e -> System.out.println("e = " + e));4.排序操作
// 4.排序操作
// sorted: 排序
Stream.of("b", "a", "c").sorted().forEach(s -> System.out.println("sorted = " + s));
// 自定义排序
Stream.of("aaa", "bb", "c").sorted(Comparator.comparingInt(String::length)).forEach(s -> System.out.println("customSorted = " + s));
Stream.of("aaa", "bb", "c", null).sorted((a, b) -> {
if (a == null && b == null) return 0;
if (a == null) return 1;
if (b == null) return -1;
return b.compareTo(a);
}).forEach(s -> System.out.println("customSorted2 = " + s));5.合并操作
// 5.合并操作
Stream.concat(list1.stream(), list2.stream()).forEach(e -> System.out.println("e = " + e));6.其他中间操作
此API可以很好的证明流“延迟执行”的特点，当无forEach()时，不会打印出中间元素，当有终结操作时，流才会执行。
// 6.其他中间操作
// peek: 查看流中元素，调试用
Stream.of("one", "two", "three")
.peek(e -> System.out.println("Original: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped: " + e))
.forEach(e-> System.out.println("peek = " + e));四、 流的终结操作
终结操作会触发流的处理并返回结果
1.遍历操作
// 1.遍历操作
List<String> list = Arrays.asList("张三-13", "李四-14", "王五-15", "赵六-16", "钱七-17", "张三-23");
// forEach: 遍历元素
list.stream().forEach(e -> System.out.println("e = " + e));
// forEachOrdered: 保证顺序的遍历
list.parallelStream().forEachOrdered(e -> System.out.println("e = " + e));2.收集操作
// 2.收集操作
// 收集到list集合
List<String> nameList = list.stream().map(e -> e.split("-")[0]).collect(Collectors.toList());
System.out.println("nameList = " + nameList);
// 收集到set集合，会去重
Set<String> nameSet = list.stream().map(e -> e.split("-")[0]).collect(Collectors.toSet());
System.out.println("nameSet = " + nameSet);
// 收集到map集合
// 注意收集到map，键不能重复，重复会报 java.lang.IllegalStateException: Duplicate key 张三 (attempted merging values 13 and 23)
// Map<String, Integer> map1 = list.stream().collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.valueOf(s.split("-")[1])));
// System.out.println("map1 = " + map1);
// 解决方案，传递第三个参数，如果键重复，使用前面的那么，以下的(a, b)代表的value，a为已经存在的，b为新加的
Map<String, Integer> map2 = list.stream().collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.valueOf(s.split("-")[1]), (a, b) -> a));
System.out.println("map2 = " + map2);
// 收集为字符串
String nameStr = list.stream().map(e -> e.split("-")[0]).collect(Collectors.joining("-"));
System.out.println("nameStr = " + nameStr); // 张三-李四-王五-赵六-钱七-张三3.聚合操作
// 3.聚合操作
// count: 计数
long count = Stream.of("a", "b", "c").count();
System.out编程.println("count = " + count); // 3
// max/min: 最大最小值
Optional<String> max = Stream.of("a", "bb", "ccc").max(Comparator.comparingInt(String::length));
System.out.println("max = " + max.get());
// reduce: 归约操作
// 无初始值，当流为空，则为Optional.empty()
China编程 Optional<Integer> sum = Stream.of(1, 2, 3).reduce(Integer::sum);
System.out.println("sum = " + androidsum.get()); // ccc
// 初始值为0，流为空则返回0，执行的操作为 0+1+2+3 = 6
Integer sumWithIdentity = Stream.of(1, 2, 3).reduce(0, Integer::sum);
System.out.println("sumWithIdentity = " + sumWithIdentity); // 64.匹配操作
// 4.匹配操作
// anyMatch: 任意元素匹配(任意一个满足条件则为true)
boolean hasEven = Stream.of(1, 2, 3).anyMatch(n -> n % 2 == 0);
System.out.println("hasEven = " + hasEven); // true
// allMatch: 所有元素匹配(所有元素都要满足条件)
boolean allEven = Stream.of(2, 4, 6).allMatch(n -> n % 2 == 0);
System.out.println("allEven = " + allEven); // true
// noneMatch: 没有元素匹配(所有元素都不能满足条件)
boolean noneNegative = Stream.of(1, 2, 3).noneMatch(n -> n < 0);
System.out.println("noneNegative = " + noneNegative); // tTAzqIIyrue5.查找操作
// 5.查找操作
// findFirst: 查找第一个元素
Optional<String> first = Stream.of("a", "b", "c").findFirst();
System.out.println("first = " + first.get()); // a
// findAny: 查找任意元素(在并行流中效率更高)
Optional<String> any = Stream.of("a", "b", "c").parallel().findAny();
System.out.println("any = " + any.get()); // b6.数组转换
// 6.数组转换
// toArray: 转换为数组
String[] array = Stream.of("a", "b", "c").toArray(String[]::new);
System.out.println("array = " + Arrays.toString(array))http://www.chinasem.cn; // [a, b, c]7.分组
// 7.分组
// 可将一个对象集合按照里面的某个字段转换为map，如key为ID，value为对象
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "grape");
Map<Integer, List<String>> groupedByLength = words.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength);到此这篇关于Java Stream流与使用操作指南的文章就介绍到这了,更多相关Java Stream流内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持China编程(www.chinasem.cn)！
这篇关于Java Stream流与使用操作指南的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
