我有一个ArrayList，里面填充了属性名称和时间的对象。我想根据名称删除重复项，并保留最新时间的记录。所以我在我的对象中覆盖了equals和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但是我无法弄清楚我应该如何将时间标准放在那里。
答案 0 :(得分：5)
扩展HashMap并覆盖put方法，仅在新对象比现有对象更新时才放置。
或者，您可以创建自己的专用容器，该容器将由HashMap支持，就像某些Stack的实施由LinkedList
这是一个模拟代码：
import java.util.HashMap;
import java.util.Map;
public class TimeMap<K, V> {
private Map<K, V> timeMap;
public TimeMap() {
this.timeMap = new HashMap<K, V>();
}
public void put(K key, V value) {
if (isNewer(key, value)) {
this.timeMap.put(key, value);
}
}
}
答案 1 :(得分：4)
你有两种方式，一种是需要理解这些工作的方式，另一种是对那些对Java Collections有更多了解的人更容易理解的方法：
如果你想简单一点，你可以简单地读一下Javadoc of Set，http://docs.oracle.com/javase/6/docs/api/java/util/Set.html#add(E）。它清楚地表明，如果一个元素已经在里面，它将不再被添加。
通过这种方式，您第一次将项目添加到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();
}
}
答案 2 :(得分：2)
为什么不使用Set和字母：
new ArrayList(set);
答案 3 :(得分：1)
我建议通过实施Comparable接口使您的课程Comparable。然后在comparetTo()基于名称和时间进行比较，如果对象时间是最近返回1则为0（如果等于）或-1。一旦获得此功能，您可以扩展HashMap 类并覆盖put方法，如。
o1.compareTo(o2) > 0 then simply overwrite the object with latest one.
向@Lopina代码添加逻辑，例如
public class MyHashMap extends HashMap<String, MyClass>{
private Map<String, MyClass> timeMap;
public MyHashMap() {
this.timeMap = new HashMap<String, MyClass>();
}
public MyClass put(String key, MyClass value) {
MyClass obj;
if (isNewer(key, value)) {
System.out.println("count");
obj=this.timeMap.put(key, value);
}else{
obj=value;
}
return obj;
}
private boolean isNewer(String key, MyClass value) {
if(this.timeMap.get(key)==null ||( key.equals(value.getName()))&& (this.timeMap.get(key).compareTo(value))<0)
return true;
else
return false;
}
@Override
public int size() {
return this.timeMap.size();
}
@Override
public MyClass get(Object key) {
return this.timeMap.get(key);
}
}
在MyClass中实现类似的接口并覆盖compareTo方法，如下所示。
@Override
public int compareTo(MyClass o) {
return this.getTime().compareTo(o.getTime());
}
答案 4 :(得分：1)
您可以让您的类实现Comparable接口并进行比较检查您感兴趣的时间戳。如果您再对其进行排序（例如将所有元素放在TreeSet中）然后获取它们只有在它们尚不存在的情况下才一个接一个地出来。像这样：
public void removeDuplicates(List<MyObject> list){
SortedSet<MyObject> sortedSet = new TreeSet<MyObject>();
sortedSet.addAll(list);
//Now clear the list, and start adding them again
list.clear();
for(MyObject obj : sortedSet){
if(!list.contains(obj) {
list.add(obj);
}
}
return list;
}
但是，只有两个时间戳不同的对象不相等时才会有效！ （在equals()意义上的
答案 5 :(得分：1)
快速实现我的想法。
假设ChangedRecentlyTO对象具有name属性。
private List<ChangedRecentlyTO> groupRecords(List<ChangedRecentlyTO> toList) {
Map<String, ChangedRecentlyTO> uniqueMap = new HashMap<String, ChangedRecentlyTO>();
for(ChangedRecentlyTO to : toList) {
if (uniqueMap.containsKey(to.getName())) {
if (uniqueMap.get(to.getName()).getTimeChanged().before(to.getTimeChanged())) {
uniqueMap.put(to.getName(), to);
}
} else {
uniqueMap.put(to.getName(), to);
}
}
return (List<ChangedRecentlyTO>) uniqueMap.values();
}
毕竟，除了不需要覆盖hashcode和equals之外，它与原始实现似乎没有什么不同。
答案 6 :(得分：1)
我写了一个UniqueList类，它扩展了一个ArrayList来支持它的数据，并使用HashSet来有效地拒绝重复。这为手动扫描数据集提供了O（1）随机访问时间和许多其他速度改进。
https://gist.github.com/hopesenddreams/80730eaafdfe816ddbb1
public class UniqueList<T> extends ArrayList<T> implements Set<T>
{
HashMap<T,Integer> hash; // T -> int
public UniqueList()
{
hash = new HashMap<>();
}
/*
* O(n)
* */
@Override
public void add(int location, T object)
{
super.add(location, object);
for( int i = location ; i < size() ; i++ )
{
hash.put(get(i),i);
}
}
/*
* O(1) amortized.
* */
@Override
public boolean add(T object) {
if( hash.containsKey(object) ) return false;
hash.put(object, size());
super.add(object);
return true;
}
/*
* O(MAX(collection.size(),n)) because of the hash-value-shift afterwards.
* */
@Override
public boolean addAll(int location, Collection<? extends T> collection) {
boolean bChanged = false;
for( T t : collection)
{
if( ! hash.containsKey( t ) )
{
hash.put(t, size());
super.add(t);
bChanged = true;
}
}
for( int i = location + collection.size() ; i < size() ; i ++ )
{
hash.put( get(i) , i );
}
return bChanged;
}
/*
* O(collection.size())
* */
@Override
public boolean addAll(Collection<? extends T> collection) {
boolean bChanged = false;
for( T t : collection)
{
if( ! hash.containsKey( t ) )
{
hash.put( t , size() );
super.add(t);
bChanged = true;
}
}
return bChanged;
}
/*
* O(n)
* */
@Override
public void clear() {
hash.clear();
super.clear();
}
/*
* O(1)
* */
@Override
public boolean contains(Object object) {
return hash.containsKey(object);
}
/*
* O(collection.size())
* */
@Override
public boolean containsAll(Collection<?> collection) {
boolean bContainsAll = true;
for( Object c : collection ) bContainsAll &= hash.containsKey(c);
return bContainsAll;
}
/*
* O(1)
* */
@Override
public int indexOf(Object object) {
//noinspection SuspiciousMethodCalls
Integer index = hash.get(object);
return index!=null?index:-1;
}
/*
* O(1)
* */
@Override
public int lastIndexOf(Object object)
{
return hash.get(object);
}
/*
* O(n) because of the ArrayList.remove and hash adjustment
* */
@Override
public T remove(int location) {
T t = super.remove(location);
hash.remove( t );
for( int i = size() - 1 ; i >= location ; i -- )
{
hash.put( get(i) , i );
}
return t;
}
/*
* O(n) because of the ArrayList.remove and hash adjustment
* */
@Override
public boolean remove(Object object) {
Integer i = hash.get( object );
if( i == null ) return false;
remove( i.intValue() );
return true;
}
/*
* O( MAX( collection.size() , ArrayList.removeAll(collection) ) )
* */
@Override
public boolean removeAll(@NonNull Collection<?> collection) {
for( Object c : collection )
{
hash.remove( c );
}
return super.removeAll( collection );
}
}