Uint32List abstract final

abstract final class Uint32List implements TypedDataList<int>

A fixed-length list of 32-bit unsigned integers that is viewable as a TypedData.

For long lists, this implementation can be considerably more space- and time-efficient than the default List implementation.

Integers stored in the list are truncated to their low 32 bits, interpreted as an unsigned 32-bit integer with values in the range 0 to 4294967295.

It is a compile-time error for a class to attempt to extend or implement Uint32List.

Implemented types

• TypedDataList<E>

Available Extensions

• Uint32ListAddress
• Uint32ListToJSUint32Array

Constructors

Uint32List() factory

factory Uint32List(int length)

Creates a Uint32List of the specified length (in elements), all of whose elements are initially zero.

The list is backed by a ByteBuffer containing precisely length times 4 bytes.

Implementation

external factory Uint32List(int length);

Uint32List.fromList() factory

factory Uint32List.fromList(List<int> elements)

Creates a Uint32List with the same length as the elements list and copies over the elements.

Values are truncated to fit in the list when they are copied, the same way storing values truncates them.

The list is backed by a ByteBuffer containing precisely elements.length times 4 bytes.

Implementation

external factory Uint32List.fromList(List<int> elements);

Uint32List.sublistView() factory

factory Uint32List.sublistView(TypedData data, [int start = 0, int? end])

Creates a Uint32List view on a range of elements of data.

Creates a view on the range of data.buffer which corresponds to the elements of data from start until end. If data is a typed data list, like Uint16List, then the view is on the bytes of the elements with indices from start until end. If data is a ByteData, it's treated like a list of bytes.

If provided, start and end must satisfy

0 ≤ start ≤ end ≤ elementCount

where elementCount is the number of elements in data, which is the same as the List.length of a typed data list.

If omitted, start defaults to zero and end to elementCount.

The start and end indices of the range of bytes being viewed must be multiples of four.

Implementation

factory Uint32List.sublistView(TypedData data, [int start = 0, int? end]) {
  int elementSize = data.elementSizeInBytes;
  end = RangeError.checkValidRange(
    start,
    end,
    data.lengthInBytes ~/ elementSize,
  );
  int byteLength = (end - start) * elementSize;
  if (byteLength % bytesPerElement != 0) {
    throw ArgumentError(
      "The number of bytes to view must be a multiple of " +
          "$bytesPerElement",
    );
  }
  return data.buffer.asUint32List(
    data.offsetInBytes + start * elementSize,
    byteLength ~/ bytesPerElement,
  );
}

Uint32List.view() factory

factory Uint32List.view(ByteBuffer buffer, [int offsetInBytes = 0, int? length])

Creates a Uint32List view of the specified region in the specified byte buffer.

Changes in the Uint32List will be visible in the byte buffer and vice versa. If the offsetInBytes index of the region is not specified, it defaults to zero (the first byte in the byte buffer). If the length is not provided, the view extends to the end of the byte buffer.

The offsetInBytes and length must be non-negative, and offsetInBytes + (length * bytesPerElement) must be less than or equal to the length of buffer.

The offsetInBytes must be a multiple of bytesPerElement.

Note that when creating a view from a TypedData list or byte data, that list or byte data may itself be a view on a larger buffer with a TypedData.offsetInBytes greater than zero. Merely doing Uint32List.view(other.buffer, 0, count) may not point to the bytes you intended. Instead you may need to do:

Uint32List.view(other.buffer, other.offsetInBytes, count)

Alternatively, use Uint32List.sublistView which includes this computation:

Uint32List.sublistView(other, 0, count);

(The third argument is an end index rather than a length, so if you start from a position greater than zero, you need not reduce the count correspondingly).

Implementation

factory Uint32List.view(
  ByteBuffer buffer, [
  int offsetInBytes = 0,
  int? length,
]) {
  return buffer.asUint32List(offsetInBytes, length);
}

Properties

address extension no setter

Pointer<Uint32> get address

The memory address of the underlying data.

An expression of the form expression.address denoting this address can only occurr as an entire argument expression in the invocation of a leaf Native external function.

Example:

@Native<Void Function(Pointer<Uint32>)>(isLeaf: true)
external void myFunction(Pointer<Uint32> pointer);

void main() {
  final list = Uint32List(10);
  myFunction(list.address);
}

The expression before .address is evaluated like the left-hand-side of an assignment, to something that gives access to the storage behind the expression, which can be used both for reading and writing. The .address then gives a native pointer to that storage.

The .address is evaluated just before calling into native code when invoking a leaf Native external function. This ensures the Dart garbage collector will not move the object that the address points in to.

Available on Uint32List, provided by the Uint32ListAddress extension

Implementation

external Pointer<Uint32> get address;

buffer no setter inherited

ByteBuffer get buffer

The byte buffer associated with this object.

Inherited from TypedData.

Implementation

ByteBuffer get buffer;

elementSizeInBytes no setter inherited

int get elementSizeInBytes

The number of bytes in the representation of each element in this list.

Inherited from TypedData.

Implementation

int get elementSizeInBytes;

first read / write inherited

int get first

getter:

The first element.

Throws a StateError if this is empty. Otherwise returns the first element in the iteration order, equivalent to this.elementAt(0).

setter:

The first element of the list.

The list must be non-empty when accessing its first element.

The first element of a list can be modified, unlike an Iterable. A list.first is equivalent to list[0], both for getting and setting the value.

final numbers = <int>[1, 2, 3];
print(numbers.first); // 1
numbers.first = 10;
print(numbers.first); // 10
numbers.clear();
numbers.first; // Throws.

