public class SetUniqueList<E> extends AbstractSerializableListDecorator<E>
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 | Constructor and Description |
|---|---|
protected |
SetUniqueList(List
Constructor that wraps (not copies) the List and specifies the set to use.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
add(E object)
Adds an element to the list if it is not already present.
|
void |
add(int index, E object)
Adds an element to a specific index in the list if it is not already present.
|
boolean |
addAll(Collection
Adds a collection of objects to the end of the list avoiding duplicates.
|
boolean |
addAll(int index, Collection
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
|
boolean |
containsAll(Collection
|
protected Set |
createSetBasedOnList(Set
|
Iterator |
iterator()
|
ListIterator |
listIterator()
|
ListIterator |
listIterator(int index)
|
E |
remove(int index)
|
boolean |
remove(Object
|
boolean |
removeAll(Collection
|
boolean |
retainAll(Collection
|
E |
set(int index, E object)
Sets the value at the specified index avoiding duplicates.
|
static <E> SetUniqueList |
setUniqueList(List
Factory method to create a SetList using the supplied list to retain order.
|
List |
subList(int fromIndex, int toIndex)
|
decorated, equals, get, hashCode, indexOf, lastIndexOfisEmpty, setCollection, size, toArray, toArray, toStringclone, finalize, getClass, notify, notifyAll, wait, wait, waitisEmpty, replaceAll, size, sort, spliterator, toArray, toArrayparallelStream, removeIf, streamprotected SetUniqueList(List<E> list, Set <E> set)
The set and list must both be correctly initialised to the same elements.
set - the set to decorate, must not be null
list - the list to decorate, must not be null
NullPointerException - if set or list is null
public static <E> SetUniqueList<E> setUniqueList(List <E> list)
If the list contains duplicates, these are removed (first indexed one kept). A HashSet is used for the set behaviour.
E - the element type
list - the list to decorate, must not be null
SetUniqueList
NullPointerException - if list is null
public boolean add(E 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
Collection<E>
add in interface
List<E>
add in class
AbstractCollectionDecorator<E>
object - the object to add
public void add(int index,
E object)
(Violation) The List interface makes the assumption that the element is always inserted. This may not happen with this implementation.
public boolean addAll(Collection<? extends E> 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
Collection<E>
addAll in interface
List<E>
addAll in class
AbstractCollectionDecorator<E>
coll - the collection to add in iterator order
public boolean addAll(int index,
Collection<? extends E> 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.
public E set(int index, E 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.
public boolean remove(Objectobject)
public E remove(int index)
public boolean removeAll(Collection<?> coll)
public boolean retainAll(Collection<?> coll)
This implementation iterates over the elements of this list, checking each element in turn to see if it's contained in coll. If it's not contained, it's removed from this list. As a consequence, it is advised to use a collection type for coll that provides a fast (e.g. O(1)) implementation of Collection.
public void clear()
public boolean contains(Objectobject)
public boolean containsAll(Collection<?> coll)
public ListIterator<E> listIterator()
public ListIterator<E> listIterator(int index)
public List<E> subList(int fromIndex, int toIndex)
NOTE: from 4.0, an unmodifiable list will be returned, as changes to the subList can invalidate the parent list.