文章目录

  • Stream流的常用方法
    • 一、终结方法
      • (1)count方法:返回流中的元素个数(统计个数)
      • (2)foreach方法:遍历流中的数据
        • ⚡foreach使用注意
    • 二、中间方法
      • (1)filter 方法:过滤数据,得到符合条件的数据,放入到Stream中,返回新的流
        • ⚡ filter使用注意
      • (2)limit(n)方法:截取前n个数据,返回新Stream流(截取超过长度的时候不会报错,会把所有数据截取)
        • ⚡limit使用注意:当截取超过流的长度
      • (3)skip(n)方法: 跳过前n个数据,返回到新Stream流(数量不够也不会报错,只不过没有数据)
        • ⚡skip 使用注意:当跳过超过流的长度
      • (4)map 方法:数据转换,将流中的数据类型进行转换
        • ⚡ map方法的应用场景
        • ⚡ map方法的使用注意
    • 三、静态方法
      • (1)concat方法: static Stream concat(流1,流2) , 可以把两个流合并成一个新的流
  • 作者:KJ.JK

Stream流的常用方法


一、终结方法


(1)count方法:返回流中的元素个数(统计个数)

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);long count = stream.count();System.out.println(count); //5 


(2)foreach方法:遍历流中的数据

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);//遍历流中的数据//匿名内部类stream.forEach(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println(integer);}});


优化输出


⚡foreach使用注意

 forEach里面是一个"Consumer函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化


二、中间方法


(1)filter 方法:过滤数据,得到符合条件的数据,放入到Stream中,返回新的流

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55,66);Stream<Integer> stream1 = stream.filter(new Predicate<Integer>() {//会返回一个筛选过的流,记得接它/* a代表流的每个元素 返回值为true,数据就会保留 返回值为false,数据就会被去掉 */@Overridepublic boolean test(Integer a) {return a % 2 == 0;}});//简化效果//Stream stream1 = stream.filter(a -> a % 2 == 0);//遍历stream1.forEach(integer -> {System.out.println(integer); //22 ,44});


⚡ filter使用注意

 filter里面是一个"Predicate函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化


(2)limit(n)方法:截取前n个数据,返回新Stream流(截取超过长度的时候不会报错,会把所有数据截取)

 Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);//截取前3个数据Stream<Integer> limit = stream.limit(3);//遍历limit.forEach(integer -> System.out.println(integer)); //11 22 33


⚡limit使用注意:当截取超过流的长度

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);//截取前40个数据,如果数量不够,也不会报错Stream<Integer> limit1 = stream.limit(40);limit1.forEach(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println(integer); //11 22 33 44 55 66}});


(3)skip(n)方法: 跳过前n个数据,返回到新Stream流(数量不够也不会报错,只不过没有数据)

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);//跳过前三个数据Stream<Integer> skip = stream.skip(3);skip.forEach(integer -> System.out.println(integer));// 44 55 66


⚡skip 使用注意:当跳过超过流的长度

Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);// 跳过前20个数据,数量不够也不会报错Stream<Integer> skip1 = stream.skip(20);skip1.forEach(integer -> System.out.println(integer));//什么都没有了,不会报错


(4)map 方法:数据转换,将流中的数据类型进行转换

 //将流中的字符串转为整数类型Stream<String> stream = Stream.of("11", "22", "33", "44", "55", "66");/* String: 流中数据原来的类型 Integer : 要变的类型 */Stream<Integer> stream1 = stream.map(new Function<String, Integer>() { //有返回值,记得接@Overridepublic Integer apply(String s) {return Integer.parseInt(s); //这步需要自己操作转换对应的类型}});


⚡ map方法的应用场景

 Stream<String> stream = Stream.of("11", "22", "33", "44", "55", "66");//把String流变成Integer流,再进行筛选奇数的流出来并遍历Stream<Integer> stream1 = stream.map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s);}});Stream<Integer> stream2 = stream1.filter(new Predicate<Integer>() {@Overridepublic boolean test(Integer integer) {return integer % 2 != 0;}});stream2.forEach(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println(integer);}});


⚡ map方法的使用注意

map里面是一个"Function函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化


三、静态方法


(1)concat方法: static Stream concat(流1,流2) , 可以把两个流合并成一个新的流

Stream<Integer> stream = Stream.of(11, 22);Stream<Integer> stream1 = Stream.of(33, 44);//合并流(前提是两个流的数据类型是一样的)Stream<Integer> concat = Stream.concat(stream, stream1);//方法引用简化输出concat.forEach(System.out::println);//11 22 33 44


作者:KJ.JK

文章对你有所帮助的话,欢迎给个赞或者 star,你的支持是对作者最大的鼓励,不足之处可以在评论区多多指正,交流学习