Inherited from Iterable.

Implementation

E get first {
  Iterator<E> it = iterator;
  if (!it.moveNext()) {
    throw IterableElementError.noElement();
  }
  return it.current;
}

void set first(E value);

hashCode no setter inherited

int get hashCode

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

Implementation

external int get hashCode;

isEmpty no setter inherited

bool get isEmpty

Whether this collection has no elements.

May be computed by checking if iterator.moveNext() returns false.

Example:

final emptyList = <int>[];
print(emptyList.isEmpty); // true;
print(emptyList.iterator.moveNext()); // false

Inherited from Iterable.

Implementation

bool get isEmpty => !iterator.moveNext();

isNotEmpty no setter inherited

bool get isNotEmpty

Whether this collection has at least one element.

May be computed by checking if iterator.moveNext() returns true.

Example:

final numbers = <int>{1, 2, 3};
print(numbers.isNotEmpty); // true;
print(numbers.iterator.moveNext()); // true

Inherited from Iterable.

Implementation

bool get isNotEmpty => !isEmpty;

iterator no setter inherited

Iterator<int> get iterator

A new Iterator that allows iterating the elements of this Iterable.

Iterable classes may specify the iteration order of their elements (for example List always iterate in index order), or they may leave it unspecified (for example a hash-based Set may iterate in any order).

Each time iterator is read, it returns a new iterator, which can be used to iterate through all the elements again. The iterators of the same iterable can be stepped through independently, but should return the same elements in the same order, as long as the underlying collection isn't changed.

Modifying the collection may cause new iterators to produce different elements, and may change the order of existing elements. A List specifies its iteration order precisely, so modifying the list changes the iteration order predictably. A hash-based Set may change its iteration order completely when adding a new element to the set.

Modifying the underlying collection after creating the new iterator may cause an error the next time Iterator.moveNext is called on that iterator. Any modifiable iterable class should specify which operations will break iteration.

Inherited from Iterable.

Implementation

Iterator<E> get iterator;

last read / write inherited

int get last

getter:

The last element.

Throws a StateError if this is empty. Otherwise may iterate through the elements and returns the last one seen. Some iterables may have more efficient ways to find the last element (for example a list can directly access the last element, without iterating through the previous ones).

setter:

The last element of the list.

The list must be non-empty when accessing its last element.

The last element of a list can be modified, unlike an Iterable. A list.last is equivalent to theList[theList.length - 1], both for getting and setting the value.

final numbers = <int>[1, 2, 3];
print(numbers.last); // 3
numbers.last = 10;
print(numbers.last); // 10
numbers.clear();
numbers.last; // Throws.

Inherited from Iterable.

Implementation

E get last {
  Iterator<E> it = iterator;
  if (!it.moveNext()) {
    throw IterableElementError.noElement();
  }
  E result;
  do {
    result = it.current;
  } while (it.moveNext());
  return result;
}

void set last(E value);

length read / write inherited

int get length

getter:

The number of objects in this list.

The valid indices for a list are 0 through length - 1.

final numbers = <int>[1, 2, 3];
print(numbers.length); // 3

setter:

Setting the length changes the number of elements in the list.

The list must be growable. If newLength is greater than current length, new entries are initialized to null, so newLength must not be greater than the current length if the element type E is non-nullable.

final maybeNumbers = <int?>[1, null, 3];
maybeNumbers.length = 5;
print(maybeNumbers); // [1, null, 3, null, null]
maybeNumbers.length = 2;
print(maybeNumbers); // [1, null]

final numbers = <int>[1, 2, 3];
numbers.length = 1;
print(numbers); // [1]
numbers.length = 5; // Throws, cannot add `null`s.

Inherited from List.

Implementation

int get length;

set length(int newLength);

lengthInBytes no setter inherited

int get lengthInBytes

The length of this view, in bytes.

Inherited from TypedData.

Implementation

int get lengthInBytes;

offsetInBytes no setter inherited

int get offsetInBytes

The offset of this view into the underlying byte buffer, in bytes.

Inherited from TypedData.

Implementation

int get offsetInBytes;

reversed no setter inherited

Iterable<int> get reversed

An Iterable of the objects in this list in reverse order.

final numbers = <String>['two', 'three', 'four'];
final reverseOrder = numbers.reversed;
print(reverseOrder.toList()); // [four, three, two]

Inherited from List.

Implementation

Iterable<E> get reversed;

runtimeType no setter inherited

Type get runtimeType

A representation of the runtime type of the object.

Inherited from Object.

Implementation

external Type get runtimeType;

single no setter inherited

int get single

Checks that this iterable has only one element, and returns that element.

Throws a StateError if this is empty or has more than one element. This operation will not iterate past the second element.

Inherited from Iterable.

Implementation

E get single {
  Iterator<E> it = iterator;
  if (!it.moveNext()) throw IterableElementError.noElement();
  E result = it.current;
  if (it.moveNext()) throw IterableElementError.tooMany();
  return result;
}

toJS extension no setter

JSUint32Array get toJS

Converts this Uint32List to a JSUint32Array by either casting, unwrapping, or cloning the Uint32List.

INFO

Depending on whether code is compiled to JavaScript or Wasm, this conversion will have different semantics.

When compiling to JavaScript, all typed lists are the equivalent JavaScript typed arrays, and therefore this getter simply casts.

When compiling to Wasm, this Uint32List is a wrapper around a Uint32Array if it was converted via JSUint32ArrayToUint32List.toDart. If it is a wrapper, this getter unwraps it and returns the Uint32Array. If it's instantiated in Dart, this getter clones this Uint32List's values into a new JSUint32Array.

Avoid assuming that modifications to this Uint32List will affect the returned JSUint32Array and vice versa on all compilers unless it was converted first via JSUint32ArrayToUint32List.toDart.

Available on Uint32List, provided by the Uint32ListToJSUint32Array extension

Implementation

external JSUint32Array get toJS;

Methods

add() inherited

void add(int value)

Adds value to the end of this list, extending the length by one.

The list must be growable.

final numbers = <int>[1, 2, 3];
numbers.add(4);
print(numbers); // [1, 2, 3, 4]

Inherited from List.

Implementation

void add(E value);

addAll() inherited

void addAll(Iterable<int> iterable)

Appends all objects of iterable to the end of this list.

Extends the length of the list by the number of objects in iterable. The list must be growable.

final numbers = <int>[1, 2, 3];
numbers.addAll([4, 5, 6]);
print(numbers); // [1, 2, 3, 4, 5, 6]

Inherited from List.

Implementation

void addAll(Iterable<E> iterable);

any() inherited

bool any(bool Function(int element) test)

Checks whether any element of this iterable satisfies test.

Checks every element in iteration order, and returns true if any of them make test return true, otherwise returns false. Returns false if the iterable is empty.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.any((element) => element >= 5); // true;
result = numbers.any((element) => element >= 10); // false;

Inherited from Iterable.

Implementation

bool any(bool test(E element)) {
  for (E element in this) {
    if (test(element)) return true;
  }
  return false;
}

asMap() inherited

Map<int, int> asMap()

An unmodifiable Map view of this list.

The map uses the indices of this list as keys and the corresponding objects as values. The Map.keys Iterable iterates the indices of this list in numerical order.

var words = <String>['fee', 'fi', 'fo', 'fum'];
var map = words.asMap();  // {0: fee, 1: fi, 2: fo, 3: fum}
map.keys.toList(); // [0, 1, 2, 3]

Inherited from List.

Implementation

Map<int, E> asMap();

asUnmodifiableView()

Uint32List asUnmodifiableView()

A read-only view of this Uint32List.

Implementation

@Since("3.3")
Uint32List asUnmodifiableView();

cast() inherited

List<R> cast<R>()

Returns a view of this list as a list of R instances.

If this list contains only instances of R, all read operations will work correctly. If any operation tries to read an element that is not an instance of R, the access will throw instead.

Elements added to the list (e.g., by using add or addAll) must be instances of R to be valid arguments to the adding function, and they must also be instances of E to be accepted by this list as well.

Methods which accept Object? as argument, like contains and remove, will pass the argument directly to the this list's method without any checks. That means that you can do listOfStrings.cast<int>().remove("a") successfully, even if it looks like it shouldn't have any effect.

Typically implemented as List.castFrom<E, R>(this).

Inherited from List.

Implementation

List<R> cast<R>();

clear() inherited

void clear()

Removes all objects from this list; the length of the list becomes zero.

The list must be growable.

final numbers = <int>[1, 2, 3];
numbers.clear();
print(numbers.length); // 0
print(numbers); // []

Inherited from List.

Implementation

void clear();

contains() inherited

bool contains(Object? element)

Whether the collection contains an element equal to element.

This operation will check each element in order for being equal to element, unless it has a more efficient way to find an element equal to element. Stops iterating on the first equal element.

The equality used to determine whether element is equal to an element of the iterable defaults to the Object.== of the element.

Some types of iterable may have a different equality used for its elements. For example, a Set may have a custom equality (see Set.identity) that its contains uses. Likewise the Iterable returned by a Map.keys call should use the same equality that the Map uses for keys.

Example:

final gasPlanets = <int, String>{1: 'Jupiter', 2: 'Saturn'};
final containsOne = gasPlanets.keys.contains(1); // true
final containsFive = gasPlanets.keys.contains(5); // false
final containsJupiter = gasPlanets.values.contains('Jupiter'); // true
final containsMercury = gasPlanets.values.contains('Mercury'); // false

Inherited from Iterable.

Implementation

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

elementAt() inherited

int elementAt(int index)

Returns the indexth element.

The index must be non-negative and less than length. Index zero represents the first element (so iterable.elementAt(0) is equivalent to iterable.first).

May iterate through the elements in iteration order, ignoring the first index elements and then returning the next. Some iterables may have a more efficient way to find the element.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
final elementAt = numbers.elementAt(4); // 6

Inherited from Iterable.

Implementation

E elementAt(int index) {
  RangeError.checkNotNegative(index, "index");
  var iterator = this.iterator;
  var skipCount = index;
  while (iterator.moveNext()) {
    if (skipCount == 0) return iterator.current;
    skipCount--;
  }
  throw IndexError.withLength(
    index,
    index - skipCount,
    indexable: this,
    name: "index",
  );
}

every() inherited

bool every(bool Function(int element) test)

Checks whether every element of this iterable satisfies test.

Checks every element in iteration order, and returns false if any of them make test return false, otherwise returns true. Returns true if the iterable is empty.

Example:

final planetsByMass = <double, String>{0.06: 'Mercury', 0.81: 'Venus',
  0.11: 'Mars'};
// Checks whether all keys are smaller than 1.
final every = planetsByMass.keys.every((key) => key < 1.0); // true

Inherited from Iterable.

Implementation

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

expand() inherited

Iterable<T> expand<T>(Iterable<T> Function(int element) toElements)

Expands each element of this Iterable into zero or more elements.

The resulting Iterable runs through the elements returned by toElements for each element of this, in iteration order.

The returned Iterable is lazy, and calls toElements for each element of this iterable every time the returned iterable is iterated.

