工作中遇到的问题：如何根据根据某一字段进行数据去重

package com.javabasic.javabasic.workidea;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private Long id;

    /**
     * 手机号码
     */
    private String phone;

    /**
     * 密码，加密存储
   服务器托管网  */
    private String password;

    /**
     * 昵称，默认是随机字符
     */
    private String nickName;

    /**
     * 用户头像
     */
    private String icon = "";

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;


}

package com.javabasic.javabasic.workidea;

import cn.hutool.core.util.StrUtil;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author: Ambation
 * @Description:
 * @Date Created in 2023-11-16-21:39
 * @Modified By:
 */
public class TestDeWeight {
    public static void main(String[] args) {
        List userList = new ArrayList();
        for (int i = 0; i  hashSet = new HashSet();
        //遍历集合，将phone去重放入hashSet
        for (User user : userList) {
            String phone = user.getPhone();
            if (phone != null && !phone.isEmpty()) {
                hashSet.add(phone);
            }
        }
        //遍历用户集合，如果phone在hashSet中，则将该用户添加到新建的集合中
        ArrayList distictUserList = new ArrayList();
        for (String phone : hashSet) {
            for (User user : userList) {
                String phoneu = user.getPhone();
                if (phoneu != null && !phoneu.isEmpty()) {
                    if (phone.equals(phoneu)) {
                        distictUserList.add(user);
                        break;
                    }
                }
            }
        }
        System.out.println(distictUserList);
        //方法三: stream流进行去重
        userList.stream().collect(
                () -> new HashSet(),
                (hashSet1, user) -> {
                    String phone = user.getPhone();
                    if (phone != null && !phone.isEmpty()) {
                        hashSet1.add(phone);
                    }
                },
                (hashSet1, hashSet2) -> {
                    hashSet1.addAll(hashSet2);
                }
        );
        System.out.println(userList);

        //方法四：stream流分组进行去重
        ArrayList distictUserLists = new ArrayList();
        Map> groupByPhone = userList.stream().filter(u -> StrUtil.isNotBlank(u.getPhone()))
                .collect(Collectors.groupingBy(User::getPhone));
        groupByPhone.forEach((k, v) -> {
            distictUserLists.add(v.get(0));
        });

        System.out.println(distictUserLists);


  服务器托管网      //=====================ChatGTP推荐的方案=====================

        //方法五: 自定义对象进行去重,比较器实现
        Set set = new TreeSet(new MyObjectComparator());
        // 将需要去重的对象添加到set中
        set.addAll(userList);
        System.out.println(set);

        //方法六: 使用stream流进行去重
        /**
         * 在这个示例中，我们通过stream将原始列表转换为流，
         * 然后使用Collectors.toMap方法以Phone字段作为键进行收集。
         * 在这个过程中，我们使用了一个合并函数(existing, replacement) -> existing
         * 来指定如果遇到重复的键时保留已存在的值。
         * 最后，我们取出map的值部分，并再次使用collect方法转换为列表，
         * 得到了根据Phone字段去重后的列表。
         */
        List uniqueObjects = userList.stream()
                .collect(Collectors.toMap(User::getPhone, obj -> obj, (existing, replacement) -> existing))
                .values()
                .stream()
                .collect(Collectors.toList());

        System.out.println(uniqueObjects);
        
        //=====================文心一言 推荐的方案=====================

        //方法七: 使用map进行去重
        Map phoneUserMap = new HashMap();
        for (User user : userList) {
            if (!phoneUserMap.containsKey(user.getPhone())) {
                phoneUserMap.put(user.getPhone(), user);
            }
        }

        // Print out the unique users
        for (User user : phoneUserMap.values()) {
            System.out.println(user);
        }

        //方法八: 使用stream流进行去重
        List uniqueUserList = userList.stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet(Comparator.comparing(User::getPhone))),
                        ArrayList::new));

        // Print out the unique users
        uniqueUserList.forEach(System.out::println);
    }

}

class MyObjectComparator implements Comparator {
    @Override
    public int compare(User o1, User o2) {
        return o1.getPhone().compareTo(o2.getPhone());
    }
}