devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java的Stream流【详解】_java stream流

作者：小蓝xlanll | 2024-05-05 04:05:05

赞

踩

java stream流

        

目录

        

一.概念

二.Stream流处理数据的步骤

        1.得到集合或者数组的Stream流。

2.调用Stream流的中间方法对数据进行处理

3.调用Stream流的终结方法获取处理的结果

一.概念

        是Jdk8开始新增的一套API (java.util.stream.*)，可以用于操作集合或者数组的数据。

好处:

       Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。

二.Stream流处理数据的步骤

        1.得到集合或者数组的Stream流。

                获取集合对象的Stream流：default Stream<E> stream​()

                获取数组对象的Stream流：

                        Arrays类提供的静态方法 public static <T> Stream<T> stream(T[] array)

                        Stream类提供的静态方法   public static<T> Stream<T> of(T... values)

        

  1. package com.itheima.day08.teacher.stream;
  2.  
  3. import java.util.*;
  4. import java.util.stream.Stream;
  5.  
  6. public class StreamDemo01 {
  7.     /*
  8.       掌握
  9.          如何获取 List的Stream流
  10.          如何获取 Set的Stream流
  11.              单列集合对象.stream()
  13.          如何获取 Map的Stream流
  14.              变成单列之后 在 .stream()
  16.          如果获取 数组的Stream流
  17.              Arrays.stream(数组)
  18.              Stream.of(数组)
  19.          将集合中的数据放到流水线上。
  20.      */
  21.     public static void main(String[] args) {
  22.         //1 List的Stream流
  23.         List<String> names = new ArrayList<>();
  24.         Collections.addAll(names,"蔡徐坤","小黑子","ikun","鸡你太美");
  25.         // 数据转换到流上
  26.         Stream<String> stream1 = names.stream();
  27.  
  28.         //2 Set的Stream流
  29.         Set<String> set = new HashSet<>();
  30.         Collections.addAll(set,"蔡徐坤","小黑子","ikun","鸡你太美");
  31.         // 数据转换到流上
  32.         Stream<String> stream2 = names.stream();
  33.  
  34.         //3:如何获取 Map的Stream流
  35.         Map<String,Integer> map = new HashMap<>();
  36.         map.put("姚明",40);
  37.         map.put("刘翔",42);
  38.         map.put("郭敬明",44);
  39.         // 键集 转换成Stream流
  40.         Stream<String> stream31 = map.keySet().stream();
  41.         // 值集 转换成Stream流
  42.         Stream<Integer> stream32 = map.values().stream();
  43.  
  44.         //处理键值对呢？ 键值对对象 叫entry
  45.         Stream<Map.Entry<String, Integer>> stream3 = map.entrySet().stream();
  46.  
  47.  
  48.         //4:数组 的Stream流
  49.         String[] array = {"蔡徐坤","小黑子","ikun","鸡你太美"};
  50.         //两种方式
  51.         Stream<String> stream4 = Arrays.stream(array);
  52.         Stream<String> stream5 = Stream.of(array);
  53.     }
  54. }