Example:

Iterable<int> count(int n) sync* {
  for (var i = 1; i <= n; i++) {
    yield i;
   }
 }

var numbers = [1, 3, 0, 2];
print(numbers.expand(count)); // (1, 1, 2, 3, 1, 2)

Equivalent to:

Iterable<T> expand<T>(Iterable<T> toElements(E e)) sync* {
  for (var value in this) {
    yield* toElements(value);
  }
}

Inherited from Iterable.

Implementation

Iterable<T> expand<T>(Iterable<T> toElements(E element)) =>
    ExpandIterable<E, T>(this, toElements);

fillRange() inherited

void fillRange(int start, int end, [int? fillValue])

Overwrites a range of elements with fillValue.

Sets the positions greater than or equal to start and less than end, to fillValue.

The provided range, given by start and end, must be valid. A range from start to end is valid if 0 ≤ start ≤ end ≤ length. An empty range (with end == start) is valid.

If the element type is not nullable, the fillValue must be provided and must be non-null.

Example:

final words = List.filled(5, 'old');
print(words); // [old, old, old, old, old]
words.fillRange(1, 3, 'new');
print(words); // [old, new, new, old, old]

Inherited from List.

Implementation

void fillRange(int start, int end, [E? fillValue]);

firstWhere() inherited

int firstWhere(bool Function(int element) test, {(int Function())? orElse})

The first element that satisfies the given predicate test.

Iterates through elements and returns the first to satisfy test.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.firstWhere((element) => element < 5); // 1
result = numbers.firstWhere((element) => element > 5); // 6
result =
    numbers.firstWhere((element) => element > 10, orElse: () => -1); // -1

If no element satisfies test, the result of invoking the orElse function is returned. If orElse is omitted, it defaults to throwing a StateError. Stops iterating on the first matching element.

Inherited from Iterable.

Implementation

E firstWhere(bool test(E element), {E orElse()?}) {
  for (E element in this) {
    if (test(element)) return element;
  }
  if (orElse != null) return orElse();
  throw IterableElementError.noElement();
}

fold() inherited

T fold<T>(T initialValue, T Function(T previousValue, int element) combine)

Reduces a collection to a single value by iteratively combining each element of the collection with an existing value

Uses initialValue as the initial value, then iterates through the elements and updates the value with each element using the combine function, as if by:

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

Example of calculating the sum of an iterable:

final numbers = <double>[10, 2, 5, 0.5];
const initialValue = 100.0;
final result = numbers.fold<double>(
    initialValue, (previousValue, element) => previousValue + element);
print(result); // 117.5

Inherited from Iterable.

Implementation

T fold<T>(T initialValue, T combine(T previousValue, E element)) {
  var value = initialValue;
  for (E element in this) value = combine(value, element);
  return value;
}

followedBy() inherited

Iterable<int> followedBy(Iterable<int> other)

Creates the lazy concatenation of this iterable and other.

The returned iterable will provide the same elements as this iterable, and, after that, the elements of other, in the same order as in the original iterables.

Example:

var planets = <String>['Earth', 'Jupiter'];
var updated = planets.followedBy(['Mars', 'Venus']);
print(updated); // (Earth, Jupiter, Mars, Venus)

Inherited from Iterable.

Implementation

Iterable<E> followedBy(Iterable<E> other) {
  var self = this; &#47;&#47; TODO(lrn): Remove when we can promote `this`.
  if (self is EfficientLengthIterable<E>) {
    return FollowedByIterable<E>.firstEfficient(self, other);
  }
  return FollowedByIterable<E>(this, other);
}

forEach() inherited

void forEach(void Function(int value) action)

Invokes action on each element of this iterable in iteration order.

Example:

final numbers = <int>[1, 2, 6, 7];
numbers.forEach(print);
// 1
// 2
// 6
// 7

Inherited from Iterable.

Implementation

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

getRange() inherited

Iterable<int> getRange(int start, int end)

Creates an Iterable that iterates over a range of elements.

The returned iterable iterates over the elements of this list with positions greater than or equal to start and less than end.

The provided range, start and end, must be valid at the time of the call. A range from start to end is valid if 0 ≤ start ≤ end ≤ length. An empty range (with end == start) is valid.

The returned Iterable behaves like skip(start).take(end - start). That is, it does not break if this list changes size, it just ends early if it reaches the end of the list early (if end, or even start, becomes greater than length).

final colors = <String>['red', 'green', 'blue', 'orange', 'pink'];
final firstRange = colors.getRange(0, 3);
print(firstRange.join(', ')); // red, green, blue

final secondRange = colors.getRange(2, 5);
print(secondRange.join(', ')); // blue, orange, pink

Inherited from List.

Implementation

Iterable<E> getRange(int start, int end);

indexOf() inherited

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

The first index of element in this list.

Searches the list from index start to the end of the list. The first time an object o is encountered so that o == element, the index of o is returned.

final notes = <String>['do', 're', 'mi', 're'];
print(notes.indexOf('re')); // 1

final indexWithStart = notes.indexOf('re', 2); // 3

Returns -1 if element is not found.

final notes = <String>['do', 're', 'mi', 're'];
final index = notes.indexOf('fa'); // -1

Inherited from List.

Implementation

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

indexWhere() inherited

int indexWhere(bool Function(int element) test, [int start = 0])

The first index in the list that satisfies the provided test.

Searches the list from index start to the end of the list. The first time an object o is encountered so that test(o) is true, the index of o is returned.

final notes = <String>['do', 're', 'mi', 're'];
final first = notes.indexWhere((note) => note.startsWith('r')); // 1
final second = notes.indexWhere((note) => note.startsWith('r'), 2); // 3

Returns -1 if element is not found.

final notes = <String>['do', 're', 'mi', 're'];
final index = notes.indexWhere((note) => note.startsWith('k')); // -1

Inherited from List.

Implementation

int indexWhere(bool test(E element), [int start = 0]);

insert() inherited

void insert(int index, int element)

Inserts element at position index in this list.

This increases the length of the list by one and shifts all objects at or after the index towards the end of the list.

The list must be growable. The index value must be non-negative and no greater than length.

final numbers = <int>[1, 2, 3, 4];
const index = 2;
numbers.insert(index, 10);
print(numbers); // [1, 2, 10, 3, 4]

Inherited from List.

Implementation

void insert(int index, E element);

insertAll() inherited

void insertAll(int index, Iterable<int> iterable)

Inserts all objects of iterable at position index in this list.

This increases the length of the list by the length of iterable and shifts all later objects towards the end of the list.

The list must be growable. The index value must be non-negative and no greater than length.

final numbers = <int>[1, 2, 3, 4];
final insertItems = [10, 11];
numbers.insertAll(2, insertItems);
print(numbers); // [1, 2, 10, 11, 3, 4]

Inherited from List.

Implementation

void insertAll(int index, Iterable<E> iterable);

join() inherited

String join([String separator = ""])

Converts each element to a String and concatenates the strings.

Iterates through elements of this iterable, converts each one to a String by calling Object.toString, and then concatenates the strings, with the separator string interleaved between the elements.

Example:

final planetsByMass = <double, String>{0.06: 'Mercury', 0.81: 'Venus',
  0.11: 'Mars'};
final joinedNames = planetsByMass.values.join('-'); // Mercury-Venus-Mars

Inherited from Iterable.

Implementation

String join([String separator = ""]) {
  Iterator<E> iterator = this.iterator;
  if (!iterator.moveNext()) return "";
  var first = iterator.current.toString();
  if (!iterator.moveNext()) return first;
  var buffer = StringBuffer(first);
  &#47;&#47; TODO(51681): Drop null check when de-supporting pre-2.12 code.
  if (separator == null || separator.isEmpty) {
    do {
      buffer.write(iterator.current.toString());
    } while (iterator.moveNext());
  } else {
    do {
      buffer
        ..write(separator)
        ..write(iterator.current.toString());
    } while (iterator.moveNext());
  }
  return buffer.toString();
}

lastIndexOf() inherited

int lastIndexOf(int element, [int? start])

The last index of element in this list.

Searches the list backwards from index start to 0.

The first time an object o is encountered so that o == element, the index of o is returned.

final notes = <String>['do', 're', 'mi', 're'];
const startIndex = 2;
final index = notes.lastIndexOf('re', startIndex); // 1

If start is not provided, this method searches from the end of the list.

final notes = <String>['do', 're', 'mi', 're'];
final index = notes.lastIndexOf('re'); // 3

Returns -1 if element is not found.

final notes = <String>['do', 're', 'mi', 're'];
final index = notes.lastIndexOf('fa'); // -1

Inherited from List.

Implementation

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

lastIndexWhere() inherited

int lastIndexWhere(bool Function(int element) test, [int? start])

The last index in the list that satisfies the provided test.

Searches the list from index start to 0. The first time an object o is encountered so that test(o) is true, the index of o is returned. If start is omitted, it defaults to the length of the list.

final notes = <String>['do', 're', 'mi', 're'];
final first = notes.lastIndexWhere((note) => note.startsWith('r')); // 3
final second = notes.lastIndexWhere((note) => note.startsWith('r'),
    2); // 1

Returns -1 if element is not found.

final notes = <String>['do', 're', 'mi', 're'];
final index = notes.lastIndexWhere((note) => note.startsWith('k'));
print(index); // -1

Inherited from List.

Implementation

int lastIndexWhere(bool test(E element), [int? start]);

lastWhere() inherited

int lastWhere(bool Function(int element) test, {(int Function())? orElse})

The last element that satisfies the given predicate test.

An iterable that can access its elements directly may check its elements in any order (for example a list starts by checking the last element and then moves towards the start of the list). The default implementation iterates elements in iteration order, checks test(element) for each, and finally returns that last one that matched.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.lastWhere((element) => element < 5); // 3
result = numbers.lastWhere((element) => element > 5); // 7
result = numbers.lastWhere((element) => element > 10,
    orElse: () => -1); // -1

If no element satisfies test, the result of invoking the orElse function is returned. If orElse is omitted, it defaults to throwing a StateError.

Inherited from Iterable.

Implementation

E lastWhere(bool test(E element), {E orElse()?}) {
  var iterator = this.iterator;
  // Potential result during first loop.
  E result;
  do {
    if (!iterator.moveNext()) {
      if (orElse != null) return orElse();
      throw IterableElementError.noElement();
    }
    result = iterator.current;
  } while (!test(result));
  // Now `result` is actual result, unless a later one is found.
  while (iterator.moveNext()) {
    var current = iterator.current;
    if (test(current)) result = current;
  }
  return result;
}

map() inherited

Iterable<T> map<T>(T Function(int e) toElement)

The current elements of this iterable modified by toElement.

Returns a new lazy Iterable with elements that are created by calling toElement on each element of this Iterable in iteration order.

The returned iterable is lazy, so it won't iterate the elements of this iterable until it is itself iterated, and then it will apply toElement to create one element at a time. The converted elements are not cached. Iterating multiple times over the returned Iterable will invoke the supplied toElement function once per element for on each iteration.

