Kotlin集合扩展函数 - 转换

Kotlin 集合类型提供了很多用于转换的扩展函数。

这里需要指出示例里的intList为

val intList: List<I­nt> = listOf(1, 2, 3)

associate

关联函数：使用转换函数把Array或Iterable转换为Map：

数组

fun <T, K, V> any_array<T>.associate(
    transform: (T) -> Pair<K, V>
): Map<K, V>

Iterable

fun <T, K, V> Iterable<T>.associate(
    transform: (T) -> Pair<K, V>
): Map<K, V>

示例：

intLi­st.a­ss­ociate { 
  Pair(i­t.t­oSt­ring(), it) 
}
//结果为：{1=1, 2=2, 3=3}

map

使用转换函数把集合的元素映射为目的元素，返回转换后的新列表

Map

fun <K, V, R> Map<out K, V>.map(
    transform: (Entry<K, V>) -> R
): List<R>

数组

fun <T, R> any_array<T>.map(transform: (T) -> R): List<R>

Iterable

fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

示例

intLi­st.map { it + 1 }
//结果为：[2,3,4]

mapNotNull

mapNotNull和map类似，但是它只返回非null的值作为新列表的元素。

示例

intLi­st.m­ap­NotNull { null }
//结果为：[]，原因是所有返回的都是null

mapIndexed

map函数是以集合里的元素作为转换函数的输入，而mapIndexed则把数组和Iterable的元素以及元素对应的索引作为转换函数的输入，使用转换函数后映射为列表新的值。

数组

fun <T, R> any_array<T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>

Iterable

fun <T, R> Iterable<T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>

示例

intLi­st.m­ap­Indexed{ idx, value -> 
  if (idx == 0) value + 1 else value + 2 
}
//结果为：[2,4,5]

mapIndexedNotNull

与mapIndexed类似，但是只返回非null的值作为新列表的元素

示例

intLi­st.m­ap­Ind­exe­dNo­tNull { idx, value -> 
  if (idx == 0) null else value + 2 
}
//结果为：[4,5]

mapKeys 和 mapValues

mapKeys和mapValues是应用于Map，分别是对Map的键和值做映射，与其他映射返回的是列表不同，它们仍然是返回Map，只是Map的键或值是通过转换函数映射后的新值。

mapKeys

fun <K, V, R> Map<out K, V>.mapKeys(
    transform: (Entry<K, V>) -> R
): Map<R, V>

mapValues

fun <K, V, R> Map<out K, V>.mapValues(
    transform: (Entry<K, V>) -> R
): Map<K, R>

示例

aMap.m­apKeys { pair -> pair.key + ", mate" }
//结果为：{hi, mate=1, hello, mate=2}

aMap.m­ap­Values { pair -> pair.value + 2 })
//结果为：{hi=3, hello=4}

reverse和reversed

反转函数有两个：revers和reversed。

reverse：是对原来的列表直接做反转。

fun <T> any_array<T>.reverse()
fun <T> MutableList<T>.reverse()

reversed：返回一个与原来列表元素相反顺序的新列表。

fun <T> Array<out T>.reversed(): List<T>
fun ByteArray.reversed(): List<Byte>
fun ShortArray.reversed(): List<Short>
fun IntArray.reversed(): List<Int>
fun LongArray.reversed(): List<Long>
fun FloatArray.reversed(): List<Float>
fun DoubleArray.reversed(): List<Double>
fun BooleanArray.reversed(): List<Boolean>
fun CharArray.reversed(): List<Char>
fun <T> Iterable<T>.reversed(): List<T>

partition

分区函数用于把一个列表分为两个列表，这两个列表是根据预测函数返回的布尔值决定，预测函数返回true的元素进入第一个列表，否则为第二个列表的元素。

数组

fun <T> any_array<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

Iterable

fun <T> Iterable<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

示例

intLi­st.p­ar­tition { it > 2 })
//结果为：Pair(­[1,2], [3])

slice

slice用于获取列表里指定索引范围的元素。

使用IntRange指定索引范围

fun <T> Array<out T>.slice(indices: IntRange): List<T>
fun ByteArray.slice(indices: IntRange): List<Byte>
fun ShortArray.slice(indices: IntRange): List<Short>
fun IntArray.slice(indices: IntRange): List<Int>
fun LongArray.slice(indices: IntRange): List<Long>
fun FloatArray.slice(indices: IntRange): List<Float>
fun DoubleArray.slice(indices: IntRange): List<Double>
fun BooleanArray.slice(indices: IntRange): List<Boolean>
fun CharArray.slice(indices: IntRange): List<Char>
fun <T> List<T>.slice(indices: IntRange): List<T>

使用Iterable指定特定的索引

fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>
fun ByteArray.slice(indices: Iterable<Int>): List<Byte>
fun ShortArray.slice(indices: Iterable<Int>): List<Short>
fun IntArray.slice(indices: Iterable<Int>): List<Int>
fun LongArray.slice(indices: Iterable<Int>): List<Long>
fun FloatArray.slice(indices: Iterable<Int>): List<Float>
fun DoubleArray.slice(indices: Iterable<Int>): List<Double>
fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean>
fun CharArray.slice(indices: Iterable<Int>): List<Char>
fun <T> List<T>.slice(indices: Iterable<Int>): List<T>

排序

sorted 和 sortedBy

sorted是是把列表里的元素按自然顺序排序，返回排序后的列表。这里的前提是列表里的元素是可比较的。

fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>

示例

intLi­st.s­or­ted())
//结果[1,2,3]

sortedBy则是根据选择selector返回的值按自然顺序排序，返回排序后的列表。其中selector函数返回的值是可比较的。

fun <T, R : Comparable<R>> Iterable<T>.sortedBy(
    selector: (T) -> R?
): List<T>

示例

users.sortedBy{user -> user.age}

sortedDescending和sortedByDescending相应的分别和sorted与sortedBy函数对应，但是排序的顺序是降序。

sortedWith

sortedWith则是安装指定的comparator来对值进行比较，在这里可以很灵活定义自己的比较器。

fun <T> Iterable<T>.sortedWith(
    comparator: Comparator<in T>
): List<T>

示例

intLi­st.s­or­ted­Wit­h(C­omp­ara­tor­<In­t> { x, y -> 
  when { 
    x == 2 -> 1 
    y == 2 -> -1 
    else -> y - x 
  } 
})
//输出结果为[3,1,2]

展开

flatten函数把多个集合构成的一个集合展开，把所有集合的元素合并在一个集合返回

fun <T> Iterable<Iterable<T>>.flatten(): List<T>

示例

listO­f(i­ntList, aSet).f­la­tten()
//输出[2,3,­4,1]

zip和unzip

infix fun <T, R> Iterable<T>.zip(
    other: Array<out R>
): List<Pair<T, R>>

示例

listOf(3, 4).zip­(in­tList)
//输出为[(3,1), (4,2)]

unzip则是把Pair列表转换为两个列表对

fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

示例

listO­f(P­air­("hi­", 1), Pair("h­ell­o", 2)).un­zip()
Pair([hi, hello], [1,2])