2.调用Stream流的中间方法对数据进行处理

        中间方法调用完成后会返回新的Stream流，可以继续使用(支持链式编程)

  1. package com.itheima.day08.teacher.stream;
  2.  
  3. import java.util.stream.Stream;
  4.  
  5. public class StreamDemo02 {
  6.     /*
  7.      学习Stream流的中间方法
  8.      */
  9.     public static void main(String[] args) {
  10.         //将多个数据放到流水线上 形成新的Stream流
  11.         Stream<String> stream1 = Stream.of("a", "b", "c", "d", "e", "f", "g");
  12.         // limit(long n)流水线上取出前n个元素..形成一个新的流向  旧的流向已经关闭 (永不回头)
  13. //        Stream<String> limit = stream1.limit(3);
  14.         // forEach(写处理每个数据的lambda表达式)
  15.         // lambda ()->{}
  16.         System.out.println("=================limit 取前几个======================");
  17.         stream1.limit(3).forEach(s-> System.out.println(s));
  18.  
  19.         // forEach() 终结方法 从流水线上下来了。
  20.         //============================
  21.         System.out.println("=================skip跳过======================");
  22.         Stream<String> stream2 = Stream.of("a", "b", "c", "d", "e", "f", "g");
  23.         //跳过
  24.         stream2.skip(4).forEach(s -> System.out.println(s));
  25.  
  26.         System.out.println("=============distinct去重==========================");
  27.         Stream<String> stream3 = Stream.of("a", "b", "a", "d", "b", "b", "g");
  28.         //终结方法
  29. //        System.out.println(stream3.count());
  30. //        stream3.skip(3); 报错 原因 count()终结
  31.         long count = stream3.distinct().count();
  32.         System.out.println("去重之后还有几个数据:"+count);
  33.  
  34.         System.out.println("============sorted排序=================");
  35.         Stream<Integer> stream4 = Stream.of(911,119,111,114,110);
  36.         stream4.sorted().forEach(s-> System.out.println(s));//默认排序
  37.         System.out.println("============sorted排序 自定义排序规则=================");
  38.         Stream<Integer> stream5 = Stream.of(911,119,111,114,110);
  39.         stream5.sorted((o1,o2)->o2-o1).forEach(s-> System.out.println(s));//默认排序
  40.     }
  41. }
  42.  
  43.  
  44.  
  45. ----------------
  46. package com.itheima.day08.teacher.stream;
  47.  
  48. import java.util.ArrayList;
  49. import java.util.Collections;
  50. import java.util.List;
  51. import java.util.stream.Stream;
  52.  
  53. public class StreamDemo03 {
  54.     /*
  55.        学会使用Stream流的中间方法
  56.      */
  57.     public static void main(String[] args) {
  58.         List<Double> scores = new ArrayList<>();
  59.         Collections.addAll(scores, 88.5, 100.0, 50.0);
  60.  
  61.         // sorted 排序  排序的规则  两个数据比较 (o1,o2)->{比较的规则}
  62.         // sorted((o1,o2)->{排序的规则})  sorted() 默认规则
  63.         // forEach(完成数据的遍历)  每次取出来每一个元素
  64.         // forEach((s)->{处理s})
  65.  
  66.         // filter是过滤的功能  找出符合要求的数据 返回的结果是boolean
  67.         // filter((s)->{return 判断语句;})
  68.         // filter(s->判断语句)
  69.         // 找出成绩大于等于60分的数据，并升序后，再输出。
  70.         scores.stream().filter(s->s>=60).sorted().forEach(System.out::println);
  71.  
  72.         // map 一一映射  转换的意思
  73.         // 将流中的Double类型数据 变成字符串类型
  74. //        Stream<Double> stream = scores.stream(); 流里面是 Double类型元素
  75.         // map 将A 类型 转换成  B类型
  76.         //      Double---String
  77.         // map((A s)->{return B类型;})
  78.         // map(A类型参数->B类型数据)
  79. //        Stream<String> stringStream = scores.stream().map((Double d) -> {
  80. //            return d + "哈哈";
  81. //        });
  82.  
  83.         Stream<String> stringStream = scores.stream().map( d ->  d + "哈哈");
  84.  
  85.         // Double类型 变成学生类型
  86. //         scores.stream().map((Double s)->{返回 学生对象})
  87. //        Stream<Student> studentStream = scores.stream().map((Double s) -> {
  88. //            return new Student("小明", 18, s);
  89. //        });
  90.  
  91.         Stream<Student> studentStream = scores.stream().map( s->  new Student("小明", 18, s));
  92.          //苍穹外卖 项目后期 可以使用map进行类型转换。
  93.  
  94.         //合并流
  95.         Stream<String> stream1 = Stream.of("a", "b", "c");
  96.         Stream<String> stream2 = Stream.of("1", "2", "3");
  97.  
  98.         Stream<String> stream = Stream.concat(stream1, stream2);
  99.         //两个流合并到一个流上了。
  100.     }
  101. }
3.调用Stream流的终结方法获取处理的结果

        终结方法调用完成后，不会返回新Stream了，不能继续使用流了

       

