本篇内容介绍了“Java中Steam流怎么使用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
一. 流的常用创建方法
1-1 使用Collection下的 stream() 和 parallelStream() 方法
List<String> list = new ArrayList<>();Stream<String> stream = list.stream(); //获取一个顺序流Stream<String> parallelStream = list.parallelStream(); //获取一个并行流1-2 使用Arrays 中的 stream() 方法，将数组转成流
Integer[] nums = new Integer[10];Stream<Integer> stream = Arrays.stream(nums);1-3 使用Stream中的静态方法：of()、iterate()、generate()
// 1. of()Stream<Integer> stream = Stream.of(1,2,3,4,5,6);// 2. iterate()Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);stream2.forEach(System.out::println); // 0 2 4 6 8 10// 3. generate()Stream<Double> stream3 = Stream.generate(Math::random).limit(2);stream3.forEach(System.out::println);1-4 使用 BufferedReader.lines() 方法，将每行内容转成流
BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));Stream<String> lineStream = reader.lines();lineStream.forEach(System.out::println);1-5 使用 Pattern.splitAsStream() 方法，将字符串分隔成流
Pattern pattern = Pattern.compile(",");Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");stringStream.forEach(System.out::println);二、流的中间操作
// 1. 筛选与切片filter：过滤流中的某些元素limit skip distinct sorted 都是有状态操作，这些操作只有拿到前面处理后的所有元素之后才能继续下去。limit(n)：获取前n个元素skip(n)：跳过前n元素，配合limit(n)可实现分页distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素// 2. 映射map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。// 3. 消费 peek , 类似map， // map接收的是一个Function表达式，有返回值；// 而peek接收的是Consumer表达式，没有返回值。// 4. 排序sorted()：自然排序，流中元素需实现Comparable接口sorted(Comparator com)：定制排序，自定义Comparator排序器// 5.2-1 筛选、去重与切片：filter、distinct、skip、limit
// 实例：集合内元素>5,去重，跳过前两位，取剩下元素的两个返回为新集合Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14 .distinct() //6 7 9 8 10 12 14 .skip(2) //9 8 10 12 14 .limit(2); //9 8newStream.forEach(System.out::println);2-2 映射：map、flatMap
// 1. Map可以看成一个转换器，传入一个对象，返回新的对象// map的使用实例 stream.map(x->x.getId());List<String> list = Arrays.asList("a,b,c", "1,2,3");// 去掉字符串中所有的,List<String> collect = list.stream().map(s -> s.replaceAll(",", "")).collect(Collectors.toList());// collect集合内容为：{abc,123}System.out.println(collect);// 2. flatMap 效果：结果展平 ，即把嵌套集合，按照子集合的形式，统一放入到新的一个集合中 // 接收一个函数作为参数，将流中的每个值都换成另一个流，// 然后把所有流连接成一个流。Stream<String> stringStream = list.stream().flatMap(s -> { // 将字符串以,分割后得到一个字符串数组 String[] split = s.split(","); // 然后将每个字符串数组对应流返回，flatMap会自动把返回的所有流连接成一个流 Stream<String> stream = Arrays.stream(split); return stream;});// stringStream.collect(Collectors.toList())的集合内容为：{a,b,c,1,2,3}System.out.println(stringStream.collect(Collectors.toList()));2-3 归约：统计-计算-逻辑处理：reduce
// 说明：reduce看似效果和map相似，// 但reduce返回的是函数经过执行运算后的结果,// 而map返回的是处理后新的集合List<String> memberNames = new ArrayList<>();memberNames.add("Amitabh");memberNames.add("Shekhar");memberNames.add("Aman");memberNames.add("Rahul");memberNames.add("Shahrukh");memberNames.add("Salman");memberNames.add("Yana");memberNames.add("Lokesh");// 将集合中的元素按照#连接成字符串，并返回放置在Optional<String>中Optional<String> reduced = memberNames.stream() .reduce((s1,s2) -> s1 + "#" + s2);// 有值则取出打印显示 reduced.ifPresent(System.out::println); // 输出内容： Amitabh#Shekhar#Aman#Rahul#Shahrukh#Salman#Yana#Lokesh// 计算统计实例： private static void testReduce() { //T reduce(T identity, BinaryOperator<T> accumulator); System.out.println("给定个初始值，求和"); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item)); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum)); // 输出：110 System.out.println("给定个初始值，求min"); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, item) -> Math.min(min, item))); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min)); // 输出：1 System.out.println("给定个初始值，求max"); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, item) -> Math.max(max, item))); System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max)); // 输出：100 //Optional<T> reduce(BinaryOperator<T> accumulator); // 注意返回值，上面的返回是T,泛型，传进去啥类型，返回就是啥类型。 // 下面的返回的则是Optional类型 System.out.println("无初始值，求和"); System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0)); // 输出：10 Integer sum=Stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get(); System.out.println(sum); // 输出：10 System.out.println("无初始值，求max"); System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0)); // 输出：4 System.out.println("无初始值，求min"); System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0)); // 输出：1 }2-4 排序：sorted
// 按照默认字典顺序排序stream.sorted(); // 按照sortNo排序stream.sorted((x,y)->Integer.compare(x.getSortNo(),y.getSortNo())); 2-4-1 函数式接口排序// 正向排序（默认）pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId));// 逆向排序pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId).reversed()); 2-4-2 LocalDate 和 LocalDateTime 排序// 准备测试数据Stream<DateModel> stream = Stream.of(new DateModel(LocalDate.of(2020, 1, 1)), new DateModel(LocalDate.of(2021, 1, 1)), new DateModel(LocalDate.of(2022, 1, 1)));// 正向排序（默认）stream.sorted(Comparator.comparing(DateModel::getLocalDate)).forEach(System.out::println);// 逆向排序stream.sorted(Comparator.comparing(DateModel::getLocalDate).reversed()).forEach(System.out::println);三. 流的终止操作 allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min
// 匹配和聚合allmatch，noneMatch，anyMatch用于对集合中对象的某一个属性值是否存在判断。 allMatch全部符合该条件返回true， noneMatch全部不符合该断言返回true anyMatch 任意一个元素符合该断言返回true// 实例：List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);boolean allMatch = list.stream().allMatch(e -> e > 10); //falseboolean noneMatch = list.stream().noneMatch(e -> e > 10); //trueboolean anyMatch = list.stream().anyMatch(e -> e > 4); //true// 其他一些方法findFirst：返回流中第一个元素 String firstMatchedName = memberNames.stream() .filter((s) -> s.startsWith("L")) .findFirst().get();findAny：返回流中的任意元素count：返回流中元素的总个数 long totalMatched = memberNames.stream() .filter((s) -> s.startsWith("A")) .count();max：返回流中元素最大值min：返回流中元素最小值3-1 普通收集 – 收集为List
// 默认返回的类型为ArrayList，可通过Collectors.toCollection(LinkedList::new)// 显示指明使用其它数据结构作为返回值容器。List<String> collect = stream.collect(Collectors.toList());// 由集合创建流的收集需注意：仅仅修改流字段中的内容，没有返回新类型，// 如下操作直接修改原始集合，无需处理返回值。userVos.stream().map(e -> e.setDeptName(hashMap.get(e.getDeptId()))).collect(Collectors.toList());// 收集偶数集合的实例：List<Integer> list = new ArrayList<Integer>();for(int i = 1; i< 10; i++){ list.add(i);}Stream<Integer> stream = list.stream();List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0) .collect(Collectors.toList());System.out.print(evenNumbersList);3-2 普通收集 – 收集流为数组(Array)
// list 为 {1,2,3,.....100}Stream<Integer> stream = list.stream();Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);3-3 普通收集 – 收集为Set
// 默认返回类型为HashSet，可通过Collectors.toCollection(TreeSet::new)// 显示指明使用其它数据结构作为返回值容器。Set<String> collect = stream.collect(Collectors.toSet());3-4 高级收集 – 收集为Map
// 默认返回类型为HashMap，可通过Collectors.toCollection(LinkedHashMap::new)// 显示指明使用其它数据结构作为返回值容器// 测试实体类@Datapublic class Entity { private Integer id; private String name;}// 模拟从数据库中查询批量的数据List<Entity> entityList = Stream.of(new Entity(1,"A"), new Entity(2,"B"), new Entity(3,"C")).collect(Collectors.toList());// 将集合数据转化成id与name的MapMap<Integer, String> hashMap = entityList.stream().collect(Collectors.toMap(Entity::getId, Entity::getName));3-5 高级收集 – 分组收集
// 默认使用List作为分组后承载容器Map<Integer, List<XUser>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId)); // 显示指明使用List作为分组后承载容器Map<Integer, List<XUser>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId, Collectors.toList()));// 映射后再分组Map<Integer, List<String>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId,Collectors.mapping(XUser::getUserName,Collectors.toList())));四. Steam拓展
4-1 集合与对象互转
public static <T, C extends Collection<T>> Collection<T> toCollection(T t) { return toCollection(t, ArrayList::new);}public static <T, C extends Collection<T>> Collection<T> toCollection(T t, Supplier<C> supplier) { return Stream.of(t).collect(Collectors.toCollection(supplier));}4-2 集合转对象
public static <E> E toObject(Collection<E> collection) { // 处理集合空指针异常 Collection<E> coll = Optional.ofNullable(collection).orElseGet(ArrayList::new); // 此处可以对流进行排序，然后取出第一个元素 return coll.stream().findFirst().orElse(null);}4-3 Java Steam中的并发操作实例
List<Integer> list = new ArrayList<Integer>();for(int i = 1; i< 10; i++){ list.add(i);}Stream<Integer> stream = list.parallelStream(); // 创建并发流Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);System.out.print(evenNumbersArr); // 打印出的偶数为无规则排序的“Java中Steam流怎么使用”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！
