【Java基础】集合处理 Stream的使用与正则表达式过滤

Java 8 引入了一个强大的功能Stream()。这个 API 提供了一种新的处理数据的方式，它允许你以一种声明式的、链式的方式来操作集合或数组中的元素，不需要显式地使用循环。Stream() 创建一个流，通常从一个集合（ List、Set 或 Map）中创建一个 Stream 对象，并对其进行各种处理。

json编码与解析

依赖：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

实现:

    public static void fun18() {
        List<String> group1 = new ArrayList<>();
        group1.add("aaa");
        group1.add("bbb");
        group1.add("ccc");
        // json编码
        String s = JSON.toJSONString(group1);
        System.out.println(s);
		// json解码
        List<String> list = JSON.parseObject(s, new TypeReference<List<String>>(){});

        System.out.println(list);
        for (String s1 : list) {
            System.out.println(s1);
        }
    }
    
    public static void main(String[] args) {
        fun18();
    }

这里JSON.toJSONString()是将对象转为JSON字符串

JSON.parseObject(jsonString, new TypeReference<我是对象^_^>(){})是将 JSON字符串 jsonString 转为对象我是对象^_^

运行：

对对象流快速计数

对对象流快速计数，reduce() 用于将一个 Stream 中的所有元素聚合到一起，生成一个单一的值。

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class User {
        private String username;
        public String getUsername() {
            return username;
        }
    }

    public static void fun31() {
        List<User> users = Arrays.asList(
                new User("张三"),
                new User("李四"),
                new User("王五"),
                new User("赵六"),
                new User("田七")
        );

        Optional<Integer> count = users.stream()
                .map((e) -> 1)
                .reduce(Integer::sum); // 这是根据方法引用的第二种格式（即类::静态方法名）来书写成这样的
        System.out.println(count.get());
    }

运行：

两个collection元素打散合并

如果我们有两个集合a，b，我们希望这两个集合的元素快速合并在一个集合中，可以尝试如下操作：

    public static void fun47() {
        List<String> a = List.of("张三", "李四");
        List<String> b = List.of("王五", "赵六");
        List<String> collect = Stream.of(a, b).flatMap(list -> list.stream()).collect(Collectors.toList());
        System.out.println(collect);
    }

结果如下：

[张三, 李四, 王五, 赵六]

Process finished with exit code 0

关键在于flatMap()，它可以把原stream中的所有元素都打散之后组成的Stream

List内部去重 / List转Set的方法

collect() 用于将一个 Stream 中的所有元素收集到一起

实现：

    public static void fun24() {
        List<String> group1 = new ArrayList<>();
        group1.add("aaa");
        group1.add("bbb");
        group1.add("ccc");
        group1.add("ccc");
        System.out.println(group1);

        Set<String> collect1 = group1.stream().collect(Collectors.toSet());
        System.out.println(collect1);

        List<String> collect2 = group1.stream().distinct().collect(Collectors.toList());
        System.out.println(collect2);
    }
    
    public static void main(String[] args) {
        fun24();
    }
    

group1.stream()以序列为基础转stream流

.distinct()每个元素只保留唯一一个，也就是去重。

group1.stream().collect(Collectors.toSet())将stream流重新转为set集合，利用集合的元素唯一性实现list内部去重。

运行：

两个List的元素去重后合并

实现

    public static void fun17() {
        List<String> group1 = new ArrayList<>();
        group1.add("aaa");
        group1.add("bbb");
        group1.add("ccc");
        List<String> group2 = new ArrayList<>();
        group2.add("ccc");
        group2.add("ddd");
        group2.add("eee");

        List<String> group = Stream.of(group1, group2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        System.out.println(group);
    }
    
    public static void main(String[] args) {
        fun17();
    }

这里Stream.of(group1, group2)是将两组List<?>合并为一组List<?>并以Stream类格式返回：Stream<List<?>>

.flatMap()则是将Stream中的每个元素通过.flatMap()中的映射函数处理。

Stream.of(group1, group2).flatMap(Collection::stream)则是对Stream<List<String>>做 Collection::stream 处理，得到：Stream<?>

.distinct()如其名所属，每个元素只保留唯一一个，也就是去重。

.collect(Collectors.toList())则是将Stream<?>重新转为List<?>格式

输出有：

正则表达式软过滤字符

软过滤这个说法是我自己瞎起的，我把错误输入直接抛出异常的情况叫硬过滤，把错误输入转为有效输入的情况叫软过滤

实现：

    public static void fun22() {
        String input = "爱莎萨*（）！@#！%#^&*_=--~`@￥%%……（#DS116194亅7,;';;;'''^[\\u4E00-\\u9FA5]+";
        System.out.println(input);

        System.out.println();
        String s = charSoftFiltering(input);
        System.out.println(s);
    }

    public static String charSoftFiltering(String input) {
        // 正则表达式，只允许中文
        String pattern = "^[\\u4E00-\\u9FA5]+";

        // 匹配当前正则表达式
        Matcher matcher = Pattern.compile(pattern).matcher(input);
        // 定义输出
        String output = "";
        // 判断是否可以找到匹配正则表达式的字符
        if (matcher.find()) {
            // 将匹配当前正则表达式的字符串即文件名称进行赋值
            output = matcher.group();
        }
        return output;
    }

    
    public static void main(String[] args) {
        fun22();
    }

其中Pattern.compile(pattern)将给定的正则表达式编译为模式Pattern。

这里.matcher(input)将给定的输入与模式相匹配。

matcher.find()查找与模式匹配的输入序列的下一个子序列，如果匹配成功，则可以通过开始start、结束end和分组group方法获得更多信息。

matcher.group()返回与上一个匹配项匹配的输入子序列，对于具有输入序列s的匹配器matcher，表达式matcher.group()和s.substring(matcher.start()，matcher.end())等价。

运行：

可以看到成功提取了中文，但是过滤了各种乱码。

List转Map

假设存在类User.java

@Data
public class User {

    private Long id;

    private String userName;

    private Integer age;
}

我们将List<User> users转化为Map<User.属性1, User.属性2> 可以有：

    List<User> users= getUsersList();

    Map<Long, String> userMap = users.stream().collect(Collectors.toMap(
                    key -> key.getId(),
                    value -> value.getUserName()
            ));

参考

https://blog.csdn.net/fzy629442466/article/details/84629422

https://blog.csdn.net/genggeonly/article/details/127767804?ops_request_misc=&request_id=&biz_id=102&utm_term

https://blog.csdn.net/mu_wind/article/details/109516995?ops_request_misc=