public class LazyStringArrayList extends AbstractList<String> implements LazyStringList, RandomAccess
LazyStringList
that wraps an ArrayList. Each
element is either a ByteString or a String. It caches the last one requested
which is most likely the one needed next. This minimizes memory usage while
satisfying the most common use cases.
Note that this implementation is not synchronized. If multiple threads access an ArrayList instance concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the list.
If the implementation is accessed via concurrent reads, this is thread safe. Conversions are done in a thread safe manner. It's possible that the conversion may happen more than once if two threads attempt to access the same element and the modifications were not visible to each other, but this will not result in any corruption of the list or change in behavior other than performance.
Modifier and Type | Field and Description |
---|---|
static LazyStringList |
EMPTY |
Constructor and Description |
---|
LazyStringArrayList() |
LazyStringArrayList(LazyStringList from) |
LazyStringArrayList(List<String> from) |
Modifier and Type | Method and Description |
---|---|
void |
add(ByteString element)
Appends the specified element to the end of this list (optional operation).
|
void |
add(int index,
String element)
Inserts the specified element at the specified position in this list (optional operation).
|
boolean |
addAll(Collection<? extends String> c)
Adds all of the elements in the specified collection to this collection (optional operation).
|
boolean |
addAll(int index,
Collection<? extends String> c)
Inserts all of the elements in the specified collection into this list at the specified position
(optional operation).
|
void |
clear()
Removes all of the elements from this list (optional operation).
|
String |
get(int index)
Returns the element at the specified position in this list.
|
ByteString |
getByteString(int index)
Returns the element at the specified position in this list as a ByteString.
|
List<?> |
getUnderlyingElements()
Returns an unmodifiable List of the underlying elements, each of which is either a
String or its
equivalent UTF-8 encoded ByteString or byte[]. |
String |
remove(int index)
Removes the element at the specified position in this list (optional operation).
|
String |
set(int index,
String s)
Replaces the element at the specified position in this list with the specified element (optional
operation).
|
int |
size()
Returns the number of elements in this collection.
|
add, equals, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, removeRange, subList
contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toString
add, addAllByteArray, addAllByteString, asByteArrayList, getByteArray, getRaw, getUnmodifiableView, mergeFrom, set, set
asByteStringList
add, contains, containsAll, equals, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, removeAll, retainAll, subList, toArray, toArray
public static final LazyStringList EMPTY
public LazyStringArrayList()
public LazyStringArrayList(LazyStringList from)
public void add(ByteString element)
LazyStringList
add
in interface LazyStringList
element
- element to be appended to this listpublic void add(int index, String element)
AbstractList
This implementation always throws an UnsupportedOperationException
.
public boolean addAll(Collection<? extends String> c)
AbstractCollection
This implementation iterates over the specified collection, and adds each object returned by the iterator to this collection, in turn.
Note that this implementation will throw an UnsupportedOperationException unless add is overridden (assuming the specified collection is non-empty).
addAll
in interface Collection<String>
addAll
in interface List<String>
addAll
in class AbstractCollection<String>
c
- collection containing elements to be added to this collectionAbstractCollection.add(Object)
public boolean addAll(int index, Collection<? extends String> c)
AbstractList
This implementation gets an iterator over the specified collection and iterates over it,
inserting the elements obtained from the iterator into this list at the appropriate position, one
at a time, using add(int, E)
. Many implementations will override this method for
efficiency.
Note that this implementation throws an UnsupportedOperationException
unless
add(int, E)
is overridden.
addAll
in interface List<String>
addAll
in class AbstractList<String>
index
- index at which to insert the first element from the specified collectionc
- collection containing elements to be added to this listpublic void clear()
AbstractList
This implementation calls removeRange(0, size())
.
Note that this implementation throws an UnsupportedOperationException
unless
remove(int
index)
or removeRange(int fromIndex, int toIndex)
is overridden.
clear
in interface Collection<String>
clear
in interface List<String>
clear
in class AbstractList<String>
public String get(int index)
AbstractList
public ByteString getByteString(int index)
LazyStringList
getByteString
in interface LazyStringList
index
- index of the element to returnpublic List<?> getUnderlyingElements()
LazyStringList
String
or its
equivalent UTF-8 encoded ByteString
or byte[]. It is an error for the caller to modify the returned List,
and attempting to do so will result in an UnsupportedOperationException
.getUnderlyingElements
in interface LazyStringList
public String remove(int index)
AbstractList
This implementation always throws an UnsupportedOperationException
.
public String set(int index, String s)
AbstractList
This implementation always throws an UnsupportedOperationException
.
public int size()
AbstractCollection
size
in interface Collection<String>
size
in interface List<String>
size
in class AbstractCollection<String>