ListQueue<E>final

基于列表的 Queue

保留一个循环缓冲区,当填满时扩展到更大的缓冲区。这保证了常数时间的 peek 和 remove 操作,以及摊销常数时间的 add 操作。

该结构对于任何队列或栈的使用都很高效。

示例

final queue = ListQueue<int>();

要将对象添加到队列中,请使用 addaddAlladdFirstaddLast

queue.add(5);
queue.addFirst(0);
queue.addLast(10);
queue.addAll([1, 2, 3]);
print(queue); // {0, 5, 10, 1, 2, 3}

要检查队列是否为空,请使用 isEmptyisNotEmpty。要查找队列条目数,请使用 length

final isEmpty = queue.isEmpty; // false
final queueSize = queue.length; // 6

要从队列中获取第一个或最后一个项目,请使用 firstlast

final first = queue.first; // 0
final last = queue.last; // 3

要使用索引获取项目值,请使用 elementAt

final itemAt = queue.elementAt(2); // 10

要将队列转换为列表,请调用 toList

final numbers = queue.toList();
print(numbers); // [0, 5, 10, 1, 2, 3]

要从队列中移除项目,请调用 removeremoveFirstremoveLast

queue.remove(10);
queue.removeFirst();
queue.removeLast();
print(queue); // {5, 1, 2}

要同时移除多个元素,请使用 removeWhere

queue.removeWhere((element) => element == 1);
print(queue); // {5, 2}

要移除所有不满足条件的元素,请使用 retainWhere

queue.retainWhere((element) => element < 4);
print(queue); // {2}

要移除所有项目并清空集合,请使用 clear

queue.clear();
print(queue.isEmpty); // true
print(queue); // {}
继承
实现类型
可用的扩展

构造函数

ListQueue([int? initialCapacity])
创建一个空队列。
ListQueue.from(Iterable elements)
创建包含所有 elementsListQueue
工厂
ListQueue.of(Iterable<E> elements)
elements 创建一个 ListQueue
工厂

属性

first → E
第一个元素。
无设置器
hashCode int
此对象的哈希码。
无设置器继承
isEmpty bool
此集合是否没有元素。
无设置器
isNotEmpty bool
判断此集合是否至少有一个元素。
无设置器继承
iterator Iterator<E>
一个新的 Iterator,允许迭代此 Iterable 的元素。
无设置器
last → E
最后一个元素。
无设置器
length int
返回可迭代对象中的元素数量。
无设置器
runtimeType Type
表示对象的运行时类型。
无设置器继承
single → E
检查此可迭代是否只有一个元素,并返回该元素。
无设置器

方法

add(E value) → void
value 添加到队列的末尾。
覆盖
addAll(Iterable<E> elements) → void
iterable 的所有元素添加到队列的末尾。队列的长度增加 iterable 的长度。
覆盖
addFirst(E value) → void
value 添加到队列的开头。
覆盖
addLast(E value) → void
value 添加到队列的末尾。
覆盖
any(bool test(E element)) bool
检查此可迭代中的任何元素是否满足 test
继承
cast<R>() Queue<R>
将此可迭代视为 R 实例的可迭代视图。
覆盖
clear() → void
从队列中删除所有元素。队列的大小变为零。
覆盖
contains(Object? element) bool
集合是否包含与 element 等价的元素。
继承
elementAt(int index) → E
返回第 index 个元素。
every(bool test(E element)) bool
检查此可迭代对象的每个元素是否满足 test 条件。
继承
expand<T>(Iterable<T> toElements(E element)) Iterable<T>
将此可迭代对象的每个元素展开为零个或多个元素。
继承
firstWhere(bool test(E element), {bool orElse()?}) → E
返回满足给定谓词 test 的第一个元素。
继承
fold<T>(T initialValue, T combine(T previousValue, E element)) → T
通过迭代将每个元素与现有值组合来减少集合到一个单一值。
继承
followedBy(Iterable<E> other) Iterable<E>
创建此可迭代对象和 other 的懒加和。
继承
forEach(void f(E element)) → void
按迭代顺序对每个元素调用 action
join([String separator = ""]) String
将每个元素转换为 String 并连接这些字符串。
继承
lastWhere(bool test(E element), {E orElse()?}) → E
返回满足给定谓词 test 的最后一个元素。
继承
map<T>(T toElement(E element)) Iterable<T>
通过 toElement 修改当前可迭代元素的迭代器。
继承
noSuchMethod(Invocation invocation) → dynamic
当访问不存在的函数或属性时被调用。
继承
reduce(E combine(E value, E element)) → E
通过迭代使用提供的函数组合集合的元素,将集合减少到单个值。
继承
remove(Object? value) bool
从队列中移除 value 的单个实例。
覆盖
removeFirst() → E
移除并返回队列的第一个元素。
覆盖
removeLast() → E
移除并返回队列的最后一个元素。
覆盖
removeWhere(bool test(E element)) → void
移除所有匹配 test 的元素。
覆盖
retainWhere(bool test(E element)) → void
移除所有不匹配 test 的元素。
覆盖
singleWhere(bool test(E element), {E orElse()?}) → E
满足 test 的单个元素。
继承
skip(int count) Iterable<E>
创建一个Iterable,提供除了前 count 个元素之外的所有元素。
继承
skipWhile(bool test(E element)) Iterable<E>
创建一个Iterable,在 test 满足条件时跳过前面的元素。
继承
take(int count) Iterable<E>
创建一个惰性可迭代对象,包含这个可迭代对象的前 count 个元素。
继承
takeWhile(bool test(E element)) Iterable<E>
创建一个惰性可迭代对象,包含满足 test 的前面的元素。
继承
toList({bool growable = true}) List<E>
创建一个包含此 Iterable 元素的 List
toSet() Set<E>
创建一个包含与此可迭代相同元素的 Set
继承
toString() String
返回(此)元素的字符串表示形式。
覆盖
where(bool test(E element)) Iterable<E>
创建一个新的惰性 Iterable,包含所有满足谓词 test 的元素。
继承
whereType<T>() Iterable<T>
创建一个新的惰性 Iterable,包含所有类型为 T 的元素。
继承

运算符

operator ==(Object other) bool
等于运算符。
继承