E - the class of the elements of this list.public static final class CollectionsExt.ImmutableCyclicList<E> extends Object implements CyclicList<E>
| Modifier and Type | Field and Description |
|---|---|
private CyclicList<E> |
wrapped |
| Constructor and Description |
|---|
ImmutableCyclicList(CyclicList<E> wrapped) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
add(E element) |
void |
add(int index,
E element)
Inserts the specified element at the specified position in this list
(optional operation).
|
boolean |
addAll(Collection<? extends E> coll) |
void |
addAll(int index,
Iterator<E> iter)
Inserts the cyclic list of the specified iterator
at the specified position in this list (optional operation).
|
void |
addAll(int index,
List<? extends E> list)
Inserts the specified list at the given position
in this cyclic list (optional operation).
|
List<E> |
asList() |
List<E> |
asList(int index)
Returns a List containing all of the elements in this cyclic list
in proper sequence.
|
void |
clear()
Removes all of the elements from this list (optional operation).
|
boolean |
contains(Object obj)
Returns
true if this list contains the specified element. |
boolean |
containsAll(Collection<?> coll) |
CyclicList<E> |
cycle(int num)
Returns a cyclic permutation
p of this cyclic list. |
CyclicIterator<E> |
cyclicIterator(int index)
Returns a
CyclicIterator
of the elements in this list (in proper sequence),
starting at the specified position in this list. |
boolean |
equals(Object obj)
Compares the specified object with this cyclic list for equality.
|
boolean |
equalsCyclic(Object obj)
Compares the specified object with this cyclic list for equality.
|
E |
get(int index)
Returns the element at the specified position in this list.
|
CyclicList<E> |
getCopy(int len)
Returns a
CyclicList
which is by copying this list step by step
such that the length of the result is len. |
int |
getIndexOf(int idx,
Object obj)
Returns the non-negative index in this cyclic list
of the first occurrence of the specified element,
or
-1 if this cyclic list does not contain this element. |
CyclicList<E> |
getInverse()
Returns the inverse of this cyclic list:
the list with inverse order.
|
int |
hashCode()
Returns the hash code value for this cyclic list.
|
int |
hashCodeCyclic()
Returns a hash code value for this cyclic list
which is invariant under cyclic permutation.
|
boolean |
isEmpty()
Returns
true iff this list contains no elements. |
Iterator<E> |
iterator()
Returns
cyclicIterator(index)
for some unspecified index. |
E |
remove(int index)
Removes the element at the specified position in this list
(optional operation).
|
boolean |
remove(Object obj) |
boolean |
removeAll(Collection<?> coll) |
void |
replace(int index,
Iterator<E> iter)
Replaces the element at the specified position in this list
with the cyclic list of the specified iterator (optional operation).
|
void |
replace(int index,
List<E> list)
Replaces the element at the specified position in this list
with the specified list (optional operation).
|
boolean |
retainAll(Collection<?> coll) |
E |
set(int index,
E element)
Replaces the element at the specified position in this list
with the specified element (optional operation).
|
int |
shiftIndex(int index) |
int |
size()
Returns the number of elements in this list.
|
Object[] |
toArray() |
<E> E[] |
toArray(E[] ret) |
Object[] |
toArray(int index)
Returns an array containing all of the elements in this cyclic list
in proper sequence, i.e. in the ordering
returned by the iterator given by
CyclicList.cyclicIterator(int). |
<E> E[] |
toArray(int index,
E[] array)
Returns an array containing all of the elements in this cyclic list
in proper sequence, i.e. in the ordering
returned by the iterator given by
CyclicList.cyclicIterator(int);
the runtime type of the returned array is that of the specified array. |
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitparallelStream, removeIf, spliterator, streamprivate final CyclicList<E> wrapped
ImmutableCyclicList(CyclicList<E> wrapped)
public int shiftIndex(int index)
shiftIndex in interface CyclicList<E>public int size()
CyclicListInteger.MAX_VALUE elements,
returns Integer.MAX_VALUE.size in interface CyclicList<E>size in interface Collection<E>public boolean isEmpty()
CyclicListtrue iff this list contains no elements.isEmpty in interface CyclicList<E>isEmpty in interface Collection<E>true iff this list contains no elements.public CyclicList<E> getInverse()
CyclicListgetInverse in interface CyclicList<E>public boolean contains(Object obj)
CyclicListtrue if this list contains the specified element.
More formally, returns true
if and only if this list contains at least one element e
such that
(o==null ? e==null : o.equals(e)).contains in interface CyclicList<E>contains in interface Collection<E>obj - element whose presence in this list is to be tested.true if this list contains the specified element.public boolean containsAll(Collection<?> coll)
containsAll in interface Collection<E>public Iterator<E> iterator()
CyclicListcyclicIterator(index)
for some unspecified index.iterator in interface CyclicList<E>iterator in interface Iterable<E>iterator in interface Collection<E>cyclicIterator(index)
for some unspecified index.public CyclicIterator<E> cyclicIterator(int index)
CyclicListCyclicIterator
of the elements in this list (in proper sequence),
starting at the specified position in this list.
The specified index indicates the first element
that would be returned
by an initial call to the next method.
An initial call to the previous method
would return the element with the specified index minus one
(modulo the length of this cyclic list).cyclicIterator in interface CyclicList<E>index - index of first element to be returned from the list iterator
(by a call to the next method).
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.public Object[] toArray(int index)
CyclicListCyclicList.cyclicIterator(int).
Modifying the return value
does not modify this CyclicList.toArray in interface CyclicList<E>index - index of the element in the cyclic list
which comes first in the array returned.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.public <E> E[] toArray(int index,
E[] array)
CyclicListCyclicList.cyclicIterator(int);
the runtime type of the returned array is that of the specified array.
Modifying the return value
does not modify this CyclicList.toArray in interface CyclicList<E>index - index of the element in the cyclic list
which comes first in the array returned.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.array - the array into which the elements of this list are to be stored,
if it is big enough;
otherwise, a new array of the same runtime type
is allocated for this purpose.public Object[] toArray()
toArray in interface Collection<E>public <E> E[] toArray(E[] ret)
toArray in interface Collection<E>public List<E> asList(int index)
CyclicListasList in interface CyclicList<E>index - index of the element in the cyclic list
which comes first in the List returned.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.public List<E> asList()
asList in interface CyclicList<E>public CyclicList<E> cycle(int num)
CyclicListp of this cyclic list.cycle in interface CyclicList<E>num - an int value.p of this cyclic list.
It satisfies p.size() == this.size() and
p.get(i) == this.get(i+num).public void clear()
CyclicListclear in interface CyclicList<E>clear in interface Collection<E>public boolean equals(Object obj)
CyclicListtrue
if and only if the specified object is also a cyclic list,
both lists have the same size and
all corresponding pairs of elements the two lists are equal.
(Two elements e1 and e2 are equal
if (e1==null ? e2==null : e1.equals(e2)).)
In other words, two cyclic lists are defined to be
equal if they contain the same elements in the same order
according to their iterators.
This definition ensures that the equals method works properly
across different implementations
of the CyclicList interface.equals in interface CyclicList<E>equals in interface Collection<E>equals in class Objectobj - the object to be compared for equality with this list.true if the specified object is equal to this list.CyclicList.equalsCyclic(Object)public boolean equalsCyclic(Object obj)
CyclicListtrue
if and only if the specified object is also a cyclic list,
both lists have the same size,
and, up to a cyclic permutation,
all corresponding pairs of elements the two lists are equal.
(Two elements e1 and e2 are equal
if (e1==null ? e2==null : e1.equals(e2)).)
In other words, two lists are defined to be
equal if they contain the same elements in the same order
up to a cyclic permutation.
This definition ensures that the equals method works properly
across different implementations
of the CyclicList interface.equalsCyclic in interface CyclicList<E>obj - the object to be compared for equality with this list.true if the specified object is equal to this list.CyclicList.equals(Object)public int hashCode()
CyclicList
hashCode = 1;
Iterator i = list.iterator();
while (i.hasNext()) {
Object obj = i.next();
hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}
This ensures that list1.equals(list2) implies that
list1.hashCode()==list2.hashCode() for any two lists,
list1 and list2,
as required by the general contract of Object.hashCode.hashCode in interface CyclicList<E>hashCode in interface Collection<E>hashCode in class ObjectCyclicList.equals(Object),
CyclicList.hashCodeCyclic()public int hashCodeCyclic()
CyclicListCyclicList.equalsCyclic(Object)
and with CyclicList.equals(Object),
i.e. equals objects have equal hash codes.
The hash code of this cyclic list
is the hash code of the underlying set.
This ensures that list1.equalsCyclic(list2) implies that
list1.hashCodeCyclic()==list2.hashCodeCyclic()
for any two lists list1 and list2.hashCodeCyclic in interface CyclicList<E>CyclicList.hashCode(),
CyclicList.equalsCyclic(Object)public E get(int index)
CyclicListget in interface CyclicList<E>index - index of element to return.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.public E set(int index, E element)
CyclicListset in interface CyclicList<E>index - index of element to replace.element - element to be stored at the specified position.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.public void replace(int index,
Iterator<E> iter)
CyclicListiter.next
in this list.replace in interface CyclicList<E>index - index of element to replace.iter - a CyclicIterator which determines an index in a list
which replaces this.get(i).CyclicList.replace(int, List)public void replace(int index,
List<E> list)
CyclicListiter.next
in this list.replace in interface CyclicList<E>index - index of element to replace.list - a List which determines an index in a list
which replaces this.get(i).CyclicList.replace(int, Iterator)public boolean add(E element)
add in interface Collection<E>public void add(int index,
E element)
CyclicListlist.add(i,o);return list.get(i) yields o.
In contrast to CyclicList.set(int, E),
the element currently at the specified position is not lost.add in interface CyclicList<E>index - index at which the specified element is to be inserted.
This is interpreted modulo the length of this cyclic list plus one
(The list emerging after the insertion).
In contrast to List.add(int,Object)
any index (even a negative one) is valid.element - element to be inserted.public void addAll(int index,
Iterator<E> iter)
CyclicListCyclicList.replace(int, Iterator),
the element currently at the specified position is not lost.addAll in interface CyclicList<E>index - index at which the specified list is to be inserted.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.iter - element to be inserted. *****CyclicList.addAll(int, List)public void addAll(int index,
List<? extends E> list)
CyclicListCyclicList.replace(int, Iterator),
the element currently at the specified position is not lost.addAll in interface CyclicList<E>index - index at which the specified list is to be inserted.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.list - the list to be inserted.CyclicList.addAll(int, Iterator)public boolean addAll(Collection<? extends E> coll)
addAll in interface Collection<E>public E remove(int index) throws EmptyCyclicListException
CyclicListremove in interface CyclicList<E>index - the index of the element to removed.
This is interpreted modulo the length of this cyclic list.
Any index (even negative ones) are valid.EmptyCyclicListException - if this list is empty.public boolean remove(Object obj)
remove in interface Collection<E>public boolean removeAll(Collection<?> coll)
removeAll in interface Collection<E>public boolean retainAll(Collection<?> coll)
retainAll in interface Collection<E>public int getIndexOf(int idx,
Object obj)
CyclicList-1 if this cyclic list does not contain this element.
More formally, returns the lowest index i such that
(o==null ? get(i)==null : o.equals(get(i))),
or some negative index if there is no such index.
Note that this specification slightly differs from
List.indexOf(Object).
getIndexOf in interface CyclicList<E>idx - the index to start search with.
Independently of this,
the search comprises all entries of this cyclic list.obj - element to search for or null.-1
if this list does not contain this element.public CyclicList<E> getCopy(int len)
CyclicListCyclicList
which is by copying this list step by step
such that the length of the result is len.
For example len == size()*n
yields an n-fold copy of this cyclic list.getCopy in interface CyclicList<E>len - a non-negative int value.CyclicList
which is by copying this list step by step
such that the length of the result is as specified.Copyright © 2012–2018 Simuline Organization (l2r). All rights reserved.