Stream流的获取方式与常用方法

最新推荐文章于 2024-09-14 22:09:54 发布
最新推荐文章于 2024-09-14 22:09:54 发布
阅读量3.8k 收藏 6
点赞数 2
文章标签： java stream lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiyoo55/article/details/107748248
版权
1. 获取Stream流的方法

java.util。stream.Stream是Java 8新加入的最常用的流接口。（这并不是一个函数式接口）;
获取一个流非常简单，有以下几种常用的方式获取流.

  • 所有的Collection结合都可以通过stream默认方法获取流；
    default Stream Stream()
  • Stream接口的静态方法of可以获取数组对应的流。
    static Stream of (T…values)
    参数是一个可变参数，那么我们就可以传递一个数组
package com.Stream;

import java.util.*;
import java.util.stream.Stream;

/*
    java.util。stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口）
    获取一个流非常简单，有以下几种常用的方式获取流；
        所有的Collection结合都可以通过stream默认方法获取流；
             default Stream<E> Stream()
        Stream接口的静态方法of可以获取数组对应的流。
             static<T> Stream<T> of (T...values)
             参数是一个可变参数，那么我们就可以传递一个数组
 */
public class Demo03GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        //获取键，存储到一个Set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //获取值，存储到一个Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键值对（键与值的映射关系 entrySet)
        Set<Map.Entry<String, String>> entries = map.entrySet();

        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        //把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5, 6);
        //可变参数可以传递数组
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);

        String[] arr2 = {"a","dd","cc"};
        Stream<String> stream8 = Stream.of(arr2);
    }
}
2.Stream流中常用方法_forEach

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

  • 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。）
  • 终结方法：返回值类型不再是 Stream 接口自身类型的方法
void forEach(Consumer<? super T> action);
  • 该方法接收一个Consumer接口函数，会将每一个流元素交给函数进行处理。
  • Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据。
  • 简单记：
    forEach方法，用来遍历流中的数据;
    是一个终结方.法，遍历之后就不能继续调用Stream流中的其他方法。
package com.Stream;

import java.util.stream.Stream;

/*
    Stream流中常用方法_forEach
    void forEach(Consumer<? super T> action);
    该方法接收一个Consumer接口函数，会将每一个流元素交给函数进行处理。
    Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据

    简单记：
        forEach方法，用来遍历流中的数据
        是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class Dem04Stream_forEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三", "赵四", "王五", "李六", "田七");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
    /*    stream.forEach((String name)->{
            System.out.println(name);
        });*/
        stream.forEach( name-> System.out.println(name));
    }
}

3.Stream流中的常用方法——filter：用于对Stream流中的数据进行过滤

Stream<T> filter(Predicate<? super T> predicate);
  • filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
  • Predicate中的抽象方法：
    boolean test(T t);
package com.Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法——filter：用于对Stream流中的数据进行过滤
    Stream<T> filter(Predicate<? super T> predicate);
    filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
    Predicate中的抽象方法：
          boolean test(T t);
 */
public class Demo05Stream_filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "周芷若", "赵敏", "张无忌");
        //对Stream流中的元素进行过滤，只要姓张的人
       Stream stream2 = stream.filter((String name)->{return name.startsWith("张");});
       //遍历stream2
        stream2.forEach(name-> System.out.println(name));

        /*
        Stream流属于管道流，只能被消费（使用）一次
        第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
        而这时第一个Stream流已经使用完毕，就会关闭了
        所以第一个Stream流就不能调用方法了
        IllegalStateException: stream has already been operated upon or closed
         */
        //遍历Stream流
        stream.forEach(name-> System.out.println(name));
    }
}
4.如果需要将流中的元素映射到另一个流中，可以使用map方法。
<R> Stream<R> map(Function<? super T,? extends R> mapper);
  • 该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转化为另一种R类型的流。
  • Function中的抽象方法：
    R apply（T t);
package com.Stream;

import java.util.stream.Stream;

/*
    如果需要将流中的元素映射到另一个流中，可以使用map方法。
    <R> Stream<R> map(Function<? super T,? extends R> mapper);
    该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转化为另一种R类型的流。
    Function中的抽象方法：
     R apply（T t);
 */
