|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.apache.commons.collections4.collection.AbstractCollectionDecorator<E>
org.apache.commons.collections4.list.AbstractListDecorator<E>
org.apache.commons.collections4.list.AbstractSerializableListDecorator<E>
org.apache.commons.collections4.list.SetUniqueList<E>
public class SetUniqueList<E>
Decorates a 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.
Constructor Summary | |
---|---|
protected |
SetUniqueList(List<E> list,
Set<E> set)
Constructor that wraps (not copies) the List and specifies the set to use. |
Method Summary | ||
---|---|---|
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<? extends E> coll)
Adds a collection of objects to the end of the list avoiding duplicates. |
|
boolean |
addAll(int index,
Collection<? extends E> coll)
Adds a collection of objects a specific index in the list avoiding duplicates. |
|
Set<E> |
asSet()
Gets an unmodifiable view as a Set. |
|
void |
clear()
|
|
boolean |
contains(Object object)
|
|
boolean |
containsAll(Collection<?> coll)
|
|
protected Set<E> |
createSetBasedOnList(Set<E> set,
List<E> list)
Create a new Set with the same type as the provided set
and populate it with all elements of list . |
|
Iterator<E> |
iterator()
|
|
ListIterator<E> |
listIterator()
|
|
ListIterator<E> |
listIterator(int index)
|
|
E |
remove(int index)
|
|
boolean |
remove(Object object)
|
|
boolean |
removeAll(Collection<?> coll)
|
|
boolean |
retainAll(Collection<?> coll)
|
|
E |
set(int index,
E object)
Sets the value at the specified index avoiding duplicates. |
|
static
|
setUniqueList(List<E> list)
Factory method to create a SetList using the supplied list to retain order. |
|
List<E> |
subList(int fromIndex,
int toIndex)
|
Methods inherited from class org.apache.commons.collections4.list.AbstractListDecorator |
---|
decorated, get, indexOf, lastIndexOf |
Methods inherited from class org.apache.commons.collections4.collection.AbstractCollectionDecorator |
---|
equals, hashCode, isEmpty, setCollection, size, toArray, toArray, toString |
Methods inherited from class java.lang.Object |
---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
Methods inherited from interface java.util.List |
---|
equals, hashCode, isEmpty, size, toArray, toArray |
Constructor Detail |
---|
protected 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 nulllist
- the list to decorate, must not be null
IllegalArgumentException
- if set or list is nullMethod Detail |
---|
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 typelist
- the list to decorate, must not be null
SetUniqueList
IllegalArgumentException
- if list is nullpublic Set<E> asSet()
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.
add
in interface List<E>
add
in class AbstractListDecorator<E>
index
- the index to insert atobject
- the object to addpublic 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.
addAll
in interface List<E>
addAll
in class AbstractListDecorator<E>
index
- the index to insert atcoll
- the collection to add in iterator order
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.
set
in interface List<E>
set
in class AbstractListDecorator<E>
index
- the index to insert atobject
- the object to set
public boolean remove(Object object)
remove
in interface Collection<E>
remove
in interface List<E>
remove
in class AbstractCollectionDecorator<E>
public E remove(int index)
remove
in interface List<E>
remove
in class AbstractListDecorator<E>
public boolean removeAll(Collection<?> coll)
removeAll
in interface Collection<E>
removeAll
in interface List<E>
removeAll
in class AbstractCollectionDecorator<E>
public boolean retainAll(Collection<?> coll)
retainAll
in interface Collection<E>
retainAll
in interface List<E>
retainAll
in class AbstractCollectionDecorator<E>
public void clear()
clear
in interface Collection<E>
clear
in interface List<E>
clear
in class AbstractCollectionDecorator<E>
public boolean contains(Object object)
contains
in interface Collection<E>
contains
in interface List<E>
contains
in class AbstractCollectionDecorator<E>
public boolean containsAll(Collection<?> coll)
containsAll
in interface Collection<E>
containsAll
in interface List<E>
containsAll
in class AbstractCollectionDecorator<E>
public Iterator<E> iterator()
iterator
in interface Iterable<E>
iterator
in interface Collection<E>
iterator
in interface List<E>
iterator
in class AbstractCollectionDecorator<E>
public ListIterator<E> listIterator()
listIterator
in interface List<E>
listIterator
in class AbstractListDecorator<E>
public ListIterator<E> listIterator(int index)
listIterator
in interface List<E>
listIterator
in class AbstractListDecorator<E>
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.
subList
in interface List<E>
subList
in class AbstractListDecorator<E>
protected Set<E> createSetBasedOnList(Set<E> set, List<E> list)
Set
with the same type as the provided set
and populate it with all elements of list
.
set
- the Set
to be used as return type, must not be nulllist
- the List
to populate the Set
Set
populated with all elements of the provided
List
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |