Java之Stream流

已于 2023-12-16 17:23:23 修改
阅读量1.3k 收藏 22
点赞数 28
分类专栏： Java基础 文章标签： java 开发语言
于 2023-12-15 08:30:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lghlhg/article/details/134999880
版权

目录

一、什么是Stream流

二、Stream流的使用步骤

三、Stream流的特点

四、获取流的方式

五、Stream流的中间方法

六、Stream流的终结方法

一、什么是Stream流

        Stream是一种处理集合（Collection）数据的方式。Stream可以让我们以一种更简洁的方式对集合进行过滤、映射、排序等操作。

二、Stream流的使用步骤

  1. 先得到一条Stream流，并把数据放上去
  2. 利用Stream流中的API进行各种操作
    1. 中间操作
      1. 过滤（filter）
      2. 去重（distinct）
    2. 终止操作
      • 统计
      • 打印

三、Stream流的特点

  1. 结构化处理：Stream提供了一种结构化的方式来处理集合数据，可以使用一系列的操作来处理数据，而不是通过循环遍历集合。

  2. 链式操作：Stream的操作可以进行链式调用，形成一个操作流水线，每个操作都会作用于前一个操作的结果上。

  3. 惰性求值：Stream的操作是惰性求值的，只有在终止操作时才会触发执行，这样可以避免不必要的计算。

  4. 并行执行：Stream可以以并行的方式执行操作，可以充分利用多核处理器的优势提高程序的性能。

四、获取流的方式

获取方式方法名说明
单列集合default Stream<E> stream()Collection中的默认方法
双列集合无无法直接使用stream流
数组public static <T> Stream<T> stream(T[] array)Arrays工具类中的静态方法
一堆零散数据public static<T> Stream<T> of(T...values)Stream接口中的静态方法
// 单列集合
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d", "e", "f");

Stream<String> stream = list.stream();
stream.forEach(s -> System.out.println(s));
// 双列集合
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
hm.put("ddd", 444);

// 第一种
hm.keySet().stream().forEach(s -> System.out.println(s));

// 第二种
hm.entrySet().stream().forEach(s -> System.out.println(s));
// 数组
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};

Arrays.stream(arr).forEach(s-> System.out.println(s));
// 一堆零散数据
// 必须是同一种数据
Stream.of(1,2,3,4,5,6,7).forEach(s-> System.out.println(s));

Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));

五、Stream流的中间方法

Stream<T> filter(Predicate<? super T> predicate)过滤
Stream<T> limit(long maxSize)获取前几个元素
Stream<T> skip(long n)跳过前几个元素
Stream<T> distinct()元素去重（依赖hashcode和equals方法）
static <T> Stream<T> concat(Stream a,Stream b)合并a和b两个流为一个流
Stream<R> map(Function<T,R> mapper)转换流中的数据类型

注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程

注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

// filter   过滤
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));

// limit    获取前几个元素
list.stream().limit(2).forEach(s -> System.out.println(s));

// skip    跳过前几个元素
list.stream().skip(2).forEach(s -> System.out.println(s));
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "张无忌", "张无忌",  "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");

// distinct     元素去重（依赖hashcode和equals方法）
list1.stream().distinct().forEach(s -> System.out.println(s));

// concat       合并a和b两个流为一个流
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-20", "周芷若-18", "赵敏-19", "张强-30", "张三丰-69", "张翠山-25", "张良-29", "王二麻子-54", "谢广坤-58");

// Stream<R> map(Function<T,R> mapper)	      转换流中的数据类型
// 第一个类型：流中原本的数据类型
// 第二个类型：要转成之后的类型
// apply的形参s：依次表示流里面的每一个数据
// 返回值：表示转换之后的数据

//当map方法执行完毕后，流上的数据就变成了整数
//随意在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在是整数
list.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] arr = s.split("-");
        return Integer.parseInt(arr[1]);
    }
}).forEach(s -> System.out.println(s));

System.out.println("========");

// lambda表达式的形式
list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));

六、Stream流的终结方法

void forEach(Consumer action)遍历
long count()统计
toArray()收集流中的数据，放到数组中
collect(Collector collector)收集流中的数据，放到集合中
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

// void forEach(Consumer action)	    遍历
list.stream().forEach(s -> System.out.println(s));

// long count()	                    统计
long count = list.stream().count();
System.out.println(count);

// toArray()	                        收集流中的数据，放到数组中
Object[] obj = list.stream().toArray();
System.out.println(Arrays.toString(obj));

// IntFunction的泛型：具体类型的数组
// apply的形参：流中数据的个数，要跟数组的长度保持一致
// apply的返回值：具体类型的数组
// 方法体：就是创建数组
String[] arr = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});
System.out.println(Arrays.toString(arr));

// lambda表达式的形式
String[] arr = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr));
// collect(Collector collector)	    收集流中的数据，放到集合中
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-32", "周芷若-女-18", "赵敏-女-19", "张强-男-26", "张三丰-男-45", "张翠山-男-24", "张良-男-23", "王二麻子-男-48", "谢广坤-男-56");


// 收集到List集合
// 收集男性
List<String> collect = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
System.out.println(collect);


// 收集到Set集合中
// 收集男性
// 会去重
Set<String> collect1 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
System.out.println(collect1);


