java 不可变集合的创建和Stream流的使用

已于 2024-06-19 10:05:42 修改
阅读量797 收藏 10
点赞数 22
文章标签： java windows 开发语言
于 2024-06-18 21:14:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51305563/article/details/139781765
版权

文章目录

一、创建不可变的集合

1.1为什么创建不可变的集合

  • 不可变集合是线程安全的，因为它们的状态在创建后不会改变。多个线程可以安全地共享和读取不可变集合，而无需同步。
  • 不可变集合不允许修改，可以安全地缓存和重用
  • 在多线程环境下使用 Stream 时，确保没有其他线程修改源集合

1.2 创建List、Set和Map的不可变集合

1.2.1 创建List的不可变集合
  • 方式一
public class Demo09 {
    public static void main(String[] args) {
        // 创建不可变的List集合
        List<String> list = List.of("张飞","关羽","刘备","曹操","孙权","孙尚香","吕布");

        // 增强for 循环 遍历
        for (String s : list){
            System.out.println(s);
        }

        // 迭代器 遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        list.set(0,"张三"); // 集合不可修改，会报异常
    }
}
  • 方式二
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张飞","关羽","刘备","曹操","孙权","孙尚香","吕布");
        List<String> immutableList = Collections.unmodifiableList(list); // 设置不可变

        // 增强for 循环 遍历
        for (String s : immutableList){
            System.out.println(s);
        }

        // 迭代器 遍历
        Iterator<String> iterator = immutableList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        immutableList.set(0,"张三"); // 集合不可修改会报异常
    }
}
1.2.2 创建Set 的不可变集合
public class Demo09 {
    public static void main(String[] args) {
        // 创建 Set 的不可变集合
        Set<String> set = Set.of("张飞","关羽","刘备","曹操","孙权","孙尚香","吕布");

        // 增强for 循环遍历
        for (String s : set){
            System.out.println(s);
        }

        //  迭代器遍历
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        set.add("诸葛亮"); // 不可变，报异常
    }
}
1.2.3 创建Map的不可变集合
  • 初版，不建议
public class Demo09 {
    public static void main(String[] args) {
        // 创建 Map的不可变集合 最多十个键值对，一般不用这种方式
        Map<String,Object> map1 = Map.of("姓名","张三","年龄",25,"地址","北京");

        // 创建不可变的Map 集合，元素个数不限
        Map<String,Object> map = new HashMap<>();
        map.put("姓名","李四");
        map.put("年龄",25);
        map.put("地址","北京");

        Set<Map.Entry<String,Object>> entrySet = map.entrySet();
        Map.Entry[] arr1 = new Map.Entry[0];
        // 底层会比较 entrySet 和arr1 的长度 ，长度不够会创建新的数组
        Map.Entry[] arrayEntry = entrySet.toArray(arr1); // Entry数组

        Map<String,Object> immutableMap  = Map.ofEntries(arrayEntry); // 不可变集合

        immutableMap.put("工资",10000); // 不支持修改，报异常
    }
}
  • 使用copyOf ，建议
public class Demo09 {
    public static void main(String[] args) {
        // 创建 Map的不可变集合 最多十个键值对，一般不用这种方式
        Map<String,Object> map1 = Map.of("姓名","张三","年龄",25,"地址","北京");

        // 创建不可变的Map 集合，元素个数不限
        Map<String,Object> map = new HashMap<>();
        map.put("姓名","李四");
        map.put("年龄",25);
        map.put("地址","北京");


        Map<String,Object> immutableMap = Map.copyOf(map); // 创建不可变的集合
        // 遍历方式一
        Set<String> ketSet = map.keySet();
        for (String key:ketSet){
            System.out.println(map.get(key));
        }

        // 遍历方式二
        Set<Map.Entry<String,Object>> entrySet = map.entrySet();
        for (Map.Entry entry: entrySet ){
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        immutableMap.put("工资",10000); // 不可变，报异常
    }
}

二、使用集合 的Stream 流

2.1 Stream的使用步骤

获取到集合的Stream 流，相当于流水线 --> 把数据交给流处理 ，帅选，检查等 --> 流返回一个新的集合，流水线产品

  • 获取Stream 对象
  • 使用中间方法处理数据
  • 使用终结方法处理数据
  • 结合lambda表达式，简化操作
  • 终结方法一旦被调用，stream对象也就不可用了

2.2 Stream的方法

  • 常用处理方法（中间过程）,返回Stream对象，链式调用
    图１
  • 终结方法，用于遍历，统计、获取新的集合等，一经调用后Stream 对象就不可用了
    图2

三、如何获取Stream 流对象

  • 单列集合（List/Set）:使用stream方法
  • 双列集合（Map）：不能直接获取，需要转换成Set
  • 数组：Arrays的静态方法stream
  • 一堆零散的数据：Stream 接口的静态方法of

四、练习使用集合的Stream 流

  • 案例一：统计集合中姓张的人数
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = List.of("刘备","关羽","曹操","张飞","李四","张苞");