Methods on the returned iterable are allowed to omit calling toElement on any element where the result isn't needed. For example, elementAt may call toElement only once.

Equivalent to:

Iterable<T> map<T>(T toElement(E e)) sync* {
  for (var value in this) {
    yield toElement(value);
  }
}

Example:

var products = jsonDecode('''
[
  {"name": "Screwdriver", "price": 42.00},
  {"name": "Wingnut", "price": 0.50}
]
''');
var values = products.map((product) => product['price'] as double);
var totalPrice = values.fold(0.0, (a, b) => a + b); // 42.5.

Inherited from Iterable.

Implementation

Iterable<T> map<T>(T toElement(E e)) => MappedIterable<E, T>(this, toElement);

noSuchMethod() inherited

dynamic noSuchMethod(Invocation invocation)

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

Implementation

@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

reduce() inherited

int reduce(int Function(int value, int element) combine)

Reduces a collection to a single value by iteratively combining elements of the collection using the provided function.

The iterable must have at least one element. If it has only one element, that element is returned.

Otherwise this method starts with the first element from the iterator, and then combines it with the remaining elements in iteration order, as if by:

E value = iterable.first;
iterable.skip(1).forEach((element) {
  value = combine(value, element);
});
return value;

Example of calculating the sum of an iterable:

final numbers = <double>[10, 2, 5, 0.5];
final result = numbers.reduce((value, element) => value + element);
print(result); // 17.5

Consider using fold if the iterable can be empty.

Inherited from Iterable.

Implementation

E reduce(E combine(E value, E element)) {
  Iterator<E> iterator = this.iterator;
  if (!iterator.moveNext()) {
    throw IterableElementError.noElement();
  }
  E value = iterator.current;
  while (iterator.moveNext()) {
    value = combine(value, iterator.current);
  }
  return value;
}

remove() inherited

bool remove(Object? value)

Removes the first occurrence of value from this list.

Returns true if value was in the list, false otherwise. The list must be growable.

final parts = <String>['head', 'shoulders', 'knees', 'toes'];
final retVal = parts.remove('head'); // true
print(parts); // [shoulders, knees, toes]

The method has no effect if value was not in the list.

final parts = <String>['shoulders', 'knees', 'toes'];
// Note: 'head' has already been removed.
final retVal = parts.remove('head'); // false
print(parts); // [shoulders, knees, toes]

Inherited from List.

Implementation

bool remove(Object? value);

removeAt() inherited

int removeAt(int index)

Removes the object at position index from this list.

This method reduces the length of this by one and moves all later objects down by one position.

Returns the removed value.

The index must be in the range 0 ≤ index < length. The list must be growable.

final parts = <String>['head', 'shoulder', 'knees', 'toes'];
final retVal = parts.removeAt(2); // knees
print(parts); // [head, shoulder, toes]

Inherited from List.

Implementation

E removeAt(int index);

removeLast() inherited

int removeLast()

Removes and returns the last object in this list.

The list must be growable and non-empty.

final parts = <String>['head', 'shoulder', 'knees', 'toes'];
final retVal = parts.removeLast(); // toes
print(parts); // [head, shoulder, knees]

Inherited from List.

Implementation

E removeLast();

removeRange() inherited

void removeRange(int start, int end)

Removes a range of elements from the list.

Removes the elements with positions greater than or equal to start and less than end, from the list. This reduces the list's length by end - start.

The provided range, given by start and end, must be valid. A range from start to end is valid if 0 ≤ start ≤ end ≤ length. An empty range (with end == start) is valid.

The list must be growable.

final numbers = <int>[1, 2, 3, 4, 5];
numbers.removeRange(1, 4);
print(numbers); // [1, 5]

Inherited from List.

Implementation

void removeRange(int start, int end);

removeWhere() inherited

void removeWhere(bool Function(int element) test)

Removes all objects from this list that satisfy test.

An object o satisfies test if test(o) is true.

final numbers = <String>['one', 'two', 'three', 'four'];
numbers.removeWhere((item) => item.length == 3);
print(numbers); // [three, four]

The list must be growable.

Inherited from List.

Implementation

void removeWhere(bool test(E element));

replaceRange() inherited

void replaceRange(int start, int end, Iterable<int> replacements)

Replaces a range of elements with the elements of replacements.

Removes the objects in the range from start to end, then inserts the elements of replacements at start.

final numbers = <int>[1, 2, 3, 4, 5];
final replacements = [6, 7];
numbers.replaceRange(1, 4, replacements);
print(numbers); // [1, 6, 7, 5]

The provided range, given by start and end, must be valid. A range from start to end is valid if 0 ≤ start ≤ end ≤ length. An empty range (with end == start) is valid.

The operation list.replaceRange(start, end, replacements) is roughly equivalent to:

final numbers = <int>[1, 2, 3, 4, 5];
numbers.removeRange(1, 4);
final replacements = [6, 7];
numbers.insertAll(1, replacements);
print(numbers); // [1, 6, 7, 5]

but may be more efficient.

The list must be growable. This method does not work on fixed-length lists, even when replacements has the same number of elements as the replaced range. In that case use setRange instead.

Inherited from List.

Implementation

void replaceRange(int start, int end, Iterable<E> replacements);

retainWhere() inherited

void retainWhere(bool Function(int element) test)

Removes all objects from this list that fail to satisfy test.

An object o satisfies test if test(o) is true.

final numbers = <String>['one', 'two', 'three', 'four'];
numbers.retainWhere((item) => item.length == 3);
print(numbers); // [one, two]

The list must be growable.

Inherited from List.

