Hey all,
I know about SortedSet, but in my case I need something that implements List, and not Set. So is there an implementation out there, in the API or elsewhere?
It shouldn't be hard to implement myself, but I figured why not ask people here first?
thanks,
Yuval =8-)
Why not encapsulate a set with a list, sort like:
new ArrayList( new HashSet() )
This leaves the other implementation for someone who is a real master of Collections ;-)
The documentation (http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html) says: "Set — a collection that cannot contain duplicate elements" "List — an ordered collection (sometimes called a sequence). Lists can contain duplicate elements."
So if you don't want duplicates, you probably shouldn't use a list.
There's no Java collection in the standard library to do this. LinkedHashSet preserves ordering similarly to a List, though, so if you wrap your set in a List when you want to use it as a List you'll get the semantics you want.
Alternatively, the Commons Collections (or collections15, for the generic version) has a List which does what you want already: SetUniqueList.
Off the top of my head, lists allow duplicates. You could quickly implement a UniqueArrayList and override all the add / insert functions to check for 'contains()' before you call the inherited methods. For personal use, you could only implement the 'add' method you use, and override the others to throw an exception in case future programmers try to use the list in a different manner.
So here's what I did eventually. I hope this helps someone else.
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);
}
}
}
Yuval =8-)
You should seriously consider dhiller's answer:
new ArrayList(set) (or a new LinkedList(set), whatever).I think that the solution you posted with the NoDuplicatesList has some issues, mostly with the contains() method, plus your class does not handle checking for duplicates in the Collection passed to your addAll() method.
Hi all, I needed something like that, so I went to the commons collections and used the SetUniqueList, but when I ran some performance test, I found that it seems not optimized comparing to the case if I want to use a Set and obtain an Array using the Set.toArray() method, the SetUniqueTest took 20:1 time to fill and then traverse 100,000 Strings comparing to the other implementaion, which is a big deal difference, so If you worry about the performance, I recommend you to use the Set and get a Array instead of using the SetUniqueList, unless you really need the logic of the SetUniqueList, then you need to check other solutions...
The testing code main method:
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
}
Regards Mohammed Sleem http://abusleem.net/blog