        long count = list.stream().filter(s->s.startsWith("张"))
                .count();
        System.out.println("姓张的总人数：" + count);
    }
}
  • 案例二:输出集合中所有姓张的人名
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = List.of("刘备","关羽","曹操","张飞","李四","张苞");

        list.stream().filter(s->s.startsWith("张"))
                .forEach(s -> System.out.println(s));
    }
}
  • 案例三：输出前三个人的名字
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = List.of("刘备","关羽","曹操","张飞","李四","张苞");

        list.stream().limit(3)
                .forEach(s -> System.out.println(s));
    }
}
  • 案例四：输出第四个人开始后面所有人的名字
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = List.of("刘备","关羽","曹操","张飞","李四","张苞");

        list.stream().skip(3)
                .forEach(s -> System.out.println(s));
    }
}
  • 案例五：去除重复的人名
public class Demo09 {
    public static void main(String[] args) {
        List<String> list = List.of("刘备","刘备","关羽","曹操","张飞","李四","张苞");

        list.stream().distinct()
                .forEach(s -> System.out.println(s));
    }
}
  • 案例六：合并两个集合
public class Demo09 {
    public static void main(String[] args) {
        List<String> list1 = List.of("刘备","刘备","关羽","曹操","张飞","李四","张苞");

        List<String> list2 = List.of("王五","刘六");

        Stream<String> stringStream =  Stream.concat(list1.stream(),list2.stream());
        stringStream.forEach(s -> System.out.println(s));

    }
}
  • 案例七：将集合的结果保存到数组中
public class Demo09 {
    public static void main(String[] args) {
        List<String> list1 = List.of("刘备","刘备","关羽","曹操","张飞","李四","张苞");

        Object[] objects =  list1.stream()
                            .distinct()
                            .limit(3)
                            .toArray();
        for (Object o : objects){
            System.out.println(o.toString());
        }
    }
  • 案例八：将Stream的处理结果放到集合中
public class Demo09 {
    public static void main(String[] args) {
        List<String> list1 = List.of("刘备", "刘备", "关羽", "曹操", "张飞", "李四", "张苞");

        // 方式一：不指定具体类型的数组
//        Object[] objects = list1.stream()
//                .distinct()
//                .limit(3)
//                .toArray();
//        System.out.println(Arrays.toString(objects));


        // 方式二：指定类型的数组
        String arr[] = list1.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

改成Lamda 表达式

public class Demo09 {
    public static void main(String[] args) {
        List<String> list1 = List.of("刘备", "刘备", "关羽", "曹操", "张飞", "李四", "张苞");

        // 方式一：不指定具体类型的数组
//        Object[] objects = list1.stream()
//                .distinct()
//                .limit(3)
//                .toArray();
//        System.out.println(Arrays.toString(objects));


        // 方式二：指定类型的数组
        String arr[] = list1.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(arr));
    }
}
  • 将数据收集到集合中
public class Demo09 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,"张三丰-男-99","周芷若-女-25","张无忌-男-21");
        Collections.unmodifiableList(arrayList);// 设置为不可变的集合

        // 需求1：把所有的男性收集起来，放到一个List集合中
//        List<String> newList = arrayList.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.contains("男");
//            }
//        }).collect(Collectors.toList());
//    }

    // 需求2：把所有的男性收集起来，放到一个Set集合中
//    Set<String> stringSet = arrayList.stream().filter(s -> s.contains("男"))
//            .collect(Collectors.toSet());
//    System.out.println(stringSet);

    /* 需求3：把所有的男性收集起来，放到一个Map集合中,姓名为键，年龄为值
     toMap的两个参数：参数一：表示键的生成规则,参数二表示值的生成规则
     Function<T, R>的两个参数，T 表示流的数据类型，即apply的参数类型；R表示返回的数据类型，即apply的返回类型
     重要：键不能重复
    */

