Java8根据对象中的属性进行去重

Java8根据对象中的属性进行去重

单个属性去重

定义去重方法

package com.kang.grafana.distinct.utils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * @Author Emperor Kang
 * @ClassName DistinctUtil
 * @Description TODO
 * @Date 2023/9/8 18:03
 * @Version 1.0
 * @Motto 让营地比你来时更干净
 */
public class DistinctUtil {
    /**
     * 1.这个示例中，distinctByKey()方法使用一个Map来存储已经看到的对象属性值。
     * 当新的对象传入时，会先检查该属性值是否已经在Map中存在，如果存在，返回false（表示不应该包含在结果中），
     * 如果不存在，则添加到Map中并返回true
     * @param keyExtractor
     * @param <T>
     * @return
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}

定义对象

package com.kang.grafana.distinct.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

/**
 * @Author Emperor Kang
 * @ClassName MyObject
 * @Description TODO
 * @Date 2023/9/8 18:02
 * @Version 1.0
 * @Motto 让营地比你来时更干净
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class MyObject {
    private int id;
    private String name;
    private String address;
    private String school;
}

测试

package com.kang.grafana.distinct.test;

import com.kang.grafana.distinct.pojo.MyObject;
import com.kang.grafana.distinct.utils.DistinctUtil;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author Emperor Kang
 * @ClassName DistinctUtilTest
 * @Description TODO
 * @Date 2023/9/8 18:08
 * @Version 1.0
 * @Motto 让营地比你来时更干净
 */
public class DistinctUtilTest {
    public static void main(String[] args) {
        List<MyObject> list = Arrays.asList(
                new MyObject(1, "Object1","Object1","Object1"),
                new MyObject(2, "Object2","Object2","Object2"),
                new MyObject(3, "Object3","Object3","Object3"),
                new MyObject(1, "Object4","Object4","Object4"));
        List<MyObject> distinctList = list.stream()
                .filter(DistinctUtil.distinctByKey(MyObject::getId)) // 过滤去重
                .collect(Collectors.toList());

        // 打印去重后的列表
        for (MyObject obj : distinctList) {
            System.out.println(obj.getId() + " " + obj.getName());
        }
    }
}

多个属性去重

  LinkedHashMap<String, MyObject> myObjectLinkedHashMap = list.stream().collect(Collectors.toMap(p -> p.getAddress() + "_" + p.getName(),
                Function.identity(),   // x -> x 防止元素顺序改变
                (oldValue, newValue) -> oldValue,  // 合并函数（oldValue, newValue -> oldValue）来选择保留哪个对象
                LinkedHashMap::new));
        List<MyObject> uueMyObject = new ArrayList<>(myObjectLinkedHashMap.values());

• 这个示例中，我们使用Collectors.toMap来创建一个map，其键是由Person的name和age属性组成的字符串，而值就是Person对象本身。如果在去重过程中发现了相同的键（即，相同的name和age），则使用提供的合并函数（oldValue, newValue -> oldValue）来选择保留哪个Person对象。最后，我们通过将map的值转换为一个新的列表来获取去重后的Person列表。

• 注意，这种方法仅在属性组合的hashcode和equals方法正确实现的情况下有效。对于没有正确实现这些方法的自定义类，你可能需要提供自定义的去重逻辑。