ListQueue<E>final

基于列表的 队列

保持元素循环缓冲区,当缓冲区填满时会扩展到更大的缓冲区。这保证了常时间的 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
第一个元素。
没有setter
hashCode int
该对象的哈希码。
没有setter继承
isEmpty bool
该收集是否没有元素。
没有setter
isNotEmpty bool
该收集是否至少有一个元素。
没有setter继承
iterator Iterator<E>
一个新的允许迭代此 Iterable 元素的 Iterator
没有setter
last → E
最后一个元素。
没有setter
length int
返回可迭代对象中的元素数量。
没有setter
runtimeType Type
表示对象运行时类型的表现。
没有setter继承
single → E
检查这个可迭代对象是否只有一个元素,并返回该元素。
没有setter

方法

add(E value) → void
value 添加到队列的末尾。
覆盖
addAll(IterableE> 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>
将此Iterable的每个元素扩展为零个或多个元素。
继承
firstWhere(bool test(E element), {E 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>
创建一个不提供前 count 个元素的 Iterable
继承
skipWhile(bool test(E element)) Iterable<E>
test 条件满足时,跳过前面的元素以创建一个 Iterable
继承
take(int count) Iterable<E>
创建一个包含此可迭代器前 count 个元素的懒惰可迭代器。
继承
takeWhile(bool test(E element)) Iterable<E>
创建一个满足 test 的前导元素的懒惰可迭代器。
继承
toList({bool growable = true}) List<E>
创建一个包含此 可迭代器 元素的 列表
toSet() Set<E>
创建一个包含与此可迭代器相同元素的 集合
继承
toString() String
返回 (部分) 此的字符串表示形式。
覆盖
where(bool test(E element)) Iterable<E>
创建一个包含满足谓词 test 的所有元素的新的懒惰 可迭代器
继承
whereType<T>() Iterable<T>
创建一个包含具有类型 T 的所有元素的新的懒惰 可迭代器
继承

运算符

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