    Map<String,Integer> map = arrayList.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);
        }
}
小男孩编程
关注
  • 22
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8处理集合的优雅姿势之Stream
08-26
* 通过已有的集合来创建流：可以使用集合的stream方法将一个集合转换成流。 * 通过Stream创建流：可以使用Stream类提供的方法，直接返回一个由指定元素组成的流。 Stream中间操作 Stream有很多中间操作，多个中间...
java Stream 流使用
04-15
Java Stream 流是Java 8引入的一个重要特性，与Lambda表达式一起，为处理集合提供了新的方式。Stream 不是存储数据的容器，而是提供了一种对数据进行操作的抽象概念，它可以来源于数组、集合或其他数据源。Stream ...
JAVA进阶 —— 不可变集合
hdakj22的博客
03-08 643
不可变集合、创建不可变集合的书写格式：List、Set、Map集合如何创建不可变集合？
暑期JAVA学习（14.4）创建不可变集合
xjl243636988的博客
07-08 813
●不可变集合，就是不可被修改的集合。 ●集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。否则报错。●如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。 ●或者当集合对象被不可信的库调用时，不可变形式是安全的。●在List、Set、 Map接口中，都存在of方法，可以创建一个不可变的集合。●这个集合不能添加，不能删除，不能修改。 注意：Set系列集合特点无序，不重复，无索引，在创建不可变的Set集合时，当有两个相同的元素时会报错，即不允许有两个相同的元素...
创建不可变集合
weixin_66344432的博客
06-16 258
不可变集合就是集合的数据一旦确定就不会改变，与普通集合的创建不一样的是，改变数据的赋值方式，
设置不可变集合 java_如何在Java中创建不可变集合
weixin_36249618的博客
02-27 662
每当需要创建在初始化后无法更改的对象时，都可以定义不可变对象。没有创建不可变对象的特定规则，其思想是在初始化后限制对类字段的访问。Set是集合框架中的接口，不允许重复的值。创建不可变集时，您需要牢记以下几点：我们不应该能够从中添加或删除元素。我们应该不能将空值添加到不可变的集合中。一旦创建了一个不可变的集合，就不能向其添加或删除对象，但是可以修改存储在其中的对象。使用Java9的Of()方法Jav...
创建不可变集合，Stream流
weixin_60475929的博客
12-12 375
不可变集合的概念 不可变集合，就是不可被修改的集合 集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。否则报错 创建不可变集合的原因 如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践 或者当集合对象被不可信的库调用时，不可变形式是安全的 如何创建一个不可变集合(JDK9开始才支持) Stream流 案例：体验Strenm流 基础代码 package com.itliuxue.d2_strea...
Java Stream流详解
热门推荐
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
不可变集合、Stream流、异常处理
weixin_43584531的博客
03-13 886
不可变集合的特点？ 定义完成后不可以修改，或者添加、删除 如何创建不可变集合？ List、Set、Map接口中，都存在of方法可以创建不可变集合。 Stream流 在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。 目的：用于简化集合和数组操作的API。 说说Stream流的思想和使用步骤： 先得到集合或者数组的Stream流（就是一根传送带）。流只能使用一次！ 把元素放上去， 然后就用这个Stream流简化的API来方便的操作元素。 1、集合获取
Java不可变集合与Stream流
赵广陆
09-30 1360
目录 1 可变参数 2 创建不可变集合 3 Stream流 3.1 体验Stream流 3.2 Stream流的常见生成方式 3.3 Stream流中间操作方法 3.4 Stream流终结操作方法 3.5 Stream流的收集操作 3.6 Stream流综合练习 1 可变参数 可变参数介绍 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式
guava-stream:用于 Guava 不可变集合的 Java 8 Stream API 收集器
06-23
用于 Guava 不可变集合的 Java 8 Stream API 收集器 在Java 8个流API，你可以收集你的要素Stream采用的的多种方法之一java.util.Collectors类。 要收集java.util.List的元素，您可以这样做： list . stream() . ...
Java8新特性Stream流实例详解
08-29
* 使用并行流并不一定会提高效率，因为 JVM 对数据进行切片和切换线程也是需要时间的。 Stream 的实例详解： * 创建 Stream：通过 Collection 系列提供的 stream() 或 parallelStream() 获取数据流。 * 中间操作：...
Java教程-流介绍和创建
06-16
Java中的流(Stream)是Java 8引入的一个重要特性，它为处理集合提供了声明式和功能式的编程方式。在本文中，我们将深入探讨流的概念、创建流的方法以及它们在实际编程中的应用。 首先，流（Stream）是一种数据结构，...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 902
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 1117
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 354
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 962
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 1079
GeoServerBasePage 登录
探讨 MyBatis 特殊 SQL 执行技巧与注意事项
良月柒
06-18 748
/MyBatis 作为一个灵活的持久层框架，通过提供丰富的动态 SQL 标签、SQL 片段复用、存储过程调用、复杂结果集处理、分页查询和批量操作等功能，使开发者能够高效地实现各种复杂的 SQL 操作。
Stream.sequential()方法创建一个不可变的
06-08
我认为你提到的是Java 8中的`Stream`类的`sequential()`方法。这个方法不会创建一个不可变的流，而是将一个并行流（parallel stream）转换为串行流（sequential stream）。顾名思义，串行流指的是元素在一个线程中依次处理，而并行流则是将元素分成多个子部分，在多个线程中并行处理，以提高处理速度。 在Java 8中，我们可以使用`parallelStream()`方法将一个集合转换为并行流。这样，我们就可以在多个线程中同时处理元素，从而提高处理速度。但是，并行流并不总是比串行流更快，因为在切分元素和合并结果的过程中会涉及到一定的开销。在某些情况下，串行流可能更快。 如果我们希望将一个并行流转换为串行流，可以使用`sequential()`方法。例如，假设我们有一个并行流`stream`，我们可以使用以下代码将其转换为串行流： ``` Stream<T> sequentialStream = stream.sequential(); ``` 这样，我们就可以在一个线程中依次处理元素，而不是在多个线程中并行处理。需要注意的是，`sequential()`方法不会创建一个不可变的流，它只是将一个并行流转换为串行流。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值