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

文章目录

- 一、创建不可变的集合
- - 1.1为什么创建不可变的集合
  - 1.2 创建List、Set和Map的不可变集合
  - - 1.2.1 创建List的不可变集合
    - 1.2.2 创建Set 的不可变集合
    - 1.2.3 创建Map的不可变集合
- 二、使用集合的Stream 流
- - 2.1 Stream的使用步骤
  - 2.2 Stream的方法
- 三、如何获取Stream 流对象
- 四、练习使用集合的Stream 流

一、创建不可变的集合

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 对象就不可用了

三、如何获取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[]>() {@Overridepublic 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>() { // 键的生成规则@Overridepublic String apply(String s) {return s.split("-")[0];}},new Function<String, Integer>() { // 值的生成规则@Overridepublic Integer apply(String s) {return Integer.parseInt(s.split("-")[2]);}}));System.out.println(map);}
}