public class Demo06Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5", "6");
        //使用map方法，把字符串类型的整数，转换（映射）为Integer类型的整数
        Stream<Integer> stream2 = stream.map((String s)->{
           return Integer.parseInt(s);
        });
        //遍历stream2
        stream2.forEach(i-> System.out.println(i));
    }
}
5.Stream流中常用方法_count:用于统计Stream流中元素的个数
  • long count();
  • count方法是一个终结方法，返回值是一个long类型的整数；所以不能再继续调用Stream流中的其他方法了
package com.Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
    Stream流中常用方法_count:用于统计Stream流中元素的个数
    long count();
    count方法是一个终结方法，返回值是一个long类型的整数
    所以不能再继续调用Stream流中的其他方法了
 */
public class Demo07Stream_count {
    public static void main(String[] args) {
        //获取一个Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}
6.Stream流中常用方法——limit:用于截取流中的元素
  • limit方法可以对流进行截取，只取前n个。方法签名：
Stream<T> limit(long maxSize);
  • 参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
  • limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
package com.Stream;

import java.util.stream.Stream;

/*
    Stream流中常用方法——limit:用于截取流中的元素
    limit方法可以对流进行截取，只取前n个。方法签名：
    Stream<T> limit(long maxSize);
         参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
    limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
 */
public class Demo08Stream_limit {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
        Stream<String> stream = Stream.of(arr);
        //使用limit方法对Stream流中的元素进行截取，只要前3个元素
        Stream<String> strean2 = stream.limit(3);
        //遍历stream2流
        strean2.forEach(name-> System.out.println(name));
    }
}
7.Stream流中常用方法——skip:用于跳过元素
  • 如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流；
Stream<T> skip(long n);
  • 如果流的当前长度大于n,则跳过前n个；否则将会得到一个长度为0的空流
package com.Stream;

import java.util.stream.Stream;

/*
    Stream流中常用方法——skip:用于跳过元素
    如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流；
    Stream<T> skip(long n);
        如果流的当前长度大于n,则跳过前n个；否则将会得到一个长度为0的空流
 */
public class Demo09Stream_skip {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前3个元素
        Stream<String> stream2 = stream.skip(3);

        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}
8.Stream流中的常用方法——concat:用于把流组合到一起
  • 如果有两个流，希望合并成为一个流，那么可以使用静态方法concat
static <T> Stream<T> concat (Stream<? extends T> a,Stream <? extends T> b)

package com.Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法——concat:用于把流组合到一起
    如果有两个流，希望合并成为一个流，那么可以使用静态方法concat
    static <T> Stream<T> concat (Stream<? extends T> a,Stream <? extends T> b)
 */
public class Demo10Stream_concat {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream1 = Stream.of("张三丰", "张翠山", "周芷若", "赵敏", "张无忌");
        //获取一个Stream流
        String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
        Stream<String> stream2 = Stream.of(arr);

