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}

reversereversed

反转函数有两个: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}

sortedDescendingsortedByDescending相应的分别和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]

zipunzip

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

版权声明:著作权归作者所有。

相关推荐

Kotlin传递函数作为参数的方式

Kotlin传递函数作为参数,可以有:命名参数,位置参数以及在参数列表外,以lamba的形式传递。示例data class Person(val name: String,                &nb

Ubuntu安装php curl扩展

1、使用apt-cache搜索curlsudo apt-cache search curl 在搜索结果里找到类似:php5.6-curl - CURL module for PHP php7.1-curl - CURL module for PHP 2、使用apt-ge

Kotlin集合扩展函数 - 创建集合

Kotlin标准包提供了一系列的扩展函数用来创建集合,包括Array,List,Set,Map以及可变集合。这里需要指出示例里的intList为val intList: List<I­nt> = listOf(1, 2, 3) Array创建数组基本方式val intArray: Array<­Int

Java 8 Stream API转换到Kotlin集合API

Kotlin提供的集合操作的API相对Java 8 Stream的API简洁很多。下面是Java 8 Stream API转换到Kotlin集合API。 映射属性聚合为列表// Java:   List<String> names = users.stream().m

Kotlin空值(Nullable Value)的处理以及转换

 使用Java稍不留神很容易导致NullPointException。Kotlin的类型系统使用可空类型(Nullable Type)旨在消除null引用导致的代码出错。Kotlin要求我们必须检测可空类型的值,只有非null的值才允许访问。有几种方式来处理可空类型的值,以避免null引用的出现。 条件检查var nullableStr?: Str