函数

func sort<T>(Array<T>, Bool, Bool) where T <: Comparable<T>

public func sort<T>(data: Array<T>, stable!: Bool = false, descending!: Bool = false): Unit where T <: Comparable<T>

功能：对数组进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

参数：

• data: Array<T> - 需要排序的数组。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(Array<T>, (T, T) -> Ordering, Bool, Bool)

public func sort<T>(data: Array<T>, by!: (T, T) -> Ordering, stable!: Bool = false, descending!: Bool = false): Unit

功能：对数组按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 by。如果 by 的返回值为 Ordering.GT，排序后 t1 在 t2 后；如果 by 的返回值为 Ordering.LT，排序后 t1 在 t2 前；如果 by 的返回值为 Ordering.EQ，排序后 t1 与 t2 的位置与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: Array<T> - 需要排序的数组。
• by!: (T, T) ->Ordering - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(Array<T>, (T, T) -> Bool, Bool, Bool)

public func sort<T>(data: Array<T>, lessThan!: (T, T) -> Bool, stable!: Bool = false, descending!: Bool = false): Unit

功能：对数组按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 lessThan。如果 lessThan 的返回值为 true，排序后 t1 在 t2 前；如果 lessThan 的返回值为false，又会分为两种情况，如果 t1 和 t2 不相等，排序后 t1 在 t2 后，如果相等，t1 与 t2 的前后位置关系与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: Array<T> - 需要排序的数组。
• lessThan!: (T, T) ->Bool - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T, K>(Array<T>, (T) -> K, Bool, Bool) where K <: Comparable<K>

public func sort<T, K>(data: Array<T>, key!: (T) -> K, stable!: Bool = false, descending!: Bool = false): Unit where K <: Comparable<K>

功能：对数组按照指定的键（键与键之间可比较）进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入数组元素到键的映射函数。

参数：

• data: Array<T> - 需要排序的数组。
• key!: (T) -> K - 元素到键的映射函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(ArrayList<T>, Bool, Bool) where T <: Comparable<T>

public func sort<T>(data: ArrayList<T>, stable!: Bool = false, descending!: Bool = false): Unit where T <: Comparable<T>

功能：对 ArrayList 进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

参数：

• data: ArrayList<T> - 需要排序的 ArrayList。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(ArrayList<T>, (T, T) -> Ordering, Bool, Bool)

public func sort<T>(data: ArrayList<T>, by!: (T, T) -> Ordering, stable!: Bool = false, descending!: Bool = false): Unit

功能：对 ArrayList 按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 by。如果 by 的返回值为 Ordering.GT，排序后 t1 在 t2 后；如果 by 的返回值为 Ordering.LT，排序后 t1 在 t2 前；如果 by 的返回值为 Ordering.EQ，排序后 t1 与 t2 的位置与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: ArrayList<T> - 需要排序的 ArrayList。
• by!: (T, T) ->Ordering - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(ArrayList<T>, (T, T) -> Bool, Bool, Bool)

public func sort<T>(data: ArrayList<T>, lessThan!: (T, T) -> Bool, stable!: Bool = false, descending!: Bool = false): Unit

功能：对 ArrayList 按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 lessThan。如果 lessThan 的返回值为 true，排序后 t1 在 t2 前；如果 lessThan 的返回值为false，又会分为两种情况，如果 t1 和 t2 不相等，排序后 t1 在 t2 后，如果相等，t1 与 t2 的前后位置关系与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: ArrayList<T> - 需要排序的 ArrayList。
• lessThan!: (T, T) ->Bool - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T, K>(ArrayList<T>, (T) -> K, Bool, Bool) where K <: Comparable<K>

public func sort<T, K>(data: ArrayList<T>, key!: (T) -> K, stable!: Bool = false, descending!: Bool = false): Unit where K <: Comparable<K>

功能：对 ArrayList 按照指定的键（键与键之间可比较）进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入 ArrayList 元素到键的映射函数。

参数：

• data: ArrayList<T> - 需要排序的 ArrayList。
• key!: (T) -> K - 元素到键的映射函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(List<T>, Bool, Bool) where T <: Comparable<T>

public func sort<T>(data: List<T>, stable!: Bool = false, descending!: Bool = false): Unit where T <: Comparable<T>

功能：对 List 进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

参数：

• data: List<T> - 需要排序的 List。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(List<T>, (T, T) -> Ordering, Bool, Bool)

public func sort<T>(data: List<T>, by!: (T, T) -> Ordering, stable!: Bool = false, descending!: Bool = false): Unit

功能：对 List 按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 by。如果 by 的返回值为 Ordering.GT，排序后 t1 在 t2 后；如果 by 的返回值为 Ordering.LT，排序后 t1 在 t2 前；如果 by 的返回值为 Ordering.EQ，排序后 t1 与 t2 的位置与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: List<T> - 需要排序的 List。
• by!: (T, T) ->Ordering - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T>(List<T>, (T, T) -> Bool, Bool, Bool)

public func sort<T>(data: List<T>, lessThan!: (T, T) -> Bool, stable!: Bool = false, descending!: Bool = false): Unit

功能：对 List 按照比较函数进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入自定义的比较函数 lessThan。如果 lessThan 的返回值为 true，排序后 t1 在 t2 前；如果 lessThan 的返回值为false，又会分为两种情况，如果 t1 和 t2 不相等，排序后 t1 在 t2 后，如果相等，t1 与 t2 的前后位置关系与是否是稳定排序有关，稳定则较排序前保持不变，否则有可能发生改变。

参数：

• data: List<T> - 需要排序的 List。
• lessThan!: (T, T) ->Bool - 传入的比较函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func sort<T, K>(List<T>, (T) -> K, Bool, Bool) where K <: Comparable<K>

public func sort<T, K>(data: List<T>, key!: (T) -> K, stable!: Bool = false, descending!: Bool = false): Unit where K <: Comparable<K>

功能：对 List 按照指定的键（键与键之间可比较）进行排序。可根据入参指定是否要进行稳定排序，是升序还是降序。

用户需传入 List 元素到键的映射函数。

参数：

• data: List<T> - 需要排序的 List。
• key!: (T) -> K - 元素到键的映射函数。
• stable!: Bool - 是否使用稳定排序，默认为否。
• descending!: Bool - 是否使用降序排序，默认为否。

func stableSort<T>(Array<T>) where T <: Comparable<T> ^(deprecated)

public func stableSort<T>(data: Array<T>): Unit where T <: Comparable<T>

功能：对数组进行稳定升序排序。

注意：

未来版本即将废弃，使用 sort 替代。

参数：

• data: Array<T> - 需要排序的数组。

func stableSort<T>(Array<T>, (T, T) -> Ordering) ^(deprecated)

public func stableSort<T>(data: Array<T>, comparator: (T, T) -> Ordering): Unit

功能：对数组进行稳定排序。

用户可传入自定义的比较函数 comparator，如果 comparator 的返回值为 Ordering.GT，排序后 t1 在 t2 后；如果 comparator 的返回值为 Ordering.LT，排序后 t1 在 t2 前；如果 comparator 的返回值为 Ordering.EQ，排序后 t1 与 t2 的位置较排序前保持不变。

注意：

未来版本即将废弃，使用 sort 替代。

参数：

• data: Array<T> - 需要排序的数组。
• comparator: (T, T) ->Ordering - 用户传入的比较函数。

func unstableSort<T>(Array<T>) where T <: Comparable<T> ^(deprecated)

public func unstableSort<T>(data: Array<T>): Unit where T <: Comparable<T>

功能：对数组进行不稳定升序排序。

注意：

未来版本即将废弃，使用 sort 替代。

参数：

• data: Array<T> - 需要排序的数组。

func unstableSort<T>(Array<T>, (T, T) -> Ordering) ^(deprecated)

public func unstableSort<T>(data: Array<T>, comparator: (T, T) -> Ordering): Unit

功能：对数组进行不稳定排序。

用户可传入自定义的比较函数 comparator，如果 comparator 的返回值为 Ordering.GT，排序后 t1 在 t2 后；如果 comparator 的返回值为 Ordering.LT，排序后 t1 在 t2 前；如果 comparator 的返回值为 Ordering.EQ，排序后 t1 与 t2 的位置较排序前保持不变。

注意：

未来版本即将废弃，使用 sort 替代。

参数：

• data: Array<T> - 需要排序的数组。
• comparator: (T, T) ->Ordering - 用户传入的比较函数。