Implementation

void retainWhere(bool test(E element));

setAll() inherited

void setAll(int index, Iterable<int> iterable)

Overwrites elements with the objects of iterable.

The elements of iterable are written into this list, starting at position index. This operation does not increase the length of the list.

The index must be non-negative and no greater than length.

The iterable must not have more elements than what can fit from index to length.

If iterable is based on this list, its values may change during the setAll operation.

final list = <String>['a', 'b', 'c', 'd'];
list.setAll(1, ['bee', 'sea']);
print(list); // [a, bee, sea, d]

Inherited from List.

Implementation

void setAll(int index, Iterable<E> iterable);

setRange() inherited

void setRange(int start, int end, Iterable<int> iterable, [int skipCount = 0])

Writes some elements of iterable into a range of this list.

Copies the objects of iterable, skipping skipCount objects first, into the range from start, inclusive, to end, exclusive, of this list.

final list1 = <int>[1, 2, 3, 4];
final list2 = <int>[5, 6, 7, 8, 9];
// Copies the 4th and 5th items in list2 as the 2nd and 3rd items
// of list1.
const skipCount = 3;
list1.setRange(1, 3, list2, skipCount);
print(list1); // [1, 8, 9, 4]

The provided range, given by start and end, must be valid. A range from start to end is valid if 0 ≤ start ≤ end ≤ length. An empty range (with end == start) is valid.

The iterable must have enough objects to fill the range from start to end after skipping skipCount objects.

If iterable is this list, the operation correctly copies the elements originally in the range from skipCount to skipCount + (end - start) to the range start to end, even if the two ranges overlap.

If iterable depends on this list in some other way, no guarantees are made.

Inherited from List.

Implementation

void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]);

shuffle() inherited

void shuffle([Random? random])

Shuffles the elements of this list randomly.

final numbers = <int>[1, 2, 3, 4, 5];
numbers.shuffle();
print(numbers); // [1, 3, 4, 5, 2] OR some other random result.

Inherited from List.

Implementation

void shuffle([Random? random]);

singleWhere() inherited

int singleWhere(bool Function(int element) test, {(int Function())? orElse})

The single element that satisfies test.

Checks elements to see if test(element) returns true. If exactly one element satisfies test, that element is returned. If more than one matching element is found, throws StateError. If no matching element is found, returns the result of orElse. If orElse is omitted, it defaults to throwing a StateError.

Example:

final numbers = <int>[2, 2, 10];
var result = numbers.singleWhere((element) => element > 5); // 10

When no matching element is found, the result of calling orElse is returned instead.

result = numbers.singleWhere((element) => element == 1,
    orElse: () => -1); // -1

There must not be more than one matching element.

result = numbers.singleWhere((element) => element == 2); // Throws Error.

Inherited from Iterable.

Implementation

E singleWhere(bool test(E element), {E orElse()?}) {
  var iterator = this.iterator;
  E result;
  do {
    if (!iterator.moveNext()) {
      if (orElse != null) return orElse();
      throw IterableElementError.noElement();
    }
    result = iterator.current;
  } while (!test(result));
  while (iterator.moveNext()) {
    if (test(iterator.current)) throw IterableElementError.tooMany();
  }
  return result;
}

skip() inherited

Iterable<int> skip(int count)

Creates an Iterable that provides all but the first count elements.

When the returned iterable is iterated, it starts iterating over this, first skipping past the initial count elements. If this has fewer than count elements, then the resulting Iterable is empty. After that, the remaining elements are iterated in the same order as in this iterable.

Some iterables may be able to find later elements without first iterating through earlier elements, for example when iterating a List. Such iterables are allowed to ignore the initial skipped elements.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
final result = numbers.skip(4); // (6, 7)
final skipAll = numbers.skip(100); // () - no elements.

The count must not be negative.

Inherited from Iterable.

Implementation

Iterable<E> skip(int count) => SkipIterable<E>(this, count);

skipWhile() inherited

Iterable<int> skipWhile(bool Function(int element) test)

Creates an Iterable that skips leading elements while test is satisfied.

The filtering happens lazily. Every new Iterator of the returned iterable iterates over all elements of this.

The returned iterable provides elements by iterating this iterable, but skipping over all initial elements where test(element) returns true. If all elements satisfy test the resulting iterable is empty, otherwise it iterates the remaining elements in their original order, starting with the first element for which test(element) returns false.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.skipWhile((x) => x < 5); // (5, 6, 7)
result = numbers.skipWhile((x) => x != 3); // (3, 5, 6, 7)
result = numbers.skipWhile((x) => x != 4); // ()
result = numbers.skipWhile((x) => x.isOdd); // (2, 3, 5, 6, 7)

Inherited from Iterable.

Implementation

Iterable<E> skipWhile(bool test(E value)) => SkipWhileIterable<E>(this, test);

sort() inherited

void sort([(int Function(int a, int b))? compare])

Sorts this list according to the order specified by the compare function.

The compare function must act as a Comparator.

final numbers = <String>['two', 'three', 'four'];
// Sort from shortest to longest.
numbers.sort((a, b) => a.length.compareTo(b.length));
print(numbers); // [two, four, three]

The default List implementations use Comparable.compare if compare is omitted.

final numbers = <int>[13, 2, -11, 0];
numbers.sort();
print(numbers); // [-11, 0, 2, 13]

In that case, the elements of the list must be Comparable to each other.

A Comparator may compare objects as equal (return zero), even if they are distinct objects. The sort function is not guaranteed to be stable, so distinct objects that compare as equal may occur in any order in the result:

