public interface ByteCollection extends Collection<Byte>, Container
Collection specialization with byte elements.| Modifier and Type | Method and Description |
|---|---|
boolean |
add(byte e)
Ensures that this collection contains the specified element (optional
operation).
|
boolean |
add(Byte e)
Deprecated.
Use specialization
add(byte) instead |
boolean |
contains(byte v)
Returns
true if this collection contains at least one element
equals to the specified one. |
boolean |
contains(Object o)
Deprecated.
Use specialization
contains(byte) instead |
ByteCursor |
cursor()
Returns a new cursor over this collection's elements.
|
void |
forEach(ByteConsumer action)
Performs the given action for each element of this collection until all elements have been
processed or the action throws an exception.
|
boolean |
forEachWhile(BytePredicate predicate)
Checks the given
predicate on each element of this collection until all element
have been processed or the predicate returns false for some element,
or throws an Exception. |
ByteIterator |
iterator()
Deprecated.
Instead of explicit
iterator() calls, use cursor();
iterator() is still sensible only as a backing mechanism for Java 5's for-each
statements. |
boolean |
remove(Object o)
Deprecated.
Use specialization
removeByte(byte) instead |
boolean |
removeByte(byte v)
Removes a single copy of the specified element from this
collection, if it is present (optional operation).
|
boolean |
removeIf(BytePredicate filter)
Removes all of the elements of this collection that satisfy the given predicate.
|
Object[] |
toArray()
Deprecated.
Use specialization
toByteArray() instead |
byte[] |
toArray(byte[] a)
Returns an array containing elements in this collection.
|
<T> T[] |
toArray(T[] array)
Deprecated.
Use specialization
toArray(byte[]) instead |
byte[] |
toByteArray()
Returns an array containing all of the elements in this collection.
|
addAll, clear, containsAll, equals, hashCode, isEmpty, removeAll, retainAll, sizeclear, ensureCapacity, isEmpty, shrink, size, sizeAsLong@Deprecated boolean contains(Object o)
contains(byte) insteadcontains in interface Collection<Byte>o - element whose presence in this collection is to be testedboolean contains(byte v)
true if this collection contains at least one element
equals to the specified one.v - element whose presence in this collection is to be testedtrue if this collection contains the specified element@Deprecated @Nonnull Object[] toArray()
toByteArray() insteadThe returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
toArray in interface Collection<Byte>@Deprecated @Nonnull <T> T[] toArray(@Nonnull T[] array)
toArray(byte[]) insteadIf this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.)
If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
Like the Collection.toArray() method, this method acts as bridge between
array-based and collection-based APIs. Further, this method allows
precise control over the runtime type of the output array, and may,
under certain circumstances, be used to save allocation costs.
Suppose x is a collection known to contain only strings. The following code can be used to dump the collection into a newly allocated array of String:
String[] y = x.toArray(new String[0]);
Note that toArray(new Object[0]) is identical in function to
toArray().toArray in interface Collection<Byte>array - the array into which the elements of this collection are to be
stored, if it is big enough; otherwise, a new array of the same
runtime type is allocated for this purpose.@Nonnull byte[] toByteArray()
The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
toArray(byte[])@Nonnull byte[] toArray(@Nonnull byte[] a)
If this collection fits in the specified array with room to spare
(i.e., the array has more elements than this collection), the element in
the array immediately following the end of the collection is set
to (byte) 0 (zero). This is useful in determining
the length of this collection only if the caller knows that this
collection does not contain any elements equal to (byte) 0.
If the native array is smaller than the collection size, the array will be filled with elements in Iterator order until it is full and exclude the remainder.
If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
a - the array into which the elements of this collection are to be
stored.byte[] containing all the elements in this collectionNullPointerException - if the specified array is nulltoByteArray()@Nonnull ByteCursor cursor()
Basic cursor usage idiom is:
for (ByteCursor cur = collection.cursor(); cur.moveNext();) {
// Work with cur.elem()
// Call cur.remove() to remove the current entry
}@Deprecated @Nonnull ByteIterator iterator()
iterator() calls, use cursor();
iterator() is still sensible only as a backing mechanism for Java 5's for-each
statements.iterator in interface Collection<Byte>iterator in interface Iterable<Byte>void forEach(@Nonnull ByteConsumer action)
action - the action to be performed for each elementboolean forEachWhile(@Nonnull BytePredicate predicate)
predicate on each element of this collection until all element
have been processed or the predicate returns false for some element,
or throws an Exception. Exceptions thrown by the predicate are relayed to the caller.
Unless otherwise specified by the implementing class, elements are checked by the predicate in the order of iteration (if an iteration order is specified).
If this collection is empty, this method returns true immediately.
predicate - the predicate to be checked for each element of this collectiontrue if the predicate returned true for all elements of this
collection, false if it returned false for the element@Deprecated boolean add(@Nonnull Byte e)
add(byte) insteadCollections that support this operation may place limitations on what elements may be added to this collection. In particular, some collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added. Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after this call returns.
add in interface Collection<Byte>e - element whose presence in this collection is to be ensuredboolean add(byte e)
true if this collection changed as a
result of the call. (Returns false if this collection does
not permit duplicates and already contains the specified element.)
Collections that support this operation may place limitations on what elements may be added to this collection. Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
If a collection refuses to add a particular element for any reason
other than that it already contains the element, it must throw
an exception (rather than returning false). This preserves
the invariant that a collection always contains the specified element
after this call returns.
e - element whose presence in this collection is to be ensuredtrue if this collection changed as a result of the callUnsupportedOperationException - if the add operation
is not supported by this collectionIllegalArgumentException - if some property of the element
prevents it from being added to this collectionIllegalStateException - if the element cannot be added at this
time due to insertion restrictionsCollection.add(Object)@Deprecated boolean remove(Object o)
removeByte(byte) insteadremove in interface Collection<Byte>o - element to be removed from this collection, if presentboolean removeByte(byte v)
true if this collection contained the specified element
(or equivalently, if this collection changed as a result of the call).
The name of this method is "removeByte", not "remove", because "remove" conflicts
with List.remove(int).
v - element to be removed from this collection, if presenttrue if an element was removed as a result of this callUnsupportedOperationException - if the remove operation
is not supported by this collectionremove(Object)boolean removeIf(@Nonnull BytePredicate filter)
filter - a predicate which returns true for elements to be removedtrue if any elements were removedNullPointerException - if the specified filter is nullUnsupportedOperationException - if elements cannot be removed from this collection.
Implementations may throw this exception if a matching element cannot be removed
or if, in general, removal is not supported.