我知道SortedSet，但就我而言，我需要实现List 的东西，而不是Set。那么在 API 或其他地方是否有实现？
自己实现应该不难，但我想为什么不先在这里问人呢？
【问题讨论】：
标签： java list collections duplicates
标准库中没有用于执行此操作的 Java 集合。 LinkedHashSet<E> 保留了与 List 类似的顺序，因此，如果您将集合包装在 List 中，当您想将其用作 List 时，您将获得所需的语义。
或者，Commons Collections（或commons-collections4，对于通用版本）有一个List，它可以满足您的需求：SetUniqueList/SetUniqueList<E>。
【讨论】：
这就是我所做的，它确实有效。
假设我有一个ArrayList 可以使用，我做的第一件事就是创建一个新的LinkedHashMap。
LinkedHashSet<E> hashSet = new LinkedHashSet<E>()
然后我尝试将我的新元素添加到LinkedHashSet。 add 方法不会改变 LinkedHasSet 并且如果新元素是重复的则返回 false。所以这成为我可以在添加到ArrayList 之前测试的条件。
if (hashSet.add(E)) arrayList.add(E);
这是防止将重复项添加到数组列表中的一种简单而优雅的方法。如果您愿意，可以将其封装在扩展 ArrayList 的类中并覆盖 add 方法。只要记住通过循环遍历元素并调用 add 方法来处理addAll。
【讨论】：
这就是我最终所做的。我希望这对其他人有帮助。
class NoDuplicatesList<E> extends LinkedList<E> {
@Override
public boolean add(E e) {
if (this.contains(e)) {
return false;
}
else {
return super.add(e);
}
}
@Override
public boolean addAll(Collection<? extends E> collection) {
Collection<E> copy = new LinkedList<E>(collection);
copy.removeAll(this);
return super.addAll(copy);
}
@Override
public boolean addAll(int index, Collection<? extends E> collection) {
Collection<E> copy = new LinkedList<E>(collection);
copy.removeAll(this);
return super.addAll(index, copy);
}
@Override
public void add(int index, E element) {
if (this.contains(element)) {
return;
}
else {
super.add(index, element);
}
}
}
【讨论】：
Set<Integer> 来解决，该Set<Integer> 存储元素的哈希码（而不是搜索整个列表） -当然，这将需要所有元素正确实现 hashCode()，但是使用 Lombok 等辅助框架，这真的没问题……实际上，这有点微不足道。甚至可以使用用于 hashCodes 的红/黑树来优化 那个 解决方案......小的内存开销以获得大的性能提升；欢迎来到云计算的世界；-)
为什么不用列表封装一个集合，排序如下：
new ArrayList( new LinkedHashSet() )
这将其他实现留给真正的收藏大师;-)
【讨论】：
你应该认真考虑 dhiller 的回答：
new ArrayList(set)（或 new LinkedList(set) 等）中。我认为您使用NoDuplicatesList 发布的解决方案存在一些问题，主要是contains() 方法，而且您的类不处理传递给addAll() 方法的集合中的重复项检查。
【讨论】：
我需要类似的东西，所以我去了 commons 集合 并使用了 SetUniqueList，但是当我进行一些性能测试时，我发现它似乎没有优化我想使用Set 并使用Set.toArray() 方法获得Array。
与其他实现相比，SetUniqueTest 花了 20:1 时间 填充然后遍历 100,000 个字符串，这是一个很大的不同。
所以，如果你担心性能，我建议你使用Set and Get an Array而不是使用SetUniqueList，除非你真的需要SetUniqueList的逻辑，那么您需要检查其他解决方案...
测试代码主方法：
public static void main(String[] args) {
SetUniqueList pq = SetUniqueList.decorate(new ArrayList());
Set s = new TreeSet();
long t1 = 0L;
long t2 = 0L;
String t;
t1 = System.nanoTime();
for (int i = 0; i < 200000; i++) {
pq.add("a" + Math.random());
}
while (!pq.isEmpty()) {
t = (String) pq.remove(0);
}
t1 = System.nanoTime() - t1;
t2 = System.nanoTime();
for (int i = 0; i < 200000; i++) {
s.add("a" + Math.random());
}
s.clear();
String[] d = (String[]) s.toArray(new String[0]);
s.clear();
for (int i = 0; i < d.length; i++) {
t = d[i];
}
t2 = System.nanoTime() - t2;
System.out.println((double)t1/1000/1000/1000); //seconds
System.out.println((double)t2/1000/1000/1000); //seconds
System.out.println(((double) t1) / t2); //comparing results
}
问候， Mohammed Sleem
【讨论】：
注意：它不考虑 subList 实现。
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
public class UniqueList<T> extends ArrayList<T> {
private static final long serialVersionUID = 1L;
/** Unique elements SET */
private final Set<T> set=new HashSet();
/** Used by addAll methods */
private Collection<T> addUnique(Collection<? extends T> col) {
Collection<T> unique=new ArrayList();
for(T e: col){
if (set.add(e)) unique.add(e);
}
return unique;
}
@Override
public boolean add(T e) {
return set.add(e) ? super.add(e) : false;
}
@Override
public boolean addAll(Collection<? extends T> col) {
return super.addAll(addUnique(col));
}
@Override
public void add(int index, T e) {
if (set.add(e)) super.add(index, e);
}
@Override
public boolean addAll(int index, Collection<? extends T> col) {
return super.addAll(index, addUnique(col));
}
}
【讨论】：
documentation for collection interfaces 说：
Set — 一个不能包含重复元素的集合。
List — 有序集合（有时称为序列）。列表可以包含重复的元素。
因此，如果您不想重复，则可能不应该使用列表。
【讨论】：
这个呢？ 只需检查列表，然后再添加包含现有对象的内容
while (searchResult != null && searchResult.hasMore()) {
SearchResult nextElement = searchResult.nextElement();
Attributes attributes = nextElement.getAttributes();
String stringName = getAttributeStringValue(attributes, SearchAttribute.*attributeName*);
if(!List.contains(stringName)){
List.add(stringName);
}
}
【讨论】：
在add 方法中，为什么不使用HashSet.add() 而不是HashSet.consist() 来检查重复项。
如果没有重复，HashSet.add() 将返回 true，否则返回 false。
【讨论】：
HashSet#consist() 是什么？
在我的脑海中，列表允许重复。在调用继承的方法之前，您可以快速实现 UniqueArrayList 并覆盖所有 add / insert 函数以检查 contains()。对于个人使用，您只能实现您使用的 add 方法，并覆盖其他方法以引发异常，以防将来的程序员尝试以不同的方式使用该列表。
【讨论】：
我刚刚在自己的小库中创建了自己的 UniqueList，如下所示：
package com.bprog.collections;//my own little set of useful utilities and classes
import java.util.HashSet;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Jonathan
*/
public class UniqueList {
private HashSet masterSet = new HashSet();
private ArrayList growableUniques;
private Object[] returnable;
public UniqueList() {
growableUniques = new ArrayList();
}
public UniqueList(int size) {
growableUniques = new ArrayList(size);
}
public void add(Object thing) {
if (!masterSet.contains(thing)) {
masterSet.add(thing);
growableUniques.add(thing);
}
}
/**
* Casts to an ArrayList of unique values
* @return
*/
public List getList(){
return growableUniques;
}
public Object get(int index) {
return growableUniques.get(index);
}
public Object[] toObjectArray() {
int size = growableUniques.size();
returnable = new Object[size];
for (int i = 0; i < size; i++) {
returnable[i] = growableUniques.get(i);
}
return returnable;
}
}
我有一个如下所示的 TestCollections 类：
package com.bprog.collections;
import com.bprog.out.Out;
/**
*
* @author Jonathan
*/
public class TestCollections {
public static void main(String[] args){
UniqueList ul = new UniqueList();
ul.add("Test");
ul.add("Test");
ul.add("Not a copy");
ul.add("Test");
//should only contain two things
Object[] content = ul.toObjectArray();
Out.pl("Array Content",content);
}
}
工作正常。它所做的只是将它添加到一个集合中，如果它还没有它并且有一个可返回的 Arraylist 以及一个对象数组。
【讨论】：