final numbers = <String>['one', 'two', 'three', 'four'];
numbers.sort((a, b) => a.length.compareTo(b.length));
print(numbers); // [one, two, four, three] OR [two, one, four, three]

Inherited from List.

Implementation

void sort([int compare(E a, E b)?]);

sublist() override

Uint32List sublist(int start, [int? end])

Creates a new list containing the elements between start and end.

The new list is a Uint32List containing the elements of this list at positions greater than or equal to start and less than end in the same order as they occur in this list.

var numbers = Uint32List.fromList([0, 1, 2, 3, 4]);
print(numbers.sublist(1, 3)); // [1, 2]
print(numbers.sublist(1, 3).runtimeType); // Uint32List

If end is omitted, it defaults to the length of this list.

print(numbers.sublist(1)); // [1, 2, 3, 4]

The start and end positions must satisfy the relations 0 ≤ start ≤ end ≤ this.length. If end is equal to start, then the returned list is empty.

Implementation

Uint32List sublist(int start, [int? end]);

take() inherited

Iterable<int> take(int count)

Creates a lazy iterable of the count first elements of this iterable.

The returned Iterable may contain fewer than count elements, if this contains fewer than count elements.

The elements can be computed by stepping through iterator until count elements have been seen.

The count must not be negative.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
final result = numbers.take(4); // (1, 2, 3, 5)
final takeAll = numbers.take(100); // (1, 2, 3, 5, 6, 7)

Inherited from Iterable.

Implementation

Iterable<E> take(int count) => TakeIterable<E>(this, count);

takeWhile() inherited

Iterable<int> takeWhile(bool Function(int element) test)

Creates a lazy iterable of the leading elements satisfying test.

The filtering happens lazily. Every new iterator of the returned iterable starts iterating over the elements of this.

The elements can be computed by stepping through iterator until an element is found where test(element) is false. At that point, the returned iterable stops (its moveNext() returns false).

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.takeWhile((x) => x < 5); // (1, 2, 3)
result = numbers.takeWhile((x) => x != 3); // (1, 2)
result = numbers.takeWhile((x) => x != 4); // (1, 2, 3, 5, 6, 7)
result = numbers.takeWhile((x) => x.isOdd); // (1)

Inherited from Iterable.

Implementation

Iterable<E> takeWhile(bool test(E value)) => TakeWhileIterable<E>(this, test);

toList() inherited

List<int> toList({bool growable = true})

Creates a List containing the elements of this Iterable.

The elements are in iteration order. The list is fixed-length if growable is false.

Example:

final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Mars'};
final keysList = planets.keys.toList(growable: false); // [1, 2, 3]
final valuesList =
    planets.values.toList(growable: false); // [Mercury, Venus, Mars]

Inherited from Iterable.

Implementation

List<E> toList({bool growable = true}) =>
    List<E>.of(this, growable: growable);

toSet() inherited

Set<int> toSet()

Creates a Set containing the same elements as this iterable.

The set may contain fewer elements than the iterable, if the iterable contains an element more than once, or it contains one or more elements that are equal. The order of the elements in the set is not guaranteed to be the same as for the iterable.

Example:

final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Mars'};
final valueSet = planets.values.toSet(); // {Mercury, Venus, Mars}

Inherited from Iterable.

Implementation

Set<E> toSet() => Set<E>.of(this);

toString() inherited

String toString()

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Inherited from Object.

Implementation

external String toString();

where() inherited

Iterable<int> where(bool Function(int element) test)

Creates a new lazy Iterable with all elements that satisfy the predicate test.

The matching elements have the same order in the returned iterable as they have in iterator.

This method returns a view of the mapped elements. As long as the returned Iterable is not iterated over, the supplied function test will not be invoked. Iterating will not cache results, and thus iterating multiple times over the returned Iterable may invoke the supplied function test multiple times on the same element.

Example:

final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.where((x) => x < 5); // (1, 2, 3)
result = numbers.where((x) => x > 5); // (6, 7)
result = numbers.where((x) => x.isEven); // (2, 6)

Inherited from Iterable.

Implementation

Iterable<E> where(bool test(E element)) => WhereIterable<E>(this, test);

whereType() inherited

Iterable<T> whereType<T>()

Creates a new lazy Iterable with all elements that have type T.

The matching elements have the same order in the returned iterable as they have in iterator.

This method returns a view of the mapped elements. Iterating will not cache results, and thus iterating multiple times over the returned Iterable may yield different results, if the underlying elements change between iterations.

Inherited from Iterable.

Implementation

Iterable<T> whereType<T>() => WhereTypeIterable<T>(this);

Operators

operator +() inherited

List<int> operator +(List<int> other)

The concatenation of this list and other.

If other is also a typed-data integer list, the returned list will be a type-data integer list capable of containing all the elements of this list and of other. Otherwise the returned list will be a normal growable List<int>.

Inherited from _TypedIntList.

Implementation

List<int> operator +(List<int> other);

operator ==() inherited

bool operator ==(Object other)

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

• Total: It must return a boolean for all arguments. It should never throw.

• Reflexive: For all objects o, o == o must be true.

• Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.

• Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

Implementation

external bool operator ==(Object other);

operator inherited

int operator [](int index)

The object at the given index in the list.

The index must be a valid index of this list, which means that index must be non-negative and less than length.

Inherited from List.

Implementation

E operator [](int index);

operator []=() inherited

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

Sets the value at the given index in the list to value.

The index must be a valid index of this list, which means that index must be non-negative and less than length.

Inherited from List.

Implementation

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

Constants

bytesPerElement

const int bytesPerElement

Implementation

static const int bytesPerElement = 4;