类

通过传入的比较函数，根据其返回值 Ordering 类型的结果，可对数组进行自定义排序comparator: (t1: T, t2: T) -> Ordering，如果 comparator 的返回值为 Ordering.GT，排序后 t1 在 t2后；如果 comparator 的返回值为 Ordering.LT，排序后 t1 在t2 前；如果 comparator 的返回值为 Ordering.EQ，且为稳定排序，那么 t1 在 t2 之前；如果 comparator 的返回值为 Ordering.EQ，且为不稳定排序，那么 t1，t2 顺序不确定。

参数：

stable!: Bool - 是否使用稳定排序。
comparator!: (T, T) ->Ordering - (T, T) -> Ordering 类型。

func toArray()

public func toArray(): Array<T>

功能：返回一个数组，其中包含此列表中按正确顺序排列的所有元素。

返回值：

Array<T> - T 类型数组。

operator func [](Int64)

public operator func [](index: Int64): T

功能：操作符重载 - get。

参数：

index: Int64 - 表示 get 接口的索引。

返回值：

T - 索引位置的元素的值。

异常：

IndexOutOfBoundsException - 当 index 超出范围时，抛出异常。

operator func [](Int64, T)

public operator func [](index: Int64, value!: T): Unit

功能：操作符重载 - set，通过下标运算符用指定的元素替换此列表中指定位置的元素。

参数：

index: Int64 - 要设置的索引值。
value!: T - 要设置的 T 类型的值。

异常：

IndexOutOfBoundsException - 当 index 超出范围时，抛出异常。

operator func [](Range<Int64>)

public operator func [](range: Range<Int64>): ArrayList<T>

功能：运算符重载 - 切片。

注意：

如果参数 range 是使用 Range 构造函数构造的 Range 实例，有如下行为：

start 的值就是构造函数传入的值本身，不受构造时传入的 hasStart 的值的影响。

hasEnd 为 false 时，end 值不生效，且不受构造时传入的 isClosed 的值的影响，数组切片取到原数组最后一个元素。

切片操作返回的 ArrayList 为全新的对象，与原 ArrayList 无引用关系。

参数：

range: Range<Int64> - 传递切片的范围。

返回值：

ArrayList<T> - 切片所得的数组。

异常：

IllegalArgumentException - 当 range.step 不等于 1 时，抛出异常。
IndexOutOfBoundsException - 当 range 无效时，抛出异常。

extend<T> ArrayList<T> <: Equatable<ArrayList<T>> where T <: Equatable<T>

extend<T> ArrayList<T> <: Equatable<ArrayList<T>> where T <: Equatable<T>

功能：为 ArrayList<T> 类型扩展 Equatable<ArrayList<T>> 接口，支持判等操作。

父类型：

Equatable<ArrayList<T>>

operator func ==(ArrayList<T>)

public operator func ==(that: ArrayList<T>): Bool

功能：判断当前实例与参数指向的 ArrayList 实例是否相等。

两个数组相等指的是两者对应位置的元素分别相等。

参数：

that: ArrayList<T> - 被比较的对象。

返回值：

Bool - 如果相等，则返回 true，否则返回 false。

operator func !=(ArrayList<T>)

public operator func !=(that: ArrayList<T>): Bool

功能：判断当前实例与参数指向的 ArrayList 实例是否不等。

参数：

that: ArrayList<T> - 被比较的对象。

返回值：

Bool - 如果不等，则返回 true，否则返回 false。

func contains(T)

public func contains(element: T): Bool

功能：判断当前数组中是否含有指定元素 element。

参数：

element: T - 待寻找的元素。

返回值：

Bool - 如果数组中包含指定元素，返回 true，否则返回 false。

extend<T> ArrayList<T> <: SortExtension where T <: Comparable<T>

extend<T> ArrayList<T> <: SortExtension where T <: Comparable<T>

功能：为 ArrayList<T> 扩展 SortExtension 接口，支持数组排序。

父类型：

SortExtension

func sort(Bool)

public func sort(stable!: Bool = false): Unit

功能：将当前数组内元素以升序的方式排序。

参数：

stable!: Bool - 是否使用稳定排序。

func sortDescending(Bool)

public func sortDescending(stable!: Bool = false): Unit

功能：将当前数组内元素以降序的方式排序。

参数：

stable!: Bool - 是否使用稳定排序。

extend<T> ArrayList<T> <: ToString where T <: ToString

extend<T> ArrayList<T> <: ToString where T <: ToString

功能：为 ArrayList<T> 扩展 ToString 接口，支持转字符串操作。

父类型：

ToString

func toString()

public func toString(): String

功能：将当前数组转换为字符串。

该字符串包含数组内每个元素的字符串表示，形如："[elem1, elem2, elem3]"。

返回值：

String - 转换得到的字符串。

class ArrayListIterator<T>

public class ArrayListIterator<T> <: Iterator<T> {
    public init(data: ArrayList<T>)
}

功能：此类主要实现 ArrayList 的迭代器功能。

父类型：

Iterator<T>

init(ArrayList<T>)

public init(data: ArrayList<T>)

功能：创建 ArrayListIterator<T> 实例。

参数：

date：传入 ArrayList<T>。

func next()

public func next(): Option<T>

功能：返回迭代中的下一个元素。

返回值：

?T - 迭代器中的下一个元素，用 Option 封装。

异常：

ConcurrentModificationException - 当函数检测到不同步的并发修改，抛出异常。

func iterator()

public func iterator(): Iterator<T>

功能：返回迭代器自身。

返回值：

Iterator<T> - 迭代器自身。

class HashMapIterator<K, V> where K <: Hashable & Equatable<K>

public class HashMapIterator<K, V> <: Iterator<(K, V)> where K <: Hashable & Equatable<K> {
    public init(map: HashMap<K, V>)
}

功能：此类主要实现 HashMap 的迭代器功能。

父类型：

Iterator<(K, V)>

init(HashMap<K, V>)

public init(map: HashMap<K, V>)

功能：创建 HashMapIterator<K, V> 实例。

参数：

map: HashMap<K, V> - 传入 HashMap<K, V>。

func iterator()

public func iterator(): Iterator<(K, V)>

功能：返回迭代器实例本身。

返回值：

Iterator <(K, V) > - 迭代器实例本身。

func next()

public func next(): ?(K, V)

功能：返回迭代器中的下一个元素。

返回值：

?(K, V) - 迭代器中的下一个元素，用 Option 封装。

异常：

ConcurrentModificationException - 当函数检测到不同步的并发修改，抛出异常。

func remove()

public func remove(): Option<(K, V)>

功能：删除此 HashMap 迭代器的 next 函数返回的元素，此函数只能在 next 函数调用时调用一次。

返回值：

Option <(K, V) > - 返回被删除的元素。

异常：

ConcurrentModificationException - 当函数检测到不同步的并发修改，抛出异常。

class HashMap<K, V> where K <: Hashable & Equatable<K>

public class HashMap<K, V> <: Map<K, V> where K <: Hashable & Equatable<K> {
    public init()
    public init(elements: Collection<(K, V)>)
    public init(elements: Array<(K, V)>)
    public init(capacity: Int64)
    public init(size: Int64, initElement: (Int64) -> (K, V))
}

功能： Map 接口的哈希表实现。

哈希表是一种常用的数据结构，它可以用来快速地查找、插入和删除数据。哈希表的基本原理是将数据映射到一个数组中，这个数组称为哈希表。每个数据元素都有一个对应的哈希值，这个哈希值可以用来确定该元素在哈希表中的位置。

哈希表的特点是快速的查找、插入和删除操作，时间复杂度通常是O(1)。由于哈希表底层的数组大小是动态的，所以哈希表不能保证元素的顺序不可变。

父类型：

Map<K, V>

prop size

public prop size: Int64

功能：返回键值对的个数。

类型：Int64

init()

public init()

功能：构造一个具有默认初始容量为16和默认负载因子为空的 HashMap。

init(Array<(K, V)>)

public init(elements: Array<(K, V)>)

功能：通过传入的键值对数组构造一个 HashMap。

该构造函数根据传入数组的 size 设置 HashMap 的容量。由于HashMap 内部不允许键重复，当 Array 中存在重复的键时，按照迭代器顺序，出现在后面的键值对将会覆盖前面的键值对。

参数：

elements: Array<(K, V)> - 初始化该 HashMap 的键值对数组。

init(Collection<(K, V)>)

public init(elements: Collection<(K, V)>)

功能：通过传入的键值对集合构造一个 HashMap。

该构造函数根据传入集合 elements 的 size 设置 HashMap 的容量。由于HashMap 内部不允许键重复，当 Array 中存在重复的键时，按照迭代器顺序，出现在后面的键值对将会覆盖前面的键值对。

参数：

elements: Collection<(K, V)> - 初始化该 HashMap 的键值对集合。

init(Int64)

public init(capacity: Int64)

功能：构造一个带有传入容量大小的 HashMap。

参数：

capacity: Int64 - 初始化容量大小。

异常：

IllegalArgumentException - 如果 capacity 小于 0 则抛出异常。

init(Int64, (Int64) -> (K, V))

public init(size: Int64, initElement: (Int64) -> (K, V))

功能：通过传入的元素个数 size 和函数规则来构造 HashMap。

构造出的 HashMap 的容量受 size 大小影响。由于HashMap 内部不允许键重复，当函数 initElement 生成相同的键时，后构造的键值对将会覆盖之前出现的键值对。

参数：

size: Int64 - 初始化该 HashMap 的函数规则。
initElement: (Int64) ->(K, V) - 初始化该 HashMap 的函数规则。

异常：

IllegalArgumentException - 如果 size 小于 0 则抛出异常。

func capacity()

public func capacity(): Int64

功能：返回 HashMap 的容量。

返回值：

Int64 - HashMap 的容量。

func clear()

public func clear(): Unit

功能：清除所有键值对。

示例：

使用示例见 HashMap 的 putAll/remove/clear 函数。

func clone()

public func clone(): HashMap<K, V>

功能：克隆 HashMap。

返回值：

HashMap < K, V > - 返回一个 HashMap。

func contains(K)

public func contains(key: K): Bool

功能：判断是否包含指定键的映射。

参数：

key: K - 传递要判断的 key。

返回值：

Bool - 如果存在，则返回 true；否则，返回 false。

示例：

使用示例见 Hashmap 的 get/put/contains 函数。

func containsAll(Collection<K>)

public func containsAll(keys: Collection<K>): Bool

功能：判断是否包含指定集合中所有键的映射。

参数：

keys: Collection<K> - 键传递待判断的 keys。

返回值：

Bool - 如果都包含，则返回 true；否则，返回 false。

func entryView(K)

public func entryView(key: K): EntryView<K, V>

功能：如果不包含特定键，返回一个空的引用视图。如果包含特定键，则返回该键对应的元素的引用视图。

EntryView 的使用方式见 EntryView。

参数：

key: K - 要添加的键值对的键。

返回值：

EntryView < K, V > - 一个引用视图。

func get(K)

public func get(key: K): Option<V>

功能：返回指定键映射到的值，如果 HashMap 不包含指定键的映射，则返回 Option<V>.None。

参数：

key: K - 传入的键。

返回值：

Option<V> - 键对应的值。用 Option 封装。

示例：

使用示例见 Hashmap 的 get/put/contains 函数。

func isEmpty()

public func isEmpty(): Bool

功能：判断 HashMap 是否为空，如果是，则返回 true；否则，返回 false。

返回值：

Bool - HashMap 是否为空。

func iterator()

public func iterator(): HashMapIterator<K, V>

功能：返回 Hashmap 的迭代器。

返回值：

HashMapIterator < K, V > - 返回 HashMap 的迭代器。

func keys()

public func keys(): EquatableCollection<K>

功能：返回 HashMap 中所有的 key，并将所有 key 存储在一个 Keys 容器中。

返回值：

EquatableCollection<K> - 保存所有返回的 key。

func put(K, V)

public func put(key: K, value: V): Option<V>

功能：将键值对放入 HashMap 中。

对于 HashMap 中已有的键，该键的值将被新值替换，并且返回旧的值。

参数：

key: K - 要放置的键。
value: V - 要分配的值。

返回值：

Option<V> - 如果赋值之前 key 存在，旧的 value 用 Option 封装；否则，返回 Option<V>.None。

示例：

使用示例见 Hashmap 的 get/put/contains 函数。

func putAll(Collection<(K, V)>)

public func putAll(elements: Collection<(K, V)>): Unit

功能：按照 elements 的迭代器顺序将新的键值对集合放入 HashMap 中。

对于 HashMap 中已有的键，该键的值将被新值替换。

参数：

elements: Collection<(K, V)> - 需要添加进 HashMap 的键值对集合。

示例：

使用示例见 HashMap 的 putAll/remove/clear 函数。

func putIfAbsent(K, V)

public func putIfAbsent(key: K, value: V): Bool

功能：当此 HashMap 中不存在键 key 时，向 HashMap 中插入键值对(key, value)。

参数：

key: K - 要放置的键。
value: V - 要分配的值。

返回值：

Bool - 如果赋值之前 key 存在，则返回 false ，否则返回 true 。

func remove(K)

public func remove(key: K): Option<V>

功能：从此 HashMap 中删除指定键的映射（如果存在）。

参数：

key: K - 传入要删除的 key。

返回值：

Option<V> - 被从 HashMap 中移除的键对应的值，用 Option 封装，如果 HashMap中不存该键，返回 None 。

示例：

使用示例见 HashMap 的 putAll/remove/clear 函数。

func removeAll(Collection<K>)

public func removeAll(keys: Collection<K>): Unit

功能：从此 HashMap 中删除指定集合中键的映射（如果存在）。

参数：

keys: Collection<K> - 传入要删除的键的集合。

func removeIf((K, V) -> Bool)

public func removeIf(predicate: (K, V) -> Bool): Unit

功能：传入 lambda 表达式，如果满足条件，则删除对应的键值对。

该函数会遍历整个HashMap，所以满足 predicate(K, V) == true 的键值对都会被删除。

参数：

predicate: (K, V) ->Bool - 传递一个 lambda 表达式进行判断。

异常：

ConcurrentModificationException - 当 predicate 中增删或者修改 HashMap 内键值对时，抛出异常。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：扩容当前的HashMap。

将 HashMap 扩容 additional 大小当 additional 小于等于零时，不发生扩容；当 HashMap 剩余容量大于等于 additional 时，不发生扩容；当 HashMap 剩余容量小于 additional 时，取（原始容量的1.5倍向下取整）与（additional + 已使用容量）中的最大值进行扩容。

参数：

additional: Int64 - 将要扩容的大小。

异常：

OverflowException - 当additional + 已使用容量超过Int64.Max时，抛出异常。

func toArray()

public func toArray(): Array<(K, V)>

功能：构造一个包含 HashMap 内键值对的数组，并返回。

返回值：

Array <(K, V) > - 包含容器内所有键值对的数组。

func values()

public func values(): Collection<V>

功能：返回 HashMap 中包含的值，并将所有的 value 存储在一个 Values 容器中。

返回值：

Collection<V> - 保存所有返回的 value。

operator func [](K, V)

public operator func [](key: K, value!: V): Unit

功能：运算符重载 put 方法，如果键存在，新 value 覆盖旧 value，如果键不存在，添加此键值对。

参数：

key: K - 传递值进行判断。
value!: V - 传递要设置的值。

operator func [](K)

public operator func [](key: K): V

功能：运算符重载 get 方法，如果键存在，返回键对应的值。

参数：

key: K - 传递值进行判断。

返回值：

V - 与键对应的值。

异常：

NoneValueException - 如果该 HashMap 不存在该键，抛此异常。

extend<K, V> HashMap<K, V> <: Equatable<HashMap<K, V>> where V <: Equatable<V>

extend<K, V> HashMap<K, V> <: Equatable<HashMap<K, V>> where V <: Equatable<V>

功能：为 HashMap<K, V> 类型扩展 Equatable<HashMap<K, V>> 接口，支持判等操作。

父类型：

Equatable<HashMap<K, V>>

operator func ==(HashMap<K, V>)

public operator func ==(right: HashMap<K, V>): Bool

功能：判断当前实例与参数指向的 HashMap<K, V> 实例是否相等。

两个 HashMap<K, V> 相等指的是其中包含的键值对完全相等。

参数：

right: HashMap<K, V> - 被比较的对象。

返回值：

Bool - 如果相等，则返回 true，否则返回 false。

operator func !=(HashMap<K, V>)

public operator func !=(right: HashMap<K, V>): Bool

功能：判断当前实例与参数指向的 HashMap<K, V> 实例是否不等。

参数：

right: HashMap<K, V> - 被比较的对象。

返回值：

Bool - 如果不等，则返回 true，否则返回 false。

extend<K, V> HashMap<K, V> <: ToString where V <: ToString, K <: ToString

extend<K, V> HashMap<K, V> <: ToString where V <: ToString, K <: ToString

功能：为 HashMap<K, V> 扩展 ToString 接口，支持转字符串操作。

父类型：

ToString

func toString()

public func toString(): String

功能：将当前 HashMap<K, V> 实例转换为字符串。

该字符串包含 HashMap<K, V> 内每个键值对的字符串表示，形如："[(k1, v1), (k2, v2), (k3, v3)]"。

返回值：

String - 转换得到的字符串。

class HashSet<T> where T <: Hashable & Equatable<T>

public class HashSet<T> <: Set<T> where T <: Hashable & Equatable<T> {
    public init()
    public init(elements: Collection<T>)
    public init(elements: Array<T>)
    public init(capacity: Int64)
    public init(size: Int64, initElement: (Int64) -> T)
}

功能：基于 HashMap 实现的 Set 接口的实例。

HashSet中的元素是无序的，不允许有重复元素。当我们向HashSet中添加元素时，HashSet会根据元素的哈希值来确定该元素在哈希表中的位置。

提示：

HashSet 是基于 HashMap 实现的，因此 HashSet 的容量、内存布局、时间性能等都和 HashMap 相同。

父类型：

Set<T>

prop size

public prop size: Int64

功能：返回此 HashSet 的元素个数。

类型：Int64

init(Int64, Int64 -> T)

public init(size: Int64, initElement: (Int64) -> T)

功能：通过传入的函数元素个数 size 和函数规则来构造 HashSet。构造出的 HashSet 的容量受 size 大小影响。

参数：

size: Int64 - 初始化函数中元素的个数。
initElement: (Int64) ->T - 初始化函数规则。

异常：

IllegalArgumentException - 如果 size 小于 0，抛出异常。

init()

public init()

功能：构造一个空的 HashSet ，初始容量为 16 。

init(Array<T>)

public init(elements: Array<T>)

功能：使用传入的数组构造 HashSet。该构造函数根据传入数组 elements 的 size 设置 HashSet 的容量。

参数：

elements: Array<T> - 初始化 HashSet 的数组。

init(Collection<T>)

public init(elements: Collection<T>)

功能：使用传入的集合构造 HashSet。该构造函数根据传入集合 elements 的 size 设置 HashSet 的容量。

参数：

elements: Collection<T> - 初始化 HashSet 的集合。

init(Int64)

public init(capacity: Int64)

功能：使用传入的容量构造一个 HashSet。

参数：

capacity: Int64 - 初始化容量大小。

异常：

IllegalArgumentException - 如果 capacity 小于 0，抛出异常。

func capacity()

public func capacity(): Int64

功能：返回此 HashSet 的内部数组容量大小。

注意:

容量大小不一定等于 HashSet 的 size。

返回值：

Int64 - 返回此 HashSet 的内部数组容量大小。

func clear()

public func clear(): Unit

功能：从此 HashSet 中移除所有元素。

func clone()

public func clone(): HashSet<T>

功能：克隆 HashSet。

返回值：

HashSet<T> - 返回克隆到的 HashSet。

func contains(T)

public func contains(element: T): Bool

功能：判断 HashSet 是否包含指定元素。

参数：

element: T - 指定的元素。

返回值：

Bool - 如果包含指定元素，则返回 true；否则，返回 false。

func containsAll(Collection<T>)

public func containsAll(elements: Collection<T>): Bool

功能：判断 HashSet 是否包含指定 Collection 中的所有元素。

参数：

elements: Collection<T> - 指定的元素集合。

返回值：

Bool - 如果此 HashSet 包含 Collection 中的所有元素，则返回 true；否则，返回 false。

func isEmpty()

public func isEmpty(): Bool

功能：判断 HashSet 是否为空。

返回值：

Bool - 如果为空，则返回 true；否则，返回 false。

func iterator()

public func iterator(): Iterator<T>

功能：返回此 HashSet 的迭代器。

返回值：

Iterator<T> - 返回此 HashSet 的迭代器。

示例：

使用示例见 HashSet 的 put/iterator/remove 函数。

func put(T)

public func put(element: T): Bool

功能：将指定的元素添加到 HashSet 中, 若添加的元素在 HashSet 中存在, 则添加失败。

参数：

element: T - 指定的元素。

返回值：

Bool - 如果添加成功，则返回 true；否则，返回 false。

示例：

使用示例见 HashSet 的 put/iterator/remove 函数。

func putAll(Collection<T>)

public func putAll(elements: Collection<T>): Unit

功能：添加 Collection 中的所有元素至此 HashSet 中，如果元素存在，则不添加。

参数：

elements: Collection<T> - 需要被添加的元素的集合。

func remove(T)

public func remove(element: T): Bool

功能：如果指定元素存在于此 HashSet 中，则将其移除。

参数：

element: T - 需要被移除的元素。

返回值：

Bool - true，表示移除成功；false，表示移除失败。

示例：

使用示例见 HashSet 的 put/iterator/remove 函数。

func removeAll(Collection<T>)

public func removeAll(elements: Collection<T>): Unit

功能：移除此 HashSet 中那些也包含在指定 Collection 中的所有元素。

参数：

elements: Collection<T> - 需要从此 HashSet 中移除的元素的集合。

func removeIf((T) -> Bool)

public func removeIf(predicate: (T) -> Bool): Unit

功能：传入 lambda 表达式，如果满足 true 条件，则删除对应的元素。

参数：

predicate: (T) ->Bool - 是否删除元素的判断条件。

异常：

ConcurrentModificationException - 当 predicate 中增删或者修改 HashSet 内键值对时，抛出异常。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：将 HashSet 扩容 additional 大小，当 additional 小于等于零时，不发生扩容；当 HashSet 剩余容量大于等于 additional 时，不发生扩容；当 HashSet 剩余容量小于 additional 时，取（原始容量的1.5倍向下取整）与（additional + 已使用容量）中的最大值进行扩容。

参数：

additional: Int64 - 将要扩容的大小。

异常：

OverflowException - 当additional + 已使用容量超过Int64.Max时，抛出异常。

func retainAll(Set<T>)

public func retainAll(elements: Set<T>): Unit

功能：从此 HashSet 中保留 Set 中的元素。

参数：

elements: Set<T> - 需要保留的 Set。

func subsetOf(Set<T>)

public func subsetOf(other: Set<T>): Bool

功能：检查该集合是否为其他 Set 的子集。

参数：

other: Set<T> - 传入集合，此函数将判断当前集合是否为 other 的子集。

返回值：

Bool - 如果该 Set 是指定 Set 的子集，则返回 true；否则返回 false。

func toArray()

public func toArray(): Array<T>

功能：返回一个包含容器内所有元素的数组。

返回值：

Array<T> - T 类型数组。

extend<T> HashSet<T> <: Equatable<HashSet<T>>

extend<T> HashSet<T> <: Equatable<HashSet<T>>

功能：为 HashSet<T> 类型扩展 Equatable<HashSet<T>> 接口，支持判等操作。

父类型：

Equatable<HashSet<T>>

operator func ==(HashSet<T>)

public operator func ==(that: HashSet<T>): Bool

功能：判断当前实例与参数指向的 HashSet<T> 实例是否相等。

两个 HashSet<T> 相等指的是其中包含的元素完全相等。

参数：

that: HashSet<T> - 被比较的对象。

返回值：

Bool - 如果相等，则返回 true，否则返回 false。

operator func !=(HashSet<T>)

public operator func !=(that: HashSet<T>): Bool

功能：判断当前实例与参数指向的 HashSet<T> 实例是否不等。

参数：

that: HashSet<T> - 被比较的对象。

返回值：

Bool - 如果不等，则返回 true，否则返回 false。

extend<T> HashSet<T> <: ToString where T <: ToString

extend<T> HashSet<T> <: ToString where T <: ToString

功能：为 HashSet<T> 扩展 ToString 接口，支持转字符串操作。

父类型：

ToString

func toString()

public func toString(): String

功能：将当前 HashSet<T> 实例转换为字符串。

该字符串包含 HashSet<T> 内每个元素的字符串表示，形如："[elem1, elem2, elem3]"。

返回值：

String - 转换得到的字符串。

class LinkedListNode<T>

public class LinkedListNode<T>

功能：LinkedListNode 是 LinkedList 上的节点。

可以通过 LinkedListNode 对 LinkedList 进行前向后向遍历操作，也可以访问和修改元素的值。

LinkedListNode 只能通过对应 LinkedList 的 'nodeAt'、'firstNode'、'lastNode' 获得，当 LinkedList 删除掉对应的节点时，会造成一个悬空的节点，对悬空的节点进行任何操作都会抛 'IllegalStateException' 异常。

prop next

public prop next: Option<LinkedListNode<T>>

功能：获取当前节点的下一个节点，如果没有则返回 None。

类型：Option<LinkedListNode<T>>

异常：

IllegalStateException - 如果该节点不属于任何链表实例，抛此异常。

prop prev

public prop prev: Option<LinkedListNode<T>>

功能：获取当前节点的前一个节点，如果没有则返回 None。

类型：Option<LinkedListNode<T>>

异常：

IllegalStateException - 如果该节点不属于任何链表实例，抛此异常。

prop value

public mut prop value: T

功能：获取或者修改元素的值。

类型：T

异常：

IllegalStateException - 如果该节点不属于任何链表实例，抛此异常。

func backward()

public func backward(): Iterator<T>

功能：获取一个从当前节点开始，到所对应链表的尾部节点的所有元素的迭代器。

返回值：

Iterator<T> - 对应元素的迭代器。

异常：

IllegalStateException - 如果该节点不属于任何链表实例，抛此异常。

func forward()

public func forward(): Iterator<T>

功能：获取一个从当前节点开始，到所对应链表的头部节点的所有元素的迭代器。

返回值：

Iterator<T> - 对应元素的迭代器。

异常：

IllegalStateException - 如果该节点不属于任何链表实例，抛此异常。

class LinkedList<T>

public class LinkedList<T> <: Collection<T> {
    public init()
    public init(elements: Collection<T>)
    public init(elements: Array<T>)
    public init(size: Int64, initElement: (Int64)-> T)
}

功能：实现双向链表的数据结构。

双向链表是一种常见的数据结构，它由一系列节点组成，每个节点都包含两个指针，一个指向前一个节点，另一个指向后一个节点。这种结构允许在任何一个节点上进行双向遍历，即可以从头节点开始向后遍历，也可以从尾节点开始向前遍历。

LinkedList 不支持并发操作，并且对集合中元素的修改不会使迭代器失效，只有在添加和删除元素的时候会使迭代器失效。

父类型：

Collection<T>

prop first

public prop first: ?T

功能：链表中第一个元素的值，如果是空链表则返回 None。

类型：?T

prop last

public prop last: ?T

功能：链表中最后一个元素的值，如果是空链表则返回 None。

类型：?T

prop size

public prop size: Int64

功能：链表中的元素数量。

类型：Int64

init

public init()

功能：构造一个空的链表。

init(Array<T>)

public init(elements: Array<T>)

功能：按照数组的遍历顺序构造一个包含指定集合元素的 LinkedList 实例。

参数：

elements: Array<T> - 将要放入此链表中的元素数组。

init(Collection<T>)

public init(elements: Collection<T>)

功能：按照集合迭代器返回元素的顺序构造一个包含指定集合元素的链表。

参数：

elements: Collection<T> - 将要放入此链表中的元素集合。

init(Int64, (Int64)-> T)

public init(size: Int64, initElement: (Int64)-> T)

功能：创建一个包含 size 个元素，且第 n 个元素满足 (Int64)-> T 条件的链表。

参数：

size: Int64 - 要创建的链表元素数量。
initElement: (Int64) ->T - 元素的初始化参数。

func append(T)

public func append(element: T): LinkedListNode<T>

功能：在链表的尾部位置添加一个元素，并且返回该元素的节点。

参数：

element: T - 要添加到链表中的元素。

返回值：

LinkedListNode<T> - 指向该元素的节点。

func clear()

public func clear(): Unit

功能：删除链表中的所有元素。

func firstNode()

public func firstNode(): Option<LinkedListNode<T>>

功能：获取链表中的第一个元素的节点。

返回值：

Option < LinkedListNode<T>> - 第一个元素的节点，如果链表为空链表则返回 None。

func insertAfter(LinkedListNode<T>,T)

public func insertAfter(node: LinkedListNode<T>, element: T): LinkedListNode<T>

功能：在链表中指定节点的后面插入一个元素，并且返回该元素的节点。

参数：

node: LinkedListNode<T> - 指定的节点。
element: T - 要添加到链表中的元素。

返回值：

LinkedListNode<T> - 指向被插入元素的节点。

异常：

IllegalArgumentException - 如果指定的节点不属于该链表，则抛此异常。

func insertBefore(LinkedListNode<T>,T)

public func insertBefore(node: LinkedListNode<T>, element: T): LinkedListNode<T>

功能：在链表中指定节点的前面插入一个元素，并且返回该元素的节点。

参数：

node: LinkedListNode<T> - 指定的节点。
element: T - 要添加到链表中的元素。

返回值：

LinkedListNode<T> - 指向被插入元素的节点。

异常：

IllegalArgumentException - 如果指定的节点不属于该链表，则抛此异常。

func isEmpty()

public func isEmpty(): Bool

功能：返回此链表是否为空链表的判断。

返回值：

Bool - 如果此链表中不包含任何元素，返回 true。

func iterator()

public func iterator(): Iterator<T>

功能：返回当前集合中元素的迭代器，其顺序是从链表的第一个节点到链表的最后一个节点。

返回值：

Iterator<T> - 当前集合中元素的迭代器。

func lastNode()

public func lastNode(): Option<LinkedListNode<T>>

功能：获取链表中的最后一个元素的节点。

返回值：

Option < LinkedListNode<T>> - 最后一个元素的节点，如果链表为空链表则返回 None。

func nodeAt(Int64)

public func nodeAt(index: Int64): Option<LinkedListNode<T>>

功能：获取链表中的第 index 个元素的节点，编号从 0 开始。

该函数的时间复杂度为 O(n)。

参数：

index: Int64 - 指定获取第 index 个元素的节点。

返回值：

Option < LinkedListNode<T>> - 编号为 index 的节点，如果没有则返回 None。

func popFirst()

public func popFirst() : ?T

功能：移除链表的第一个元素，并返回该元素的值。

返回值：

?T - 被删除的元素的值，若链表为空则返回 None。

func popLast()

public func popLast() : ?T

功能：移除链表的最后一个元素，并返回该元素的值。

返回值：

?T - 被删除的元素的值，若链表为空则返回 None。

func prepend(T)

public func prepend(element: T): LinkedListNode<T>

功能：在链表的头部位置插入一个元素，并且返回该元素的节点。

参数：

element: T - 要添加到链表中的元素。

返回值：

LinkedListNode<T> - 指向该元素的节点。

func remove(LinkedListNode<T>)

public func remove(node: LinkedListNode<T>): T

功能：删除链表中指定节点。

参数：

node: LinkedListNode<T> - 要被删除的节点。

返回值：

T - 被删除的节点的值。

异常：

IllegalArgumentException - 如果指定的节点不属于该链表，则抛此异常。

func removeIf((T)-> Bool)

public func removeIf(predicate: (T)-> Bool): Unit

功能：删除此链表中满足给定 lambda 表达式或函数的所有元素。

参数：

predicate: (T) ->Bool - 对于要删除的元素，返回值为 true。

func reverse()

public func reverse(): Unit

功能：反转此链表中的元素顺序。

func splitOff(LinkedListNode<T>)

public func splitOff(node: LinkedListNode<T>): LinkedList<T>

功能：从指定的节点 node 开始，将链表分割为两个链表，如果分割成功，node 不在当前的链表内，而是作为首个节点存在于新的链表内部。

参数：

node: LinkedListNode<T> - 要分割的位置。

返回值：

LinkedList<T> - 原链表分割后新产生的链表。

异常：

IllegalArgumentException - 如果指定的节点不属于该链表，则抛此异常。

func toArray()

public func toArray(): Array<T>

功能：返回一个数组，数组包含该链表中的所有元素，并且顺序与链表的顺序相同。

返回值：

Array<T> - T 类型数组。

extend<T> LinkedList<T> <: Equatable<LinkedList<T>> where T <: Equatable<T>

extend<T> LinkedList<T> <: Equatable<LinkedList<T>> where T <: Equatable<T>

功能：为 LinkedList<T> 类型扩展 Equatable<LinkedList<T>> 接口，支持判等操作。

父类型：

Equatable<LinkedList<T>>

operator func ==(LinkedList<T>)

public operator func ==(right: LinkedList<T>): Bool

功能：判断当前实例与参数指向的 LinkedList<T> 实例是否相等。

两个 LinkedList<T> 相等指的是其中包含的元素完全相等。

参数：

right: HashSet<T> - 被比较的对象。

返回值：

Bool - 如果相等，则返回 true，否则返回 false。

operator func !=(LinkedList<T>)

public operator func !=(right: LinkedList<T>): Bool

功能：判断当前实例与参数指向的 LinkedList<T> 实例是否不等。

参数：

right: LinkedList<T> - 被比较的对象。

返回值：

Bool - 如果不等，则返回 true，否则返回 false。

extend<T> LinkedList<T> <: ToString where T <: ToString

extend<T> LinkedList<T> <: ToString where T <: ToString

功能：为 LinkedList<T> 扩展 ToString 接口，支持转字符串操作。

父类型：

ToString

func toString()

public func toString(): String

功能：将当前 LinkedList<T> 实例转换为字符串。

该字符串包含 LinkedList<T> 内每个元素的字符串表示，形如："[elem1, elem2, elem3]"。

返回值：

String - 转换得到的字符串。

class TreeMap<K, V> where K <: Comparable<K>

public class TreeMap<K, V> <: Map<K, V> where K <: Comparable<K> {
    public init()
    public init(elements: Collection<(K, V)>)
    public init(elements: Array<(K,V)>)
    public init(size: Int64, initElement: (Int64) -> (K, V))
}

功能：基于平衡二叉搜索树实现的 Map 接口实例。

这个类的主要目的是提供一个有序的 key-value 存储结构，它可以快速地插入、删除、查找元素。

TreeMap 可以用于任何需要有序键值对存储的场景，例如数据库、缓存、查找表等。

父类型：

Map<K, V>

prop size

public prop size: Int64

功能：返回键值的个数。

类型：Int64

init()

public init()

功能：构造一个空的 TreeMap。

init(Array<(K,V)>)

public init(elements: Array<(K,V)>)

功能：通过传入的键值对数组构造一个 TreeMap。

按照 elements 的先后顺序将元素插入到 TreeMap 内，由于 TreeMap 中不允许出现相同的键，如果 elements 中有相同的键时，后出现的键值对将会覆盖先出现的键值对。

参数：

elements: Array<(K, V)> - 初始化该 TreeMap 的键值对数组。

init(Collection<(K, V)>)

public init(elements: Collection<(K, V)>)

功能：通过传入的键值对集合构造一个 TreeMap。

按照 elements 的迭代器顺序将元素插入到 TreeMap 内，由于 TreeMap 中不允许出现相同的键，如果 elements 中有相同的键时，后出现(迭代器顺序)的键值对将会覆盖先出现的键值对。

参数：

elements: Collection<(K, V)> - 初始化该 TreeMap 的键值对集合。

init(Int64, (Int64) -> (K, V))

public init(size: Int64, initElement: (Int64) -> (K, V))

功能：通过传入的元素个数 size 和函数规则来构造 TreeMap。

参数：

size: Int64 - 传入的元素个数。
initElement: (Int64) ->(K, V) - 初始化该 TreeMap 的函数规则。

异常：

IllegalArgumentException - 如果 size 小于 0 则抛出异常。

func clear()

public func clear(): Unit

功能：清除所有键值对。

func clone()

public func clone(): TreeMap<K, V>

功能：克隆 TreeMap。

返回值：

TreeMap < K, V > - 返回一个 TreeMap 实例。

func contains(K)

public func contains(key: K): Bool

功能：判断是否包含指定键的映射。

参数：

key: K - 传递要判断的 key。

返回值：

Bool - 如果存在，则返回 true；否则，返回 false。

func containsAll(Collection<K>)

public func containsAll(keys: Collection<K>): Bool

功能：判断是否包含指定集合键的映射。

参数：

keys: Collection<K> - 键的集合 keys。

返回值：

Bool - 如果存在，则返回 true；否则，返回 false。

func findLower(K, Bool)

public func findLower(bound: K, inclusive!: Bool = false): Option<TreeMapNode<K, V>>

功能：返回比传入的键小的最大元素。

参数：

bound: K - 传入的键。
inclusive!: Bool - 是否包含传入的键本身，默认为 false ，即不包含。

返回值：

Option < TreeMapNode < K, V >> - 如果存在这样一个元素，用 Option<TreeMapNode<K, V>> 封装该元素并返回；否则，返回 Option<TreeMapNode<K, V>>.None。

func findUpper(K, Bool)

public func findUpper(bound: K, inclusive!: Bool = false): Option<TreeMapNode<K, V>>

功能：返回比传入的键大的最小元素。

参数：

bound: K - 传入的键。
inclusive!: Bool - 是否包含传入的键本身，默认为 false ，即不包含。

返回值：

Option < TreeMapNode < K, V >> - 如果存在这样一个元素，用 Option<TreeMapNode<K, V>> 封装该元素并返回；否则，返回 Option<TreeMapNode<K, V>>.None。

func firstEntry()

public func firstEntry(): Option<(K, V)>

功能：获取 TreeMap 的第一个元素。

返回值：

Option <(K, V) > - 如果存在第一个元素，用 Option 封装该元素并返回；否则返回 Option<(K, V)>.None。

func get(K)

public func get(key: K): Option<V>

功能：返回指定键映射的值。

参数：

key: K - 指定的键。

返回值：

Option<V> - 如果存在这样一个值，用 Option 封装该值并返回；否则，返回 Option<V>.None。

func isEmpty()

public func isEmpty(): Bool

功能：判断 TreeMap 是否为空。

返回值：

Bool - 如果为空，返回 true，否则返回 false。

func iterator()

public func iterator(): Iterator<(K, V)>

功能：返回 TreeMap 的迭代器，迭代器按 Key 值从小到大的顺序迭代。

返回值：

Iterator <(K, V) > - TreeMap 的迭代器。

func keys()

public func keys(): EquatableCollection<K>

功能：返回 TreeMap 中所有的 key，并将所有 key 存储在一个容器中。

返回值：

EquatableCollection<K> - 包含所有键的集合。

func lastEntry()

public func lastEntry(): Option<(K, V)>

功能：获取 TreeMap 的最后一个元素。

返回值：

Option <(K, V) > - 如果存在最后一个元素，用 Option 封装该元素并返回；否则返回 Option<(K, V)>.None。

func popFirstEntry()

public func popFirstEntry(): Option<(K, V)>

功能：删除 TreeMap 的第一个元素。

返回值：

Option <(K, V) > - 如果存在第一个元素，那么删除该元素，用 Option 封装该元素并返回；否则返回 Option<(K, V)>.None。

func popLastEntry()

public func popLastEntry(): Option<(K, V)>

功能：删除 TreeMap 的最后一个元素。

返回值：

Option <(K, V) > - 如果存在最后一个元素，那么删除该元素，用 Option 封装该元素并返回；否则返回 Option<(K, V)>.None。

func put(K, V)

public func put(key: K, value: V): Option<V>

功能：将新的键值对放入 TreeMap 中。对于 TreeMap 中已有的键，该键的值将被新值替换。

参数：

key: K - 要放置的键。
value: V - 要分配的值。

返回值：

Option<V> - 如果赋值之前 key 存在，旧的 value 用 Option 封装并返回；否则，返回 Option<V>.None。

func putAll(Collection<K, V>)

public func putAll(elements: Collection<(K, V)>): Unit

功能：将新的键值对集合放入 TreeMap 中。对于 TreeMap 中已有的键，该键的值将被新值替换。

参数：

elements: Collection<(K, V)> - 需要添加进 TreeMap 的键值对集合。

func remove(K)

public func remove(key: K): Option<V>

功能：从此映射中删除指定键的映射（如果存在）。

参数：

key: K - 传入要删除的 key。

返回值：

Option<V> - 被移除映射的值用 Option 封装，如果 TreeMap 中不存在指定的键，返回 None。

func removeAll(Collection<K>)

public func removeAll(keys: Collection<K>): Unit

功能：从此映射中删除指定集合的映射（如果存在）。

参数：

keys: Collection<K> - 传入要删除的键的集合。

func removeIf((K, V) -> Bool)

public func removeIf(predicate: (K, V) -> Bool): Unit

功能：传入 lambda 表达式，如果满足条件，则删除对应的键值。

参数：

predicate: (K, V) ->Bool - 传递一个 lambda 表达式进行判断。

func values()

public func values(): Collection<V>

功能：返回 TreeMap 中包含的值，并将所有的 value 存储在一个容器中。

返回值：

Collection<V> - 包含所有值的集合。

operator func [](K, V)

public operator func [](key: K, value!: V): Unit

功能：运算符重载集合，如果键存在，新 value 覆盖旧 value，如果键不存在，添加此键值对。

参数：

key: K - 传递值进行判断。
value!: V - 传递要设置的值。

operator func [](K)

public operator func [](key: K): V

功能：运算符重载集合，如果键存在，返回键对应的值。

参数：

key: K - 传递值进行判断。

返回值：

V - 与键对应的值。

异常：

NoneValueException - 如果该 HashMap 不存在该键，抛出异常。

extend<K, V> TreeMap<K, V> <: Equatable<TreeMap<K, V>> where V <: Equatable<V>

extend<K, V> TreeMap<K, V> <: Equatable<TreeMap<K, V>> where V <: Equatable<V>

功能：为 TreeMap<K, V> 类型扩展 Equatable<TreeMap<K, V>> 接口，支持判等操作。

父类型：

Equatable<TreeMap<K, V>>

operator func ==(TreeMap<K, V>)

public operator func ==(right: TreeMap<K, V>): Bool

功能：判断当前实例与参数指向的 TreeMap<K, V> 实例是否相等。

两个 TreeMap<K, V> 相等指的是其中包含的键值对完全相等。

参数：

right: TreeMap<K, V> - 被比较的对象。

返回值：

Bool - 如果相等，则返回 true，否则返回 false。

operator func !=(TreeMap<K, V>)

public operator func !=(right: TreeMap<K, V>): Bool

功能：判断当前实例与参数指向的 TreeMap<K, V> 实例是否不等。

参数：

right: TreeMap<K, V> - 被比较的对象。

返回值：

Bool - 如果不等，则返回 true，否则返回 false。

extend<K, V> TreeMap<K, V> <: ToString where V <: ToString, K <: ToString & Comparable<K>

extend<K, V> TreeMap<K, V> <: ToString where V <: ToString, K <: ToString & Comparable<K>

功能：为 TreeMap<K, V> 扩展 ToString 接口，支持转字符串操作。

父类型：

ToString

func toString()

public func toString(): String

功能：将当前 TreeMap<K, V> 实例转换为字符串。

该字符串包含 TreeMap<K, V> 内每个键值对的字符串表示，形如："[(k1, v1), (k2, v2), (k3, v3)]"。

返回值：

String - 转换得到的字符串。