/**
* Copyright (C) 2022 by Martin Robillard. See https://codesample.info/about.html
*/
package e2.chapter8;
import java.util.Arrays;
import java.util.List;
public class CardSequence implements CardSource
{
private final List<Card> aCards;
public CardSequence(Card... pCards)
{
aCards = Arrays.asList(pCards);
}
@Override
public boolean isEmpty()
{
return aCards.isEmpty();
}
public Card get(int pPosition)
{
return aCards.get(pPosition);
}
@Override
public Card draw()
{
return aCards.remove(size() - 1);
}
public int size()
{
return aCards.size();
}
@Override
public void accept(CardSourceVisitor pVisitor)
{
pVisitor.visitCardSequence(this);
}
}
true
if this list contains no elements.
true
if this list contains no elements.
isEmpty
in interface Collection<E>
true
if this list contains no elements
index
- index of the element to return
IndexOutOfBoundsException
- if the index is out of range (index < 0 || index >= size()
)
index
- the index of the element to be removed
UnsupportedOperationException
- if the remove
operation is not supported by this list
IndexOutOfBoundsException
- if the index is out of range (index < 0 || index >= size()
)
Integer.MAX_VALUE
elements, returns Integer.MAX_VALUE
.
Integer.MAX_VALUE
elements, returns Integer.MAX_VALUE
.
size
in interface Collection<E>
Unlike sets, lists typically allow duplicate elements. More formally, lists typically allow pairs of elements e1
and e2
such that e1.equals(e2)
, and they typically allow multiple null elements if they allow null elements at all. It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare.
The List
interface places additional stipulations, beyond those specified in the Collection
interface, on the contracts of the iterator
, add
, remove
, equals
, and hashCode
methods. Declarations for other inherited methods are also included here for convenience.
The List
interface provides four methods for positional (indexed) access to list elements. Lists (like Java arrays) are zero based. Note that these operations may execute in time proportional to the index value for some implementations (the LinkedList
class, for example). Thus, iterating over the elements in a list is typically preferable to indexing through it if the caller does not know the implementation.
The List
interface provides a special iterator, called a ListIterator
, that allows element insertion and replacement, and bidirectional access in addition to the normal operations that the Iterator
interface provides. A method is provided to obtain a list iterator that starts at a specified position in the list.
The List
interface provides two methods to search for a specified object. From a performance standpoint, these methods should be used with caution. In many implementations they will perform costly linear searches.
The List
interface provides two methods to efficiently insert and remove multiple elements at an arbitrary point in the list.
Note: While it is permissible for lists to contain themselves as elements, extreme caution is advised: the equals
and hashCode
methods are no longer well defined on such a list.
Some list implementations have restrictions on the elements that they may contain. For example, some implementations prohibit null elements, and some have restrictions on the types of their elements. Attempting to add an ineligible element throws an unchecked exception, typically NullPointerException
or ClassCastException
. Attempting to query the presence of an ineligible element may throw an exception, or it may simply return false; some implementations will exhibit the former behavior and some will exhibit the latter. More generally, attempting an operation on an ineligible element whose completion would not result in the insertion of an ineligible element into the list may throw an exception or it may succeed, at the option of the implementation. Such exceptions are marked as "optional" in the specification for this interface.
The List.of
and List.copyOf
static factory methods provide a convenient way to create unmodifiable lists. The List
instances created by these methods have the following characteristics:
UnsupportedOperationException
to be thrown. However, if the contained elements are themselves mutable, this may cause the List's contents to appear to change. null
elements. Attempts to create them with null
elements result in NullPointerException
. subList
views implement the RandomAccess
interface. This interface is a member of the Java Collections Framework.
The methods in this class all throw a NullPointerException
, if the specified array reference is null, except where noted.
The documentation for the methods contained in this class includes brief descriptions of the implementations. Such descriptions should be regarded as implementation notes, rather than parts of the specification. Implementors should feel free to substitute other algorithms, so long as the specification itself is adhered to. (For example, the algorithm used by sort(Object[])
does not have to be a MergeSort, but it does have to be stable.)
This class is a member of the Java Collections Framework.
Serializable
and implements RandomAccess
.
Serializable
and implements RandomAccess
.
The returned list implements the optional Collection
methods, except those that would change the size of the returned list. Those methods leave the list unchanged and throw UnsupportedOperationException
.
If the specified array's actual component type differs from the type parameter T, this can result in operations on the returned list throwing an ArrayStoreException
.
Collection.toArray()
.
This method provides a way to wrap an existing array:
Integer[] numbers = ...
...
List<Integer> values = Arrays.asList(numbers);
This method also provides a convenient way to create a fixed-size list initialized to contain several elements:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
The list returned by this method is modifiable. To create an unmodifiable list, use Collections.unmodifiableList
or Unmodifiable Lists.
T
- the class of the objects in the array
a
- the array by which the list will be backed
NullPointerException
- if the specified array is null