• Java---Stream流详解

    目录​​​​​​​

    一、Stream流详解

    二、Stream流的获取

    （1）单列集合

    （2）双列集合

    （3）数组

    （4）一些零散数据

    三、Stream流中常用的API方法

    （1）中间方法

    （2）终结方法

    （3）收集方法

    一、Stream流详解

    Stream流其实就相当于是工厂上的流水线，后面会对数据更好的进行操作，如打印，过滤等等。说到底把它比作是工厂上的流水线还是很形象的。

    二、Stream流的获取

    1.     获取方式       方法名                                          说明
    2.  
    3.   单列集合         defaultstream()                            collection中的默认方法
    4.   双列集合         无                                            无法直接使用stream流 
    5.   数组             public staticStreamstream(T[] array)    Array工具类的静态方法
    6.   一堆零散数据     public staticStreamof(T...values)       Stream接口中的静态方法

    （1）单列集合

    1. package article;
    2. import java.util.*;
    3. import java.util.Collection;
    4. import java.util.*;
    5. import java.util.function.Consumer;
    6. import java.util.*;
    7. import java.util.*;
    8. public class first {
    9.    public static void main(String[] args) {
    10.      ArrayLists=new ArrayList<>();
    11.      Collections.addAll(s, "opop","------","4er45","<>><><");
    12.      s.stream().forEach(new Consumer() {
    13.  
    14. 		@Override
    15. 		public void accept(String t) {
    16. 			// TODO 自动生成的方法存根
    17. 			System.out.println(t);
    18. 		}
    19.     	 
    20.      });
    21.      //接下来使用lambda表达式进行简化
    22.      System.out.println("--------------------------------");
    23.      s.stream().forEach(i->System.out.println(i));
    24.    }
    25. }
    26.

    （2）双列集合

    双列结合获取stream流有两种办法，一种是获取通过键获取，一种是通过键值来获取。

    1. package article;
    2. import java.util.*;
    3. import java.util.Collection;
    4. import java.util.Map.Entry;
    5. import java.util.*;
    6. import java.util.function.Consumer;
    7. import java.util.*;
    8. import java.util.*;
    9. public class first {
    10.    public static void main(String[] args) {
    11.      HashMap s=new HashMap<>();
    12.      s.put("abs", 192);
    13.      s.put("<<<<",200);
    14.      s.put("[][][]", 10);
    15.      
    16.      //第一种通过键获取stream流
    17.      s.keySet().stream().forEach(new Consumer(){
    18.  
    19. 		@Override
    20. 		public void accept(String t) {
    21. 			// TODO 自动生成的方法存根
    22. 			//t是键
    23. 			System.out.println("键="+t+" 值="+s.get(t));
    24. 			
    25. 		}
    26.     	 
    27.      });
    28.      System.out.println("----------------------------------------------------");
    29.      //第二种通过键值对获取
    30.      s.entrySet().stream().forEach(new Consumer>() {
    31.  
    32. 		@Override
    33. 		public void accept(Entry t) {
    34. 			// TODO 自动生成的方法存根
    35. 			System.out.println("键="+t.getKey()+" 值="+t.getValue());
    36. 		}
    37.     	 
    38.      });
    39.    }
    40. }
    41.

    （3）数组

    1. package article;
    2. import java.util.*;
    3. import java.util.Collection;
    4. import java.util.Map.Entry;
    5. import java.util.*;
    6. import java.util.function.Consumer;
    7. import java.util.function.IntConsumer;
    8. import java.util.*;
    9. import java.util.*;
    10. public class first {
    11.    public static void main(String[] args) {
    12.      int[] a= {1,32,98,12,90};
    13.      
    14.      Arrays.stream(a).forEach(s->System.out.println(s));
    15.    }
    16. }
    17.

    （4）一些零散数据

    静态方法of可以=传递零散数据，也可以是一个数组，如果是基本数据类型数组，传递进去的是地址，引用数据类型则是值。

    1. package article;
    2. import java.util.*;
    3. import java.util.Collection;
    4. import java.util.Map.Entry;
    5. import java.util.*;
    6. import java.util.function.Consumer;
    7. import java.util.function.IntConsumer;
    8. import java.util.stream.Stream;
    9. import java.util.*;
    10. import java.util.*;
    11. public class first {
    12.    public static void main(String[] args) {
    13.      Stream.of("1",";").forEach(s->System.out.println(s));
    14.      int[] a= {1,2,8};
    15.      String[] b= {"klj",";;;"};
    16.      Stream.of(a).forEach(s->System.out.println(s));
    17.      Stream.of(b).forEach(s->System.out.println(s));
    18.    }
    19. }
    20.

    三、Stream流中常用的API方法

    （1）中间方法

    修改stream流中的数据，但不会影响原来集合或者数组中的数据。这里建议使用链式编程。

    1.  
    2. Streamfilter(Predicatesuper T>predicate)   过滤
    3. Streamlimit(long maxsize)                    获取前几个元素
    4. Streamskip(long n)                           跳过前几个元素
    5. Streamdistinct()                             元素去重，以来hashcode和equals方法，自定义类时记得重写hashcode和equals
    6. staticStreamconcat(Stream a,Stream b)     合并a和b两个流为一个；流
    7. Streammap(Functionmapper)               转换流中的数据类型
    1. package article;
    2. import java.util.*;
    3.  
    4. import java.util.Collection;
    5. import java.util.Map.Entry;
    6. import java.util.*;
    7. import java.util.function.Consumer;
    8. import java.util.function.IntConsumer;
    9. import java.util.function.Predicate;
    10. import java.util.stream.Stream;
    11. import java.util.*;
    12. import java.util.*;
    13. public class first {
    14.    public static void main(String[] args) {
    15.      ArrayList s=new ArrayList<>();
    16.      Collections.addAll(s,"张三丰","周芷若","赵敏","张强","张无忌","张翠山","张亮","王二麻子","谢广坤");
    17.      
    18.      //第一个使用filter过滤,假如得到所有姓张的
    19.      s.stream().filter(new Predicate() {
    20.  
    21. 		@Override
    22. 		public boolean test(String t) {
    23. 			// 如果返回值是true，表示该数据留下
    24. 			if(t.startsWith("张")) {
    25. 				return true;
    26. 			}
    27. 			return false;
    28. 		}
    29.     	 
    30.      }).forEach(i->System.out.print(i+" "));
    31.      System.out.println();
    32.      
    33.      //filter使用lambda表达式简写，我也推荐大家这样写，简单一点
    34.      System.out.println("lambda写法:姓张并且长度=3----------------------");
    35.      s.stream()
    36.      .filter(i->i.startsWith("张"))
    37.      .filter(i->i.length()==3)
    38.      .forEach(i->System.out.print(i+" "));
    39.      System.out.println();
    40.    
    41.      System.out.println("limit的使用");
    42.      //第二个limit获取前几个元素
    43.      System.out.println("获取stream中的前面两个元素:");
    44.      s.stream().limit(2).forEach(i->System.out.print(i+" "));
    45.      System.out.println();
    46.     
    47.      System.out.println("skip的使用");
    48.      //第三个skip跳过前面几个元素
    49.      System.out.println("跳过前面7个元素，也就是获得后面两个元素:");
    50.      s.stream().skip(7).forEach(i->System.out.print(i+" "));
    51.      System.out.println();
    52.      
    53.      System.out.println("distinct的使用:");
    54.      //第四个distinct元素去重，依赖hashcode和equals(自定义对象记得重写)
    55.      ArrayList list=new ArrayList<>();
    56.      Collections.addAll(list, "张三丰","张三丰","周芷若","赵敏","张强","张无忌","张翠山","张亮","王二麻子","谢广坤");
    57.      list.stream().distinct().forEach(i->System.out.print(i+" "));
    58.      System.out.println();
    59.      
    60.      System.out.println("concat的使用");
    61.      //第五个使用concat将a，b两个流合并成为一个流，注意这里两个流中的数据类型建议是一样的，不一样合并之后则是它们共同父类的数据类型
    62.      ArrayList list1=new ArrayList<>();
    63.      Collections.addAll(list1, "-=-=","[][][");
    64.      Stream.concat(list1.stream(),s.stream()).forEach(i->System.out.print(i+" "));
    65.      System.out.println();
    66.      
    67.      System.out.println("map的使用：");
    68.      //第六个使用map转换流中的数据类型
    69.      //比如来个需求现在想要下面集合中的年龄
    70.      //这里注意一下map方法执行了以后，流上的数据就变成了整数，不在是之前的字符串了，所以后面的forEach打印出来的是数字
    71.      ArrayList list2=new ArrayList<>();
    72.      Collections.addAll(list2,"张无忌-15","周芷若-18","王柳-100","段誉-98");
    73.      list2.stream().map(i->Integer.parseInt(i.split("-")[1]))
    74.      .forEach(i->System.out.print(i+" "));
    75.      System.out.println();
    76.   }
    77. }
    78.

     

     

    （2）终结方法

    终结方法是什么呢，与中间方法有什么区别吗？没什么大的区别，都是方法，只不过终结方法使用过后就不能再对流进行操作了，它是对流做的最后一次操作了。

    1.  
    2. void forEach()            遍历
    3. long count()              统计
    4. toArray()                 收集流中的数据，放到数组中
    1. package article;
    2. import java.util.*;
    3.  
    4. import java.util.Collection;
    5. import java.util.Map.Entry;
    6. import java.util.*;
    7. import java.util.function.Consumer;
    8. import java.util.function.IntConsumer;
    9. import java.util.function.IntFunction;
    10. import java.util.function.Predicate;
    11. import java.util.stream.Stream;
    12. import java.util.*;
    13. import java.util.*;
    14. public class first {
    15.    public static void main(String[] args) {
    16.      ArrayList s=new ArrayList<>();
    17.      Collections.addAll(s,"张三丰","周芷若","赵敏","张强","张无忌","张翠山","张亮","王二麻子","谢广坤");
    18.      
    19.      String[] a=s.stream().toArray(new IntFunction() {
    20.         //这里的IntFunction中的类型就是要转换成的数组类型
    21.     	//apply中的value是流中的数据个数，要和数组长度保持一致
    22.     	 //apply的返回值是具体类型的数组
    23. 		@Override
    24. 		public String[] apply(int value) {
    25. 			// TODO 自动生成的方法存根
    26. 			return new String[value];
    27. 		}
    28.     	 
    29.      });
    30.      System.out.println(Arrays.toString(a));
    31.      
    32.      //lambad表达式
    33.      String[] b=s.stream().toArray((i)->{
    34.     	 return new String[i];
    35.    });
    36.      System.out.println(Arrays.toString(b));
    37.      
    38.   }
    39. }
    40.

     

    （3）收集方法

    collect()                 收集流中的数据，放到集合（list，set，map）中

    注意啊，collect()也是终结方法使用了它之后后面就不能在使用其它什么了。

    1. package article;
    2. import java.util.*;
    3.  
    4. import java.util.Collection;
    5. import java.util.Map.Entry;
    6. import java.util.*;
    7. import java.util.function.Consumer;
    8. import java.util.function.Function;
    9. import java.util.function.IntConsumer;
    10. import java.util.function.IntFunction;
    11. import java.util.function.Predicate;
    12. import java.util.stream.Collectors;
    13. import java.util.stream.Stream;
    14. import java.util.*;
    15. import java.util.*;
    16. public class first {
    17.    public static void main(String[] args) {
    18.      ArrayList s=new ArrayList<>();
    19.      Collections.addAll(s,"张无忌-男-15","张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-29","张三丰-男-100","张翠山-男-40","王五-男-66","谢逊-女-87");
    20.      
    21.      //第一个:收集到list集合中，这里的tolist底层是用ArrayList实现的
    22.      //需求收集性别是男的，姓张的
    23.      List list1=s.stream().filter(i->i.startsWith("张"))
    24.     		 .filter(i->"男".equals(i.split("-")[1]))
    25.     		 .collect(Collectors.toList());
    26.      System.out.println(list1);
    27.      
    28.      //第二个：收集到Set集合中，与List集合不同的是Set集合不允许重复
    29.      //这里的toSet方法底层是通过HashSet实现的
    30.      Set list2=s.stream().filter(i->"男".equals(i.split("-")[1]))
    31.     		 .filter(i->i.startsWith("张"))
    32.     		 .collect(Collectors.toSet());
    33.      System.out.println(list2);
    34.      
    35.      //第三个：收集到Map集合中，这里有一个注意点，键值一定不能重复，否则报错
    36.      //我们要确定哪个是键哪个是值
    37.      //这里我们将名字确定为键，年龄确定是值
    38.      //
    39.      ArrayList li=new ArrayList<>();
    40.      Collections.addAll(li,"张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-29","张三丰-男-100","张翠山-男-40","王五-男-66","谢逊-女-87");
    41.      
    42.      Map ma=li.stream().filter(i->i.startsWith("张"))
    43.     		 .filter(i->"男".equals(i.split("-")[1]))
    44.     		 .collect(Collectors.toMap(new Function(){
    45. //这里的toMap中的第一个参数是键的规则，第二个参数是值的规则
    46.     			 //第一个参数的第一个参数是流的类型，第二个是转换的键的类型，第二个同样如此
    47.     			 //返回值就是转换后的
    48. 				@Override
    49. 				public String apply(String t) {
    50. 					// TODO 自动生成的方法存根
    51. 					return t.split("-")[0];
    52. 				}
    53.     			 
    54.     		 }, new Function(){
    55.  
    56. 				@Override
    57. 				public Integer apply(String t) {
    58. 					// TODO 自动生成的方法存根
    59. 					return Integer.parseInt(t.split("-")[2]);
    60. 				}
    61.     			 
    62.     		 }));
    63.      System.out.println(ma);
    64.   }
    65. }
    66.

    ​​​​​​​

     

  • 相关阅读:
    性价比高一点的蓝牙耳机有哪几款？高性价比蓝牙耳机推荐
    使用 OpenTelemetry 构建 .NET 应用可观测性（4）：ASP.NET Core 应用中集成 OTel
    创建2个线程并执行（STL/Windows/Linux）
    基于JAVA+SpringMVC+MYSQL的网上人才招聘系统
    【数据处理必备Numpy~python】
    扫雷游戏分析实现（完整代码）
    c++对接CAT1400
    Java-基于SSM的图书书城管理系统
    虚拟DOM和真实DOM的区别和联系
    Git分支设计原则&分支常用操作练习
  • 原文地址：https://blog.csdn.net/gaoqiandr/article/details/128048088