The limit of valid indices of the sequence.

The length getter should be efficient.

int get length;

Changes the length of the list. If newLength is greater than the current length, entries are initialized to null. Throws an UnsupportedOperationException if the list is not extendable.

void set length(int newLength);

Returns the element at the given index in the list or throws an IndexOutOfRangeException if index is out of bounds.

E operator [](int index);

Sets the entry at the given index in the list to value. Throws an IndexOutOfRangeException if index is out of bounds.

void operator []=(int index, E value);

Adds value at the end of the list, extending the length by one. Throws an UnsupportedOperationException if the list is not extendable.

void add(E value);

Appends all elements of the collection to the end of this list. Extends the length of the list by the number of elements in collection. Throws an UnsupportedOperationException if this list is not extendable.

void addAll(Collection<E> collection);

Adds value at the end of the list, extending the length by one. Throws an UnsupportedOperationException if the list is not extendable.

void addLast(E value);

Returns the byte array view of this object. This view allows the byte representation of the object to be read and written directly.

ByteArray asByteArray([int start, int length]);

Returns the number of bytes in the representation of each element in this list, or the number bytes in the representation of the entire object if it is not a list.

int bytesPerElement();

Removes all elements in the list.

The length of the list becomes zero. Throws an UnsupportedOperationException, and retains all elements, if the length of the list cannot be changed.

void clear();

Check whether the collection contains an element equal to element.

bool contains(E element) {
  for (E e in this) {
    if (e == element) return true;
  }
  return false;
}

Returns true if every elements of this collection satisify the predicate f. Returns false otherwise.

bool every(bool f(E element)) {
  for (E element in this) {
    if (!f(element)) return false;
  }
  return true;
}

Returns a collection with the elements of this collection that satisfy the predicate f.

The returned collection should be of the same type as the collection creating it.

An element satisfies the predicate f if f(element) returns true.

Collection<E> filter(bool f(E element));

Applies the function f to each element of this collection.

void forEach(void f(E element)) {
  for (E element in this) f(element);
}

Returns a new list containing length elements from the list, starting at start. Returns an empty list if length is 0. Throws an ArgumentError if length is negative. Throws an IndexOutOfRangeException if start or start + length - 1 are out of range.

List<E> getRange(int start, int length);

Returns the first index of element in the list.

Searches the list from index start to the length of the list. The first time an element e is encountered so that e == element, the index of e is returned. Returns -1 if element is not found.

int indexOf(E element, [int start = 0]);

Inserts a new range into the list, starting from start to start + length - 1. The entries are filled with initialValue. Throws an UnsupportedOperationException if the list is not extendable. If length is 0, this method does not do anything. If start is the length of the list, this method inserts the range at the end of the list. Throws an ArgumentError if length is negative. Throws an IndexOutOfRangeException if start is negative or if start is greater than the length of the list.

void insertRange(int start, int length, [E initialValue]);

Returns true if there is no element in this collection.

bool isEmpty() => !iterator().hasNext();

Returns an Iterator that iterates over this Iterable object.

Iterator<E> iterator();

Returns the last element of the list, or throws an out of bounds exception if the list is empty.

E last();

Returns the last index of element in the list.

Searches the list backwards from index start to 0. The first time an element e is encountered so that e == element, the index of e is returned. If start is not provided, it defaults to this.length - 1 . Returns -1 if element is not found.

int lastIndexOf(E element, [int start]);

Returns the length of this view, in bytes.

int lengthInBytes();

Returns a new collection with the elements f(e) for each element e of this collection.

Subclasses of Collection should implement the map method to return a collection of the same general type as themselves. E.g., List.map should return a List.

Collection map(f(E element));

Reduce a collection to a single value by iteratively combining each element of the collection with an existing value using the provided function. Use initialValue as the initial value, and the function combine to create a new value from the previous one and an element.

Example of calculating the sum of a collection:

collection.reduce(0, (prev, element) => prev + element);

Dynamic reduce(var initialValue,
               Dynamic combine(var previousValue, E element)) {
  var value = initialValue;
  for (E element in this) value = combine(value, element);
  return value;
}

Removes the element at position index from the list.

This reduces the length of the list by one and moves all later elements down by one position. Returns the removed element. Throws an ArgumentError if index is not an int. Throws an IndexOutOfRangeException if the index does not point inside the list. Throws an UnsupportedOperationException, and doesn't remove the element, if the length of the list cannot be changed.

E removeAt(int index);

Pops and returns the last element of the list. Throws a UnsupportedOperationException if the length of the list cannot be changed.

E removeLast();

Removes length elements from the list, beginning at start. Throws an UnsupportedOperationException if the list is not extendable. If length is 0, this method does not do anything. Throws an ArgumentError if length is negative. Throws an IndexOutOfRangeException if start or :start + length: - 1 are out of range.

void removeRange(int start, int length);

Copies length elements of from, starting at startFrom, into the list, starting at start. If length is 0, this method does not do anything. Throws an ArgumentError if length is negative. Throws an IndexOutOfRangeException if start or start + length - 1 are out of range for this, or if startFrom or startFrom + length - 1 are out of range for from.

void setRange(int start, int length, List<E> from, [int startFrom]);

Returns true if one element of this collection satisfies the predicate f. Returns false otherwise.

bool some(bool f(E element)) {
  for (E element in this) {
    if (f(element)) return true;
  }
  return false;
}

Sorts the list according to the order specified by the Comparator.

void sort([Comparator<E> compare = Comparable.compare]);