|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.util.concurrent.CopyOnWriteArrayList<E>
public class CopyOnWriteArrayList<E>
A thread-safe implementation of an ArrayList. A CopyOnWriteArrayList is
as special ArrayList which performs copies of the underlying storage
each time a write (remove
, add
etc..) operation
is performed.
The update operation in this class run usually in O(n)
or worse,
but traversal operations are fast and efficient, especially when running in
a multi-thread environment without the need to design complex synchronize
mechanisms.
Iterator
s in this class work on a snapshot of the backing store
at the moment the iterator itself was created, hence the iterator will not
reflect changes in the underlying storage. Thus, update operation on the
Iterator
s are not supported, but as interferences from other
threads are impossible, no ConcurrentModificationException
will be ever thrown from within the Iterator
.
This class is especially useful when used with event handling, like the
following code demonstrates:
CopyOnWriteArrayList
Constructor Summary | |
---|---|
CopyOnWriteArrayList()
Construct a new ArrayList with the default capacity (16). |
|
CopyOnWriteArrayList(Collection<? extends E> c)
Construct a new ArrayList, and initialize it with the elements in the supplied Collection. |
|
CopyOnWriteArrayList(E[] array)
Construct a new ArrayList, and initialize it with the elements in the supplied array. |
Method Summary | ||
---|---|---|
boolean |
add(E e)
Appends the supplied element to the end of this list. |
|
void |
add(int index,
E e)
Adds the supplied element at the specified index, shifting all elements currently at that index or higher one to the right. |
|
boolean |
addAll(Collection<? extends E> c)
Add each element in the supplied Collection to this List. |
|
boolean |
addAll(int index,
Collection<? extends E> c)
Add all elements in the supplied collection, inserting them beginning at the specified index. c can contain objects of any type, as well as null values. |
|
int |
addAllAbsent(Collection<? extends E> c)
Adds all the element from the given collection that are not already in this list. |
|
boolean |
addIfAbsent(E val)
Adds an element if the list does not contains it already. |
|
void |
clear()
Removes all elements from this List |
|
Object |
clone()
Creates a shallow copy of this ArrayList (elements are not cloned). |
|
boolean |
contains(Object e)
Returns true if element is in this ArrayList. |
|
boolean |
containsAll(Collection<?> c)
Tests whether this collection contains all the elements in a given collection. |
|
boolean |
equals(Object o)
Determine whether this Object is semantically equal to another Object. |
|
E |
get(int index)
Retrieves the element at the user-supplied index. |
|
int |
hashCode()
Get a value that represents this Object, as uniquely as possible within the confines of an int. |
|
int |
indexOf(E e,
int index)
Return the lowest index greater equal index at which
e appears in this List, or -1 if it does not
appear. |
|
int |
indexOf(Object e)
Returns the lowest index at which element appears in this List, or -1 if it does not appear. |
|
boolean |
isEmpty()
Checks if the list is empty. |
|
Iterator<E> |
iterator()
Return an Iterator containing the elements of this list. |
|
int |
lastIndexOf(E e,
int index)
Returns the highest index lesser equal index at
which e appears in this List, or -1 if it does not
appear. |
|
int |
lastIndexOf(Object e)
Returns the highest index at which element appears in this List, or -1 if it does not appear. |
|
ListIterator<E> |
listIterator()
Return a ListIterator containing the elements of this list. |
|
ListIterator<E> |
listIterator(int index)
Return a ListIterator over the elements of this list starting at the specified index. |
|
E |
remove(int index)
Removes the element at the user-supplied index. |
|
boolean |
remove(Object element)
Remove the first occurrence, if any, of the given object from this list, returning true if the object was removed, false
otherwise. |
|
boolean |
removeAll(Collection<?> c)
Removes all the elements contained in the given collection. |
|
boolean |
retainAll(Collection<?> c)
Removes all the elements that are not in the passed collection. |
|
E |
set(int index,
E e)
Sets the element at the specified index. |
|
int |
size()
Returns the number of elements in this list. |
|
List<E> |
subList(int fromIndex,
int toIndex)
Obtain a List view of a subsection of this list, from fromIndex (inclusive) to toIndex (exclusive). |
|
Object[] |
toArray()
Returns an Object array containing all of the elements in this ArrayList. |
|
|
toArray(T[] a)
Returns an Array whose component type is the runtime component type of the passed-in Array. |
|
String |
toString()
Convert this Object to a human-readable String. |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public CopyOnWriteArrayList()
public CopyOnWriteArrayList(Collection<? extends E> c)
c
- the collection whose elements will initialize this list
NullPointerException
- if c is nullpublic CopyOnWriteArrayList(E[] array)
array
- the array used to initialize this list
NullPointerException
- if array is nullMethod Detail |
---|
public int size()
size
in interface Collection<E>
size
in interface List<E>
public boolean isEmpty()
isEmpty
in interface Collection<E>
isEmpty
in interface List<E>
public boolean contains(Object e)
contains
in interface Collection<E>
contains
in interface List<E>
e
- the element whose inclusion in the List is being tested
public boolean containsAll(Collection<?> c)
containsAll
in interface Collection<E>
containsAll
in interface List<E>
c
- the collection to test against
NullPointerException
- if the given collection is nullcontains(Object)
public int indexOf(Object e)
indexOf
in interface List<E>
e
- the element whose inclusion in the List is being tested
public int indexOf(E e, int index)
index
at which
e
appears in this List, or -1 if it does not
appear.
e
- the element whose inclusion in the list is being testedindex
- the index at which the search begins
e
was foundpublic int lastIndexOf(Object e)
lastIndexOf
in interface List<E>
e
- the element whose inclusion in the List is being tested
public int lastIndexOf(E e, int index)
index
at
which e
appears in this List, or -1 if it does not
appear.
e
- the element whose inclusion in the list is being testedindex
- the index at which the search begins
e
was foundpublic Object clone()
clone
in class Object
Cloneable
public Object[] toArray()
toArray
in interface Collection<E>
toArray
in interface List<E>
public <T> T[] toArray(T[] a)
toArray
in interface Collection<E>
toArray
in interface List<E>
a
- the passed-in Array
ArrayStoreException
- if the runtime type of a does not allow an element in this list
NullPointerException
- if a is nullpublic E get(int index)
get
in interface List<E>
index
- the index of the element we are fetching
IndexOutOfBoundsException
- if index < 0 || index >= size()public E set(int index, E e)
set
in interface List<E>
index
- the index at which the element is being sete
- the element to be set
IndexOutOfBoundsException
- if index < 0 || index >= 0public boolean add(E e)
add
in interface Collection<E>
add
in interface List<E>
e
- the element to be appended to this list
public void add(int index, E e)
add
in interface List<E>
index
- the index at which the element is being addede
- the item being added
IndexOutOfBoundsException
- if index < 0 || index > size()public E remove(int index)
remove
in interface List<E>
index
- the index of the element to be removed
IndexOutOfBoundsException
- if index < 0 || index >= size()public boolean remove(Object element)
true
if the object was removed, false
otherwise.
remove
in interface Collection<E>
remove
in interface List<E>
element
- the object to be removed.
public boolean removeAll(Collection<?> c)
removeAll
in interface Collection<E>
removeAll
in interface List<E>
c
- the collection containing the elements to be removed from this
list.
List.remove(Object)
,
List.contains(Object)
public boolean retainAll(Collection<?> c)
clear()
.
Please, note that this method is extremely slow (unless the argument has
size == 0
) and has bad performance is both space and time
usage.
retainAll
in interface Collection<E>
retainAll
in interface List<E>
c
- the collection containing the elements to be retained by this
list.
List.remove(Object)
,
List.contains(Object)
public void clear()
clear
in interface Collection<E>
clear
in interface List<E>
public boolean addAll(Collection<? extends E> c)
addAll
in interface Collection<E>
addAll
in interface List<E>
c
- a Collection containing elements to be added to this List
NullPointerException
- if c is nullList.add(Object)
public boolean addAll(int index, Collection<? extends E> c)
addAll
in interface List<E>
index
- the index at which the elements will be insertedc
- the Collection containing the elements to be inserted
IndexOutOfBoundsException
- if index < 0 || index > 0
NullPointerException
- if c is nullList.add(int, Object)
public boolean addIfAbsent(E val)
val
- the element to add to the list.
public int addAllAbsent(Collection<? extends E> c)
c
- the Collection containing the elements to be inserted
public String toString()
Object
System.out.println()
and such.
It is typical, but not required, to ensure that this method
never completes abruptly with a RuntimeException
.
This method will be called when performing string
concatenation with this object. If the result is
null
, string concatenation will instead
use "null"
.
The default implementation returns
getClass().getName() + "@" +
Integer.toHexString(hashCode())
.
toString
in class Object
Object.getClass()
,
Object.hashCode()
,
Class.getName()
,
Integer.toHexString(int)
public boolean equals(Object o)
Object
There are some fairly strict requirements on this
method which subclasses must follow:
a.equals(b)
and
b.equals(c)
, then a.equals(c)
must be true as well.a.equals(b)
and
b.equals(a)
must have the same value.a.equals(a)
must
always be true.a.equals(null)
must be false.a.equals(b)
must imply
a.hashCode() == b.hashCode()
.
The reverse is not true; two objects that are not
equal may have the same hashcode, but that has
the potential to harm hashing performance.This is typically overridden to throw a ClassCastException
if the argument is not comparable to the class performing
the comparison, but that is not a requirement. It is legal
for a.equals(b)
to be true even though
a.getClass() != b.getClass()
. Also, it
is typical to never cause a NullPointerException
.
In general, the Collections API (java.util
) use the
equals
method rather than the ==
operator to compare objects. However, IdentityHashMap
is an exception to this rule, for its own good reasons.
The default implementation returns this == o
.
equals
in interface Collection<E>
equals
in interface List<E>
equals
in class Object
o
- the Object to compare to
Object.hashCode()
public int hashCode()
Object
There are some requirements on this method which
subclasses must follow:
a.equals(b)
is true, then
a.hashCode() == b.hashCode()
must be as well.
However, the reverse is not necessarily true, and two
objects may have the same hashcode without being equal.Notice that since hashCode
is used in
Hashtable
and other hashing classes,
a poor implementation will degrade the performance of hashing
(so don't blindly implement it as returning a constant!). Also,
if calculating the hash is time-consuming, a class may consider
caching the results.
The default implementation returns
System.identityHashCode(this)
hashCode
in interface Collection<E>
hashCode
in interface List<E>
hashCode
in class Object
Object.equals(Object)
,
System.identityHashCode(Object)
public Iterator<E> iterator()
iterator
in interface Iterable<E>
iterator
in interface Collection<E>
iterator
in interface List<E>
public ListIterator<E> listIterator()
listIterator
in interface List<E>
public ListIterator<E> listIterator(int index)
next()
will thus
return the element at index
, while an initial call to
previous()
will return the element at index-1
. The
Iterator uses a snapshot of the state of the internal storage
at the moment this method is called and does not support
update operations, so no synchronization is needed to traverse the
iterator.
listIterator
in interface List<E>
index
- the index at which to start iterating.
public List<E> subList(int fromIndex, int toIndex)
This implementation returns a subclass of AbstractList. It stores, in private fields, the offset and size of the sublist, and the expected modCount of the backing list. If the backing list implements RandomAccess, the sublist will also.
The subclass's set(int, Object)
, get(int)
,
add(int, Object)
, remove(int)
,
addAll(int, Collection)
and
removeRange(int, int)
methods all delegate to the
corresponding methods on the backing abstract list, after
bounds-checking the index and adjusting for the offset. The
addAll(Collection c)
method merely returns addAll(size, c).
The listIterator(int)
method returns a "wrapper object"
over a list iterator on the backing list, which is created with the
corresponding method on the backing list. The iterator()
method merely returns listIterator(), and the size()
method
merely returns the subclass's size field.
All methods first check to see if the actual modCount of the backing list is equal to its expected value, and throw a ConcurrentModificationException if it is not.
subList
in interface List<E>
fromIndex
- the index that the returned list should start from
(inclusive)toIndex
- the index that the returned list should go to (exclusive)
IndexOutOfBoundsException
- if fromIndex < 0
|| toIndex > size()
IndexOutOfBoundsException
- if fromIndex > toIndexConcurrentModificationException
,
RandomAccess
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |