类

class ArrayList<T>

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

功能：提供可变长度的数组的功能。

ArrayList 是一种线性的动态数组，与 Array 不同，它可以根据需要自动调整大小，并且在创建时不需要指定大小。

说明：

  • 当向动态数组中添加元素时，如果数组已满，则会重新分配更大的内存空间，并将原有的元素复制到新的内存空间中。

  • 动态数组的优点是可以节省内存空间，并且可以根据需要自动调整大小，因此非常适合需要频繁添加或删除元素的情况。但是，动态数组的缺点是在重新分配内存空间时可能会导致性能下降，因此在使用动态数组时需要考虑这一点。

prop size

public prop size: Int64

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

类型：Int64

init()

public init()

功能：构造一个初始容量大小为默认值16的ArrayList。

init(Array<T>)

public init(elements: Array<T>)

功能：构造一个包含指定数组中所有元素的 ArrayList。

注意：

当 T 的类型是 Int64 时，此构造函数的变长参数语法糖版本可能会和 public init(Int64) 产生歧义，比如 ArrayList<Int64>(8, 9) 是构造一个包含两个元素的 ArrayList， 而 ArrayList<Int64>(8) 是构造一个容量为 8 的 ArrayList。

参数：

  • elements: Array<T> - 传入数组。

init(Collection<T>)

public init(elements: Collection<T>)

功能：构造一个包含指定集合中所有元素的 ArrayList。这些元素按照集合的迭代器返回的顺序排列。

参数：

init(Int64)

public init(capacity: Int64)

功能：构造一个初始容量为指定大小的 ArrayList。

参数：

  • capacity: Int64 - 指定的初始容量大小。

异常：

init(Int64, (Int64) -> T)

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

功能：构造具有指定初始元素个数和指定规则函数的 ArrayList。该构造函数根据参数 size 设置 ArrayList 的容量。

参数：

  • size: Int64 - 初始化函数元素个数。
  • initElement: (Int64) ->T - 传入初始化函数。

异常：

func append(T)

public func append(element: T): Unit

功能：将指定的元素附加到此 ArrayList 的末尾。

参数：

  • element: T - 插入的元素，类型为 T。

示例：

使用示例见 ArrayList 的 append/insert 函数。

func appendAll(Collection<T>)

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

功能：将指定集合中的所有元素附加到此 ArrayList 的末尾。

函数会按照迭代器顺序遍历入参中的集合，并且将所有元素插入到此 ArrayList 的尾部。

参数：

  • elements: Collection<T> - 需要插入的元素的集合。

func capacity()

public func capacity(): Int64

功能：返回此 ArrayList 的容量大小。

返回值：

func clear()

public func clear(): Unit

功能：从此 ArrayList 中删除所有元素。

示例：

使用示例见 ArrayList 的 remove/clear/slice 函数。

func clone()

public func clone(): ArrayList<T>

功能：返回此ArrayList实例的拷贝(浅拷贝)。

返回值：

func get(Int64)

public func get(index: Int64): ?T

功能：返回此 ArrayList 中指定位置的元素。

参数：

  • index: Int64 - 要返回的元素的索引。

返回值：

  • ?T - 返回指定位置的元素，如果 index 大小小于 0 或者大于等于 ArrayList 中的元素数量，返回 None。

示例：

使用示例见 ArrayList 的 get/set 函数。

func getRawArray()

public unsafe func getRawArray(): Array<T>

功能：返回 ArrayList 的原始数据。

注意：

这是一个 unsafe 的接口，使用处需要在 unsafe 上下文中。

原始数据是指 ArrayList 底层实现的数组，其大小大于等于 ArrayList 中的元素数量，且索引大于等于 ArrayList 大小的位置中可能包含有未初始化的元素，对其进行访问可能会产生未定义的行为。

返回值：

func insert(Int64, T)

public func insert(index: Int64, element: T): Unit

功能：在此 ArrayList 中的指定位置插入指定元素。

参数：

  • index: Int64 - 插入元素的目标索引。
  • element: T - 要插入的 T 类型元素。

异常：

示例：

使用示例见 ArrayList 的 append/insert 函数。

func insertAll(Int64, Collection<T>)

public func insertAll(index: Int64, elements: Collection<T>): Unit

功能：从指定位置开始，将指定集合中的所有元素插入此 ArrayList。

函数会按照迭代器顺序遍历入参中的集合，并且将所有元素插入到指定位置。

参数：

  • index: Int64 - 插入集合的目标索引。
  • elements: Collection<T> - 要插入的 T 类型元素集合。

异常：

示例：

使用示例见 ArrayList 的 remove/clear/slice 函数。

func isEmpty()

public func isEmpty(): Bool

功能：判断 ArrayList 是否为空。

返回值：

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

func iterator()

public func iterator(): Iterator<T>

功能：返回此 ArrayList 中元素的迭代器。

返回值：

func prepend(T)

public func prepend(element: T): Unit

功能：在起始位置，将指定元素插入此 ArrayList。

参数：

  • element: T - 插入 T 类型元素。

func prependAll(Collection<T>)

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

功能：从起始位置开始，将指定集合中的所有元素插入此 ArrayList。

函数会按照迭代器顺序遍历入参中的集合，并且将所有元素插入到指定位置。

参数：

  • elements: Collection<T> - 要插入的 T 类型元素集合。

func remove(Int64)

public func remove(index: Int64): T

功能：删除此 ArrayList 中指定位置的元素。

参数：

  • index: Int64 - 被删除元素的索引。

返回值：

  • T - 被移除的元素。

异常：

示例：

使用示例见 ArrayList 的 remove/clear/slice 函数。

func remove(Range<Int64>)

public func remove(range: Range<Int64>): Unit

功能：删除此 ArrayList 中 Range 范围所包含的所有元素。

注意：

如果参数 range 是使用 Range 构造函数构造的 Range 实例，hasEnd 为 false 时，end 值不生效，且不受构造时传入的 isClosed 的值的影响，数组切片取到原数组最后一个元素。

参数：

  • range: Range<Int64> - 需要被删除的元素的范围。

异常：

func removeIf((T) -> Bool)

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

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

参数：

  • predicate: (T) ->Bool - 传递判断删除的条件。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：增加此 ArrayList 实例的容量。

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

参数：

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

func reverse()

public func reverse(): Unit

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

func set(Int64, T)

public func set(index: Int64, element: T): Unit

功能：将此 ArrayList 中指定位置的元素替换为指定的元素。

参数：

  • index: Int64 - 要设置的索引值。
  • element: T - T 类型元素。

异常：

示例：

使用示例见 ArrayList 的 get/set 函数。

func slice(Range<Int64>)

public func slice(range: Range<Int64>): ArrayList<T>

功能：以传入参数 range 作为索引，返回索引对应的 ArrayList<T>。

注意：

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

  1. start 的值就是构造函数传入的值本身，不受构造时传入的 hasStart 的值的影响。
  2. hasEnd 为 false 时，end 值不生效，且不受构造时传入的 isClosed 的值的影响，该数组切片取到原数组最后一个元素。

参数：

异常：

示例：

使用示例见 ArrayList 的 remove/clear/slice 函数。

func sortBy(Bool, (T, T) -> Ordering)

public func sortBy(stable!: Bool = false, comparator!: (T, T) -> Ordering): Unit

功能：对数组中的元素进行排序。

通过传入的比较函数，根据其返回值 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 - 索引位置的元素的值。

异常：

operator func [](Int64, T)

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

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

参数：

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

异常：

operator func [](Range<Int64>)

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

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

注意：

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

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

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

参数：

异常：

class ArrayListIterator<T>

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

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

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>

功能：返回迭代器自身。

返回值：迭代器自身。

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 的迭代器功能。

init(HashMap<K, V>)

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

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

参数：

func iterator()

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

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

返回值：

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

func next()

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

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

返回值：

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

异常：

func remove()

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

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

返回值：

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

异常：

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)。由于哈希表底层的数组大小是动态的，所以哈希表不能保证元素的顺序不可变。

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 中存在重复的键时，按照迭代器顺序，出现在后面的键值对将会覆盖前面的键值对。

参数：

init(Int64)

public init(capacity: Int64)

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

参数：

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

异常：

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 的函数规则。

异常：

func capacity()

public func capacity(): Int64

功能：返回 HashMap 的容量。

返回值：

func clear()

public func clear(): Unit

功能：清除所有键值对。

示例：

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

func clone()

public func clone(): 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 - 要添加的键值对的键。

返回值：

func get(K)

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

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

参数：

  • key: K - 传入的键。

返回值：

示例：

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

func isEmpty()

public func isEmpty(): Bool

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

返回值：

func iterator()

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

功能：返回 Hashmap 的迭代器。

返回值：

func keys()

public func keys(): EquatableCollection<K>

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

返回值：

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 中已有的键，该键的值将被新值替换。

参数：

示例：

使用示例见 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。

返回值：

示例：

使用示例见 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 表达式进行判断。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：扩容当前的HashMap。

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

参数：

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

func toArray()

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

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

返回值：

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

func values()

public func values(): Collection<V>

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

返回值：

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 - 与键对应的值。

异常：

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 相同。

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 - 初始化函数规则。

异常：

init()

public init()

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

init(Array<T>)

public init(elements: Array<T>)

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

参数：

init(Collection<T>)

public init(elements: Collection<T>)

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

参数：

init(Int64)

public init(capacity: Int64)

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

参数：

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

异常：

func capacity()

public func capacity(): Int64

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

注意:

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

返回值：

func clear()

public func clear(): Unit

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

func clone()

public func clone(): 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 的迭代器。

返回值：

示例：

使用示例见 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 中的所有元素。

参数：

func removeIf((T) -> Bool)

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

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

参数：

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

func reserve(Int64)

public func reserve(additional: Int64): Unit

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

参数：

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

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 类型数组。

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>>

异常：

prop prev

public prop prev: Option<LinkedListNode<T>>

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

类型：Option<LinkedListNode<T>>

异常：

prop value

public mut prop value: T

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

类型：T

异常：

func backward()

public func backward(): Iterator<T>

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

返回值：

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

异常：

func forward()

public func forward(): Iterator<T>

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

返回值：

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

异常：

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

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 - 要添加到链表中的元素。

返回值：

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 - 要添加到链表中的元素。

返回值：

异常：

func insertBefore(LinkedListNode<T>,T)

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

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

参数：

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

返回值：

异常：

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 个元素的节点。

返回值：

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 - 要添加到链表中的元素。

返回值：

func remove(LinkedListNode<T>)

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

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

参数：

返回值：

  • T - 被删除的节点的值。

异常：

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 不在当前的链表内，而是作为首个节点存在于新的链表内部。

参数：

返回值：

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

异常：

func toArray()

public func toArray(): Array<T>

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

返回值：

  • Array<T> - T 类型数组。

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 可以用于任何需要有序键值对存储的场景，例如数据库、缓存、查找表等。

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 中有相同的键时，后出现(迭代器顺序)的键值对将会覆盖先出现的键值对。

参数：

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

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

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

参数：

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

异常：

func clear()

public func clear(): Unit

功能：清除所有键值对。

func clone()

public func clone(): 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

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

参数：

返回值：

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

func findLower(K, Bool)

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

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

参数：

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

返回值：

func findUpper(K, Bool)

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

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

参数：

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

返回值：

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 值从小到大的顺序迭代。

返回值：

func keys()

public func keys(): EquatableCollection<K>

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

返回值：

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 中已有的键，该键的值将被新值替换。

参数：

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 存储在一个容器中。

返回值：

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 - 与键对应的值。

异常：