代码演示：

  1.  
  2.  
  3. package com.itheima.day08.teacher.stream;
  4.  
  5. /**
  6.  * 学生类
  7.  */
  8. public class Student {
  9.  
  10.     private String name;
  11.     private int age;
  12.     private double score;
  13.  
  14.     public Student() {
  15.     }
  16.  
  17.     public Student(String name, int age, double score) {
  18.         this.name = name;
  19.         this.age = age;
  20.         this.score = score;
  21.     }
  22.  
  23.     /**
  24.      * 获取
  25.      * @return name
  26.      */
  27.     public String getName() {
  28.         return name;
  29.     }
  30.  
  31.     /**
  32.      * 设置
  33.      * @param name
  34.      */
  35.     public void setName(String name) {
  36.         this.name = name;
  37.     }
  38.  
  39.     /**
  40.      * 获取
  41.      * @return age
  42.      */
  43.     public int getAge() {
  44.         return age;
  45.     }
  46.  
  47.     /**
  48.      * 设置
  49.      * @param age
  50.      */
  51.     public void setAge(int age) {
  52.         this.age = age;
  53.     }
  54.  
  55.     /**
  56.      * 获取
  57.      * @return score
  58.      */
  59.     public double getScore() {
  60.         return score;
  61.     }
  62.  
  63.     /**
  64.      * 设置
  65.      * @param score
  66.      */
  67.     public void setScore(double score) {
  68.         this.score = score;
  69.     }
  70.  
  71.     public String toString() {
  72.         return "Student{name = " + name + ", age = " + age + ", score = " + score + "}";
  73.     }
  74. }
  75.  
  76.  
  77.  
  78. --------------
  79. package com.itheima.day08.teacher.stream;
  80.  
  81. import java.util.ArrayList;
  82. import java.util.Collections;
  83. import java.util.List;
  84. import java.util.Optional;
  85. import java.util.stream.Stream;
  86.  
  87. public class StreamDemo04 {
  88.     /*
  89.        学会使用Stream流的终结方法
  90.      */
  91.     public static void main(String[] args) {
  92.         List<Double> scores = new ArrayList<>();
  93.         Collections.addAll(scores, 88.5, 100.0, 50.0);
  94.  
  95.         System.out.println(scores.stream().count());//求出该流中数据的个数
  96.         scores.stream().forEach(s-> System.out.println(s));//对流中数据进行处理--输出
  97.         System.out.println("===========求最大值==============");
  98.         Double max = scores.stream().max((o1, o2) -> Double.compare(o2, o1)).get(); //按照正常前后顺序才能找到，翻过会找到最小值
  99. //        Double max = scores.stream().max(Double::compare).get();
  100.         Double min = scores.stream().min((o1, o2) -> Double.compare(o1, o2)).get();
  101.         System.out.println(max);
  102.         System.out.println(min);
  103.  
  104.         List<Student> students = new ArrayList<>();
  105.         students.add(new Student("小明",28,1.67));
  106.         students.add(new Student("小李",26,1.98));
  107.         students.add(new Student("小王",27,1.99));
  108.         //求出身高最高的哪位同志
  109. //        Student student = students.stream().max((o1, o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
  110.         Student student = students.stream().max((o1, o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
  111.         System.out.println(student);
  112.     }
  113. }
  114.  
  115.  
  116.  
  117. ------------------
  118. package com.itheima.day08.teacher.stream;
  119.  
  120. import java.util.ArrayList;
  121. import java.util.List;
  122. import java.util.stream.Collectors;
  123.  
  124. public class StreamTest01 {
  125.  
  126.     public static void main(String[] args) {
  127.         List<String> list = new ArrayList<>();
  128.         list.add("张歆艺");
  129.         list.add("周杰伦");
  130.         list.add("赵雷");
  131.         list.add("张译");
  132.         list.add("张学友");
  133.  
  134.         //把集合中所有以 张开头  且3个字的元素存储到新的集合中
  135.         List<String> newList = new ArrayList<>();
  136.         for (String name : list) {
  137.             if(name.startsWith("张") && name.length()==3){
  138.                 newList.add(name);
  139.             }
  140.         }
  141.         System.out.println(newList);
  142.  
  143.         // 将集合数据放到流水线上  进行 一步步的操作
  144.         List<String> newList2 = list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).collect(Collectors.toList());
  145.  
  146.         System.out.println(newList2);
  147.     }
  148.  
  149. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/537146
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号