        //把以上两个流组合一个流
        Stream<String> concat = Stream.concat(stream1, stream2);
        //遍历concat
        concat.forEach(name-> System.out.println(name));
    }
}
野生技术协会副会长
关注
Lambda表达式九：Stream流三：Stream常用方法；
小枯林的博客
04-25 2126
大 案例1：提取集合中所有偶数并求和：mapToInt()方法，filter()方法，sum()方法； package com.imooc.stream; import org.junit.Test; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class StreamMethod {
玩转 Java8 Stream 流，常用方法，详细用法大合集
m0_74931226的博客
11-13 494
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：不是数据结构，不会保存数据。不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
Stream流——获取流
weixin_44664432的博客
10-18 432
java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。） 获取一个流非常简单，有以下几种常用的方式： -所有的 Collection 集合都可以通过 stream 默认方法获取流； default String<E> stream() -Stream 接口的静态方法 of 可以获取数组对应的流。 static<T> Stream<T> of (T...values)
Stream流的常见方法
m0_56259467的博客
10-11 297
Stream流的常见方法
Stream流的思想和获取Stream流
最新发布
ADCvbV的博客
09-14 1054
流。
两种获取Stream流的方式
qq_20564455的博客
08-11 338
里面已标明 import java.util.*; import java.util.stream.Stream; //supplier接口 获取一个指定类型的数据或数值 public class FuXi2 { // // 总结： // 第一种获取Stream流的方式 直接集合或者数组.Stream（） 获取当前集合或者数组的流对象 // 第二种Stream.of传入指定类型的数据或者变量 public static void main(String[] args) { .
Stream流，方法引用
hbpartty的博客
09-20 2624
  Stream流的思想：流水线思想，先拼接一个流式模型生产线 Stream操作的基础特征：1.Pipelining ：中间操作返回流对象本身                                    2.内部迭代 可以用stream流来简化容器的相关操作   获取stream流的方式：java.util.Stream&lt;T&gt;      jdk8之后出现 1.C...
Stream流常用方法
12-22
以下将详细介绍从标题和描述中提及的Stream流的常用方法： 1. **获取Stream流** - **从Collection获取**：所有实现了`Collection`接口的类（如`List`, `Set`, `Queue`等）都提供了`stream()`方法，用于将集合转换...
Java Stream流获取与常用操作
本文主要介绍了Java中的Stream流及其常用方法，包括如何获取Stream流、以及对foreach循环的使用。 在Java 8引入的Stream API是一种处理数据的新方式，它允许我们以声明性的方式处理集合数据。Stream API可以方便地...
Stream流的常用方法
xxxjackboy的博客
11-24 948
forEach遍历 /* forEach:该方法接收一个Consumer接口函数，将每一个流元素交给该函数处理 简单记： forEach方法：用来遍历流中的数据 是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法 */ public class demo01Stream_ForEach { public static void main(String[] args) { //获取一个Stream流 Stream<String>stream= Stream.of("张三","
Stream流常用功能
qq_44880019的博客
08-16 676
Stream流常用业务功能 创建Stream public class Main { public static void main(String[] args) { Stream<String> stream1 = Arrays.stream(new String[] { "A", "B", "C" }); Stream<String> stream2 = List.of("X", "Y", "Z").stream(); st
VUE_SSE_js接收读取stream流
分享程序相关知识
05-08 2577
在网络请求中，流(stream)表示持续接收数据的过程，SSE （Server-Sent Events），服务器使用流信息向浏览器推送信息，能够实时地在客户端更新数据而无需刷新页面。不用等待整个响应完成后一次性获取。SSE它基于 HTTP 协议，目前除了 IE/Edge，其他浏览器都支持。使用SSE是在用vue对接智谱.AI的时候，对接智谱.AI使用HTTP调用，调用方式选择sse-invoke : SSE 调用的时候才能实现打字机效果，加强用户体验，缩短用户等待时间。还可以实现天气预报推送等功能。
【Stream流】收集stream流中的结果
qq_41926259的博客
12-29 1705
收集Stream流中的结果 1. 将流中数据收集到集合中 Stream流提供 collect 方法，其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪 种集合中。java.util.stream.Collectors 类提供一些方法，可以作为 Collector接口的实例： public static <T> Collector<T, ?, List<T>> toList() ：转换为 List 集合。
Java之Stream流的获取
m0_63614385的博客
07-29 238
​ 创建一条流水线，并把数据放到流水线上准备进行操作。
Stream-流式处理的常用操作你GET到了吗？
影落离风
03-19 712
Java8的新特性 对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。 借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。 提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使...
Java--stream流 三种获取方式
weixin_41812196的博客
08-04 337
1. 单列获取方式 //单列stream获取方式 ArrayList<String> arr = new ArrayList<>(); arr.add("123"); arr.add("123"); arr.add("123"); arr.add("123"); arr.stream().forEach(s -> System.out.println(s));
使用Stream流，根据条件去重并求数量
weixin_44098457的博客
06-15 2291
使用Stream流，根据条件去重并求数量
stream_get_meta_data 的使用方法及取得相关数据。
烈火成冰
08-22 1463
使用stream_get_meta_data()函数，可以获得网页的各meta项目信息，其中就包括有header的信息，事实上，使用stream_get_meta_dataheader函数获得的信息量更加丰富更加多，为网站开发提供很好的辅助作用。 不过当我第一次接触到stream_get_meta_data时，先是一愣，不是因为它信息量大，而是对返回的数据格式表示迷惑。我们先来看看s
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值