// 收集到Map集合
// 收集男性,键：姓名，值：年龄
// 键不能重复
/*
toMap:参数一表示键的生成规则
      参数二表示值的生成规则
 参数一：
        Function泛型一：表示流中每一个数据的类型
                泛型二：表示map集合中键的数据类型
        apply形参：依次表示流里面的每一个数据
           方法体：生成键的代码
           返回值：已经生成的键
  参数二：
        Function泛型一：表示流中每一个数据的类型
                泛型二：表示map集合中值的数据类型
        apply形参：依次表示流里面的每一个数据
           方法体：生成键的代码
           返回值：已经生成的键
 */
Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(new Function<String, String>() {
    @Override
    public String apply(String s) {
        return s.split("-")[0];
    }
}, new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return Integer.parseInt(s.split("-")[2]);
    }
}));
System.out.println(map);


// lambda表达式的形式
Map<String, Integer> map1 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(
        s -> s.split("-")[0],
        s -> Integer.parseInt(s.split("-")[2])
));
System.out.println(map1);

lambda表达式详解

慎霄
关注
  • 28
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java—Stream流
m0_71012114的博客
08-18 176
本文详细介绍了Stream流的相关知识
Java-Stream流（一）
qq_39495331的博客
09-30 211
什么是流？和IO流有关系吗？ Java在1.8版本引入了流的概念，这个流可不是IO流的流，第一次学的时候我就很容易把这个流和IO流想到一块去，学的时候总是想着它和IO流是不是有什么关系呢？可是学到了后来发现.......什么关系都没有，Java中的流和IO流是截然不同的两个概念，根本不搭边。 那么什么是流呢？ 直接上一大堆概念什么的各位可能会没有耐心看，很罗嗦，所以还是先上代码吧： pu...
Java基础--Stream流
左灯右行的爱情
03-20 1140
加油
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java进阶-Java Stream API详解与使用
最新发布
踏雨歌青春，诗酒趁年华
04-28 8263
本文全面介绍了 Java Stream API 的概念、功能以及如何在 Java 中有效地使用它进行集合和数据流的处理。通过详细解释和示例，文章展示了 Java Stream API 在简化代码、提高效率以及支持函数式编程方面的优势。文中还比较了 Java Stream API 与其他集合处理库的异同，强调了其在现代 Java 开发中的重要性和实用性。
Java8中的Stream API详解:Stream的背景及使用
Rico's Blogs
03-15 7万+
摘要： 　　 　　Stream是Java8的一大亮点，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的 聚合操作（aggregate operation）或者大批量数据操作。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来...
Java中Stream流详解
weixin_52357829的博客
06-12 1万+
Stream是Java 8中非常重要的一个API，可以极大地方便我们对列表、集合等数据源进行连续操作。Stream操作可以极大地简化我们的代码，提高效率，因此在Java编程中应该熟练使用Stream。需要注意的是，在对Stream进行操作时，应该注意Stream的惰性计算特性，以避免不必要的计算开销。
Java - Stream流详解
weixin_73869209的博客
06-05 1万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。
Java---Stream流技术（全网最详细）
qq_64847107的博客
07-30 7526
流是Java 8 API添加的一个新的抽象，称为流Stream，以一种声明性方式处理数据集合（侧重对于源数据计算能力的封装，并且支持序列与并行两种操作方式）Stream流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算Stream流是对集合（Collection）对象功能的增强，与结合，可以提高编程效率、间接性和程序可读性。
Java之Stream流初识
12-22
1.Stream流引入 Stream流完全不是I/O流，按照流水线处理方式来考虑代码中的思想。 JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，可以提高效率。 Stream流中使用了大量Lambda...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
JavaStream流
08-22
Java Stream流 详细文档
Java8之Stream流代替For循环操作
08-24
Java8之Stream流代替For循环操作 Java8中引入了Stream流代替For循环操作，具有很好的参考价值，希望对大家有所帮助。Stream流代替For循环进行输出可以使代码更简洁。 Stream流的优点 1. 代码简洁：使用Stream流...
Java-Stream详解
yueerba126的博客
06-30 6415
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Java的Stream流详细讲解
qq_45443475的博客
06-28 9192
Java的Stream流详细讲解
Java Stream流详解
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
java之stream流常用方法
01-12
以下是Java中Stream流的常用方法： 1. filter()方法：根据指定的条件过滤流中的元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); ``` 2. map()方法：将流中的每个元素映射为另一个元素。 ```java List<String> names = Arrays.asList("John", "Tom", "Jerry"); List<Integer> nameLengths = names.stream() .map(String::length) .collect(Collectors.toList()); ``` 3. sorted()方法：对流中的元素进行排序。 ```java List<Integer> numbers = Arrays.asList(5,3, 1, 4, 2); List<Integer> sortedNumbers = numbers.stream() .sorted() .collect(Collectors.toList()); ``` 4. distinct()方法：去除流中的重复元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4, 5); List<Integer> distinctNumbers = numbers.stream() .distinct() .collect(Collectors.toList()); ``` 5. limit()方法：限制流中元素的数量。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> limitedNumbers = numbers.stream() .limit(3) .collect(Collectors.toList()); ``` 6. skip()方法：跳过流中的前几个元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> skippedNumbers = numbers.stream() .skip(2) .collect(Collectors.toList()); ``` 7. forEach()方法：对流中的每个元素执行指定的操作。 ```java List<String> names = Arrays.asList("John", "Tom", "Jerry"); names.stream() .forEach(System.out::println); ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值