public class SetUniqueList extends AbstractSerializableListDecorator
List to ensure that no duplicates are present
 much like a Set.
 
 The List interface makes certain assumptions/requirements.
 This implementation breaks these in certain ways, but this is merely the
 result of rejecting duplicates.
 Each violation is explained in the method, but it should not affect you.
 Bear in mind that Sets require immutable objects to function correctly.
 
 The ListOrderedSet
 class provides an alternative approach, by wrapping an existing Set and
 retaining insertion order in the iterator.
 
This class is Serializable from Commons Collections 3.1.
| Modifier and Type | Field and Description | 
|---|---|
protected Set | 
set
Internal Set to maintain uniqueness. 
 | 
collection| Modifier | Constructor and Description | 
|---|---|
protected  | 
SetUniqueList(List list,
             Set set)
Constructor that wraps (not copies) the List and specifies the set to use. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
add(int index,
   Object object)
Adds an element to a specific index in the list if it is not already present. 
 | 
boolean | 
add(Object object)
Adds an element to the list if it is not already present. 
 | 
boolean | 
addAll(Collection coll)
Adds an element to the end of the list if it is not already present. 
 | 
boolean | 
addAll(int index,
      Collection coll)
Adds a collection of objects a specific index in the list avoiding 
 duplicates. 
 | 
Set | 
asSet()
Gets an unmodifiable view as a Set. 
 | 
void | 
clear()  | 
boolean | 
contains(Object object)  | 
boolean | 
containsAll(Collection coll)  | 
protected Set | 
createSetBasedOnList(Set set,
                    List list)
 | 
static SetUniqueList | 
decorate(List list)
Factory method to create a SetList using the supplied list to retain order. 
 | 
Iterator | 
iterator()  | 
ListIterator | 
listIterator()  | 
ListIterator | 
listIterator(int index)  | 
Object | 
remove(int index)  | 
boolean | 
remove(Object object)  | 
boolean | 
removeAll(Collection coll)  | 
boolean | 
retainAll(Collection coll)  | 
Object | 
set(int index,
   Object object)
Sets the value at the specified index avoiding duplicates. 
 | 
List | 
subList(int fromIndex,
       int toIndex)  | 
get, getList, indexOf, lastIndexOfequals, getCollection, hashCode, isEmpty, size, toArray, toArray, toStringprotected final Set set
protected SetUniqueList(List list, Set set)
The set and list must both be correctly initialised to the same elements.
set - the set to decorate, must not be nulllist - the list to decorate, must not be nullIllegalArgumentException - if set or list is nullpublic static SetUniqueList decorate(List list)
 If the list contains duplicates, these are removed (first indexed one kept).
 A HashSet is used for the set behaviour.
list - the list to decorate, must not be nullIllegalArgumentException - if list is nullpublic Set asSet()
public boolean add(Object object)
 (Violation)
 The List interface requires that this method returns
 true always. However this class may return false
 because of the Set behaviour.
add in interface Collectionadd in interface Listadd in class AbstractCollectionDecoratorobject - the object to addpublic void add(int index,
       Object object)
 (Violation)
 The List interface makes the assumption that the element is
 always inserted. This may not happen with this implementation.
add in interface Listadd in class AbstractListDecoratorindex - the index to insert atobject - the object to addpublic boolean addAll(Collection coll)
 (Violation)
 The List interface makes the assumption that the element is
 always inserted. This may not happen with this implementation.
addAll in interface CollectionaddAll in interface ListaddAll in class AbstractCollectionDecoratorcoll - the collection to addpublic boolean addAll(int index,
             Collection coll)
Only elements that are not already in this list will be added, and duplicates from the specified collection will be ignored.
 (Violation)
 The List interface makes the assumption that the elements
 are always inserted. This may not happen with this implementation.
addAll in interface ListaddAll in class AbstractListDecoratorindex - the index to insert atcoll - the collection to add in iterator orderpublic Object set(int index, Object object)
The object is set into the specified index. Afterwards, any previous duplicate is removed If the object is not already in the list then a normal set occurs. If it is present, then the old version is removed.
set in interface Listset in class AbstractListDecoratorindex - the index to insert atobject - the object to setpublic boolean remove(Object object)
remove in interface Collectionremove in interface Listremove in class AbstractCollectionDecoratorpublic Object remove(int index)
remove in interface Listremove in class AbstractListDecoratorpublic boolean removeAll(Collection coll)
removeAll in interface CollectionremoveAll in interface ListremoveAll in class AbstractCollectionDecoratorpublic boolean retainAll(Collection coll)
retainAll in interface CollectionretainAll in interface ListretainAll in class AbstractCollectionDecoratorpublic void clear()
clear in interface Collectionclear in interface Listclear in class AbstractCollectionDecoratorpublic boolean contains(Object object)
contains in interface Collectioncontains in interface Listcontains in class AbstractCollectionDecoratorpublic boolean containsAll(Collection coll)
containsAll in interface CollectioncontainsAll in interface ListcontainsAll in class AbstractCollectionDecoratorpublic Iterator iterator()
iterator in interface Iterableiterator in interface Collectioniterator in interface Listiterator in class AbstractCollectionDecoratorpublic ListIterator listIterator()
listIterator in interface ListlistIterator in class AbstractListDecoratorpublic ListIterator listIterator(int index)
listIterator in interface ListlistIterator in class AbstractListDecoratorpublic List subList(int fromIndex, int toIndex)
subList in interface ListsubList in class AbstractListDecoratorCopyright © 2001–2015 The Apache Software Foundation. All rights reserved.