Java 基于列表中的几个对象属性删除重复项

我有一个列表集合，其中每个度量包含多个属性，例如：metricName、命名空间、震源组、类型、组件、firstSeenTime、lastSeenTime等。此列表中有重复项，因此除firstSeenTime和lastSeenTime外，所有属性都相同。我正在寻找一种优雅的方法来过滤这个列表，并且只有在存在这样的重复项时才返回具有最新lastSeenTime的度量

比这更好的东西：

private List<Metric> processResults(List<Metric metrics) {
    List<Metric> results = new ArrayList<>();

    for (Metric incomingMetric: metrics) {

        // We need to implement "contains" below so that only properties
        // other than the two dates are checked.
        if (results.contains(incomingMetric) { 
            int index = results.indexOf(incomingMetric);
            Metric existing = results.get(index); 
            if (incomingMetric.getLastSeen().after(existing.getLastSeen())) {
                results.set(index, metricName);
            } else {
                // do nothing, metric in results is already the latest 
            }
        } else {
            // add incomingMetric to results for the first time
            results.add(incomingMetric);
        }
    }

    return results;
}

---

private List processResults（List我不确定如何生成
List
。但是如果您可以维护一个
Map
而不是该列表，您可以尝试以下方法

因此，此映射的键将是所有需要比较的值的组合（日期属性除外）

键：{metricName}${type}$..”

为此，您可以使用getter在Metric对象中维护另一个属性。当您调用getter时，它将返回键

然后在放入映射之前检查键是否存在。如果存在，则获取该键在映射中存储的度量值，并进行日期比较以查找最新的度量值对象。如果是最新的，则用新对象替换映射的存储对象

PS：对两种情况下的执行时间进行比较。这样你就会找到最佳方法。
我不确定你是如何生成
列表的。但是如果你可以维护
映射，而不是该列表，你可以尝试下面的方法

因此，此映射的键将是所有需要比较的值的组合（日期属性除外）

键：{metricName}${type}$..”

为此，您可以使用getter在Metric对象中维护另一个属性。当您调用getter时，它将返回键

然后在放入映射之前检查键是否存在。如果存在，则获取该键在映射中存储的度量值，并进行日期比较以查找最新的度量值对象。如果是最新的，则用新对象替换映射的存储对象

PS：对这两种情况进行执行时间比较。这样你就会找到最好的方法。
在java中，最优雅的比较方法是界面。你应该使用以下方法删除重复项：

public List<Metric> removeDuplicates(List<Metric> metrics) {

    List<Metric> copy = new ArrayList<>(metrics);
    //first sort the metrics list from most recent to older
    Collections.sort(copy, new SortComparator());

    Set<Metric> set = new TreeSet<Metric>(new Comparator<Metric>() {

        @Override
        public int compare(Metric o1, Metric o2) {
            int result = 0;
            // compare the two metrics given your rules
            return result;
        }
    });

    for(Metric metric : copy) {
        set.add(metric);
    }

    List<Metric> result = Arrays.asList(set.toArray());
    return result;
 }

class SortComparator implements Comparator<Metric> {

    @Override
    public int compare(Metric o1, Metric o2) {
        int result = 0;
        if(o2.getLastSeenTime() != null && o1.getLastSeenTime() != null) {
            result = o2.getLastSeenTime().compareTo(o1.getLastSeenTime());
        }
        return result;
    }

}

public List removeDuplicates（列表度量）{
列表副本=新阵列列表（度量）；
//首先，将度量列表从最新到较旧排序
Collections.sort（copy，new SortComparator（））；
Set Set=新树集（新比较器（）{
@凌驾
公共整数比较（公制o1，公制o2）{
int结果=0；
//比较给定规则的两个指标
返回结果；
}
});
用于（公制：副本）{
集合。添加（公制）；
}
列表结果=Arrays.asList（set.toArray（））；
返回结果；
}
类SortComparator实现Comparator{
@凌驾
公共整数比较（公制o1，公制o2）{
int结果=0；
if（o2.getLastSeenTime（）！=null和&o1.getLastSeenTime（）！=null）{
结果=o2.getLastSeenTime（）。与（o1.getLastSeenTime（））相比；
}
返回结果；
}
}

这种方法的优点在于，您可以编写一系列比较器，并提供一个在运行时选择最佳方法来比较度量，并在运行时条件中删除或不删除重复的实例：

public void removeDuplicates(List<Metric> metrics, Comparator<Metric> comparator) {

    List<Metric> copy = new ArrayList<>(metrics);
    Collections.sort(copy, new SortComparator());

    Set<Metric> set = new TreeSet<Metric>(comparator);
    for(Metric metric : copy) {
        set.add(metric);
    }
    List<Object> result = Arrays.asList(set.toArray());
    return result;
 }

public void removeDuplicates（列出度量、比较器）{
列表副本=新阵列列表（度量）；
Collections.sort（copy，new SortComparator（））；
Set=新树集（比较器）；
用于（公制：副本）{
集合。添加（公制）；
}
列表结果=Arrays.asList（set.toArray（））；
返回结果；
}
在java中，比较事物最优雅的方式是界面。您应该使用以下方法删除重复项：

public List<Metric> removeDuplicates(List<Metric> metrics) {

    List<Metric> copy = new ArrayList<>(metrics);
    //first sort the metrics list from most recent to older
    Collections.sort(copy, new SortComparator());

    Set<Metric> set = new TreeSet<Metric>(new Comparator<Metric>() {

        @Override
        public int compare(Metric o1, Metric o2) {
            int result = 0;
            // compare the two metrics given your rules
            return result;
        }
    });

    for(Metric metric : copy) {
        set.add(metric);
    }

    List<Metric> result = Arrays.asList(set.toArray());
    return result;
 }

class SortComparator implements Comparator<Metric> {

    @Override
    public int compare(Metric o1, Metric o2) {
        int result = 0;
        if(o2.getLastSeenTime() != null && o1.getLastSeenTime() != null) {
            result = o2.getLastSeenTime().compareTo(o1.getLastSeenTime());
        }
        return result;
    }

}

public List removeDuplicates（列表度量）{
列表副本=新阵列列表（度量）；
//首先，将度量列表从最新到较旧排序
Collections.sort（copy，new SortComparator（））；
Set Set=新树集（新比较器（）{
@凌驾
公共整数比较（公制o1，公制o2）{
int结果=0；
//比较给定规则的两个指标
返回结果；
}
});
用于（公制：副本）{
集合。添加（公制）；
}
列表结果=Arrays.asList（set.toArray（））；
返回结果；
}
类SortComparator实现Comparator{
@凌驾
公共整数比较（公制o1，公制o2）{
int结果=0；
if（o2.getLastSeenTime（）！=null和&o1.getLastSeenTime（）！=null）{
结果=o2.getLastSeenTime（）。与（o1.getLastSeenTime（））相比；
}
返回结果；
}
}

这种方法的优点在于，您可以编写一系列比较器，并提供一个在运行时选择最佳方法来比较度量，并在运行时条件中删除或不删除重复的实例：

public void removeDuplicates(List<Metric> metrics, Comparator<Metric> comparator) {

    List<Metric> copy = new ArrayList<>(metrics);
    Collections.sort(copy, new SortComparator());

    Set<Metric> set = new TreeSet<Metric>(comparator);
    for(Metric metric : copy) {
        set.add(metric);
    }
    List<Object> result = Arrays.asList(set.toArray());
    return result;
 }

public void removeDuplicates（列出度量、比较器）{
列表副本=新阵列列表（度量）；
Collections.sort（copy，new SortComparator（））；
Set=新树集（比较器）；
用于（公制：副本）{
集合。添加（公制）；
}
列表结果=Arrays.asList（set.toArray（））；
返回结果；
}
谢谢你的回答。我选择了map方法，因为它不需要额外的排序和拷贝

@VisibleForTesting
Set<Metric> removeDuplicates(List<Metric> metrics) {

Map<RawMetric, Metric> metricsMap = new HashMap<>();
for (Metric metric : metrics) {
    RawMetric rawMetric = RawMetric.builder()
            .metricName(metric.getName())
            .metricType(metricName.getMetricType())
            ... // and more
            .build();

        // pick the latest updated metric (based on lastSeen date)
        BiFunction<RawMetric, Metric, Metric> biFunction =
            (k, v) -> Metric.builder()
                    .name(k.getMetricName())
                    .metricType(k.getMetricType())
                    ... // and more                        
                    .lastSeen(v.getLastSeen().after(
                        metricName.getLastSeen()) ? v.getLastSeen() : 
                            metricName.getLastSeen())
                    .firstSeen(v.getFirstSeen())
                    .build();

        metricsMap.putIfAbsent(rawMetric, metric);
        metricsMap.computeIfPresent(rawMetric, biFunction);
    }

    return ImmutableSet.copyOf(metricsMap.values());
}

@Value
@Builder
static class RawMetricName {
    private String metricName;
    private String metricType;
    private String ad;
    private String project;
    private String fleet;
    private String host;
    private int granularity;
}

@VisibleForTesting
设置移除的副本（列出度量）{
Map metricsMap=新HashMap（）；
对于（度量：度量）{
RawMetric RawMetric=RawMetric.builder（）
.metricName（metric.getName（））
.metricType（metricName.getMetricType（））
…//还有更多
.build（）；
//选择最新更新的度量值（基于上次看到的日期）
双功能双功能=
（k，v）->Metric.builder（）
N