制作一个唯一的 Java 对象列表

我有一个 ArrayList，其中填充了具有名称和时间属性的对象。我想根据名称删除重复项并仅保留最新时间的记录。所以我已经覆盖了equals and hashcode我的对象中的名称并使用了这样的代码。

private List<ChangedRecentlyTO> groupRecords(List<ChangedRecentlyTO> toList) {
    changedRecentlyList.clear(); //static list
    for(ChangedRecentlyTO to : toList) {
        if(!changedRecentlyList.contains(to)) {
            changedRecentlyList.add(to);
        } else {
            if(changedRecentlyList.get(changedRecentlyList.lastIndexOf(to)).getTimeChanged().before(to.getTimeChanged())) {
                changedRecentlyList.remove(to);
                changedRecentlyList.add(to);
            }
        }
    }
    return changedRecentlyList;
}

但我想知道，是否有更好的解决方案？我正在考虑使用 Set，但我不知道应该如何放置时间标准。

对我来说，有两种方法，一种需要了解集合如何工作，另一种对于对 Java 集合了解较少的人来说更容易理解：

如果你想简单一点，你可以简单地阅读Set的Javadoc的详细内容，http://docs.oracle.com/javase/6/docs/api/java/util/Set.html#add(E http://docs.oracle.com/javase/6/docs/api/java/util/Set.html#add(E）。它明确指出，如果一个元素已经在里面，则不会再次添加。

• 您仅使用名称来实现 equals 和 hashcode
• 您按时间对项目进行排序，然后将它们添加到集合中。

这样，第一次将项目添加到 Set 时，您将添加最新时间的元素。当您添加其他内容时，它们将被忽略，因为它们已经包含在内。

如果其他人不确切知道 java.util.Set 的契约行为，您可能需要扩展 Set 以使您的意图更清晰。但是，由于不应访问 Set 来“删除后取回元素”，因此您需要使用 HashMap 来支持您的集合：

interface TimeChangeable {
   long getTimeChanged();
}
public class TimeChangeableSet<E extends TimeCheangeable> implements Set<E> {

    private final HashMap<Integer,E> hashMap = new HashMap<Integer,E>();

    @Override
    public boolean add(E e) {
        E existingValue = hashMap.remove(e.hashCode());
        if(existingValue==null){
            hashMap.put(e.hashCode(),e);
            return true;
        }
        else{
            E toAdd = e.getTimeChanged() > existingValue.getTimeChanged() ? e : existingValue;
            boolean newAdded = e.getTimeChanged() > existingValue.getTimeChanged() ? true : false;
            hashMap.put(e.hashCode(),e);
            return newAdded;
        }

    }

    @Override
    public int size() {
        return hashMap.size();
    }

    @Override
    public boolean isEmpty() {
        return hashMap.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return hashMap.containsKey(o.hashCode());
    }

    @Override
    public Iterator<E> iterator() {
        return hashMap.values().iterator();
    }

    @Override
    public Object[] toArray() {
        return hashMap.values().toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return hashMap.values().toArray(a);
    }

    @Override
    public boolean remove(Object o) {
        return removeAndGet(o)!=null ? true : false;
    }

    public E removeAndGet (Object o) {
        return hashMap.remove(o.hashCode());
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        boolean containsAll = true;
        for(Object object:c){
            E objectInMap = removeAndGet(object);
            if(objectInMap==null || !objectInMap.equals(object))
                containsAll=false;
        }
        return containsAll;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        boolean  addAll=true;
        for(E e:c){
            if(!add(e)) addAll=false;
        }
        return addAll;

    }

    @Override
    public boolean retainAll(Collection<?> c) {
        boolean setChanged=false;
        for(E e: hashMap.values()){
            if(!c.contains(e)){
                hashMap.remove(e.hashCode());
                setChanged=true;
            }
        }
        return setChanged;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        throw new UnsupportedOperationException("Please do not use type-unsafe methods in 2012");
    }

    @Override
    public void clear() {
        hashMap.clear();
    }




}