当前位置:管家婆资料大全 > 关于管家婆 > 集合详解

集合详解

文章作者:关于管家婆 上传时间:2019-09-09

在 Java 类库中有一套相当完整的器皿集结类来全数对象。Kotlin未有去重新造轮子(Scala则是和煦达成了一套集结类框架),而是在Java 类库的功底上拓宽了改造和扩充,引进了不可变集结类,同不日常候扩张了大气有益实用的意义,那些职能的API 都在 kotlin.collections 包上边。

Kotlin中集聚的有别于Java,它有别于可变与不可变集结,且持有丰富的操作函数,使得我们运用起来更为简便易行轻易。

会集是开荒中国和北美洲平时用的学识,比方操作各样数据集,种种算法,保存互连网哀告结果,作为Adapter数据集,固然您不会汇聚的知识,那么恐怕连呈现壹在那之中央的ListView列表都做不到,明天就来讲说Kotlin中会面的学识。

其余,在Kotlin中集结类不仅能有所普通对象,并且能够具有函数类型的变量。譬喻,上面是多少个怀有三个函数的List

Kotlin中的集结类

Iterable:父类。全部大家可以遍历一多级的都以兑现这么些接口。

MutableIterable:一个支撑遍历的同一时间能够进行删除的Iterables。

Collection:这一个类相是三个范性会集。大家经过函数访谈能够回来集结的size、是不是为空、是不是带有四个依然局地item。这一个集结的兼具办法提供查询,因为connections是不可修改的。

MutableCollection:多少个协理增删item的Collection。它提供了附加的函数,举个例子add 、remove、clear等等。

List:可能是最流行的联谊类型。它是三个范性有序的联谊。因为它的平稳,大家得以选择get函数通过position来访谈。

MutableList:二个支撑增删item的List。

Set:三个冬日并不援救再度item的汇集。

MutableSet:多个支撑增删item的Set。

Map:三个key-value对的collection。key在map中是不二法门的,也正是说无法有两对key是同一的键值对存在于多个map中。

MutableMap:三个帮忙增删item的map。

有众多两样群集可用的函数操作符,实际付出进度中,可参照他事他说加以考察API。下边轻巧列举几个操作符:

Kotlin 中的集结依据可变性分类可以分为:

val funlist: List< -> Boolean> = listOf({ it -> it % 2 == 0 }, { it -> it % 2 == 1 })

list相关函数

val  list = listOf(1,2,3,4,5)v

list.any{ it > 3} //至少有多少个要素符合给出的论断标准

list.all{ it > 3} //全数的要素都高于2

list.count{ it > 3} //重回大于3的要素的个数

list.forEach{ println(it) } //遍历集合

list.max()  

list.maxBy{ -it } //再次回到符合条件的最大学一年级项,若无则赶回null

list.sumBy{ it % 2 } //重临每一类通过函数调换之后的多寡总和

list.fold(3){ total,count->total+count }//在一个开端值的功底上,从第一项到终极一项通过一个函数累加全体的要素

list.filter{ it % 2 == 0}//过滤集合

list.drop(4) //再次来到包含去掉前n个要素的兼具因素列表

list.slice(listOf(1,3))  //过滤三个list中钦点index的成分

list.take(3) //重返从首个开首的n个成分

...

  • 可变聚积
  • 不可变会集

中间, -> Boolean 是叁个从Int 映射到 Boolean的函数。

Map相关函数

val map = mapOf<String,String>()

map.put("one","1") //至极,为何?留给你们想想,结合作品初阶

val map2 =mapOf("one"tolistOf(1,2,3),"two"tolistOf("2"),"three"to1)

map2.getOrDefault("four","default_value")  //如果key无four,返回default_value

map2.getOrElse("four",{ "default_value" }) //与上贰个好像,重回lambda值

map2.forEach{ k ,v -> println("$k -> $v")} //遍历map

map2.get("one")   等价于 map2["one"]

...

根据体系分类能够分成:

而以此时候,大家得以在代码里甄选调用哪个函数

Set相关函数

val set = setOf(1,2,3,4) //成立不可变set

val muSet = mutableSetOf() //创设可变set

muSet.add(1)

muSet.remove(1)

muSet.removeIf{ it > 5 }

muSet.clear()

...

  • List集合
  • Map集合
  • Set集合
val list = listOf(1, 2, 3, 4, 5, 6, 7)list.filter(funlist[0]) // [2, 4, 6]list.filter(funlist[1]) // [1, 3, 5, 7]

结缘在一块儿就是说List,Map,Set又都足以分为可变和不可变二种。
具体来说
对于List

是或不是以为很风趣?那就是面向对象范式混合函数式编制程序的任意野趣吧!

  • List ——注解不可变List集结
  • MutableList——注解可变List集合

本章将介绍Kotlin标准库中的集结类,大家将驾驭到它是什么扩展的Java集结库,使得写代码尤其简约轻易。

对于Map

集结类存放的都以目的的援用,而非对象自己,大家不以为奇说的汇聚中的对象指的是汇集中目的的引用(reference)。

  • Map——证明不可变Map群集
  • MutableMap——注脚可变Map群集

Kotlin的集合类分为:可变集结类与不足变集合类(Immutable)。

对于Set

7.1.1 常用的3种群集类

会集类首要有3种:List、Set和 Map。如下图所示

图片 1集结类分类

  • List 列表

List 列表的显要特点是其指标以线性子局存款和储蓄,未有一定顺序,独有一个起来和三个尾声。列表在数据结构中可展现为:数组和向量、链表、仓库、队列等。

  • Set 集

Set 集是最简易的一种集合,它的对象不按一定措施排序,只是简短的把目的参与集结中,就像是往口袋里放一批溜溜弹珠。 Set 集中未有重新对象。

  • Map 映射

Map 映射与Set 集或List 列表的界别是:Map 映射中各样项都是成对的。

Map 映射中储存的每一个对象都有四个有关的机要字对象,关键字决定了 对象在粲焕中的存款和储蓄地点,检索对象时必须提供对应的入眼字,就像是在字典中查单词同样。关键字是头一无二的。

重大字我并不可能调控对象的蕴藏地点,它通过散列 发生二个被称作散列码(hash code)的大背头值,那个散列码对应值的累积地点。

如果大家从数据结构的本质上来看,其实List正是Key是Int类型下标的特别规的Map。而Set也是Key为Int,不过Value值不可能再一次的分裂平常Map。

  • Set——注解不可变Set会集
  • MutableSet——注脚可变Set集结

7.1.2 Kotlin 集结类承继档案的次序

下边是 Kotlin 中的集结接口的类图

图片 2Kotlin 集结类承袭档次

个中种种接口表明如下表所示

接口 功能
Iterable 父类。任何类继承这个接口就表示可以遍历序列的元素
MutableIterable 在迭代期间支持删除元素的迭代
Collection List和Set的父类接口。只读不可变
MutableCollection 支持添加和删除元素的Collection。它提供写入的函数,如:add、remove或clear等
List 最常用的集合,继承Collection接口,元素有序,只读不可变
MutableList 继承List,支持添加和删除元素,除了拥有List中的读数据的函数,还有add、remove或clear等写入数据的函数
Set 元素无重复、无序。继承Collection接口。只读不可变
MutableSet 继承Set,支持添加和删除元素的Set
Map 存储 K-V对的集合。在 Map 映射表中 key是唯一的
MutableMap 支持添加和删除元素的Map

List 列表分为只读不可变的 List 和 可变 MutableList 。List 集合类图如下

图片 3List 集合类图.png

Set 集也分为不可变 Set 和 可变 MutableSet 。 Set 集合类图如下

图片 4Set 集结类图

Kotlin中的Map与List、Set一样,Map也分为只读Map和可变 MutableMap。Map未有承继于Collection接口。其类图结构如下

图片 5Map 集结类图

下边,大家来成立集结类。

Kotlin中接纳 listOf() 、setOf 创设不可变的 List列表、Set集、Map映射表;使用mutableListOf() 、mutableSetOf() 、mutableMapOf() 来创建可变的 MutableList 列表、MutableSet 集、MutableMap 映射表。代码示举例下

 val list = listOf(1, 2, 3, 4, 5, 6, 7) val mutableList = mutableListOf("a", "b", "c") val set = setOf(1, 2, 3, 4, 5, 6, 7) val mutableSet = mutableSetOf("a", "b", "c") val map = mapOf(1 to "a", 2 to "b", 3 to "c") val mutableMap = mutableMapOf(1 to "X", 2 to "Y", 3 to "Z")

只要创制没有元素的空List,使用listOf() 就可以。然则那年,变量的品种不能够大约,必要显式评释

 val emptyList: List<Int> = listOf() val emptySet: Set<Int> = setOf() val emptyMap: Map<Int, String> = mapOf()

再不会报错

>>> val list = listOf()error: type inference failed: Not enough information to infer parameter T in inline fun <T> listOf(): List<T>Please specify it explicitly.val list = listOf() ^

因为这里的 fun <T> listOf(): List<T> 泛型参数 T 编写翻译器不能想见出来。 setOf同理分析。

List、Set 类承袭了Iterable接口,里面扩展了forEach函数来迭代遍历成分;一样的 Map 接口中也扩充了forEach函数来迭代遍历成分。

 list.forEach { println } set.forEach { println } map.forEach { println("K = ${it.key}, V = ${it.value}") // Map里面的对象是Map.Entry<K, V> }

里面,forEach函数签字如下

public inline fun <T> Iterable<T>.forEach(action:  -> Unit): Unitpublic inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit): Unit

大家看出,在Iterable 和 Map中, forEach 函数都以多少个内联 inline 函数。

另外,假若大家想在迭代遍历成分的时候,访谈index下标,在List 和 Set 中能够利用上边的forEachIndexed函数

 list.forEachIndexed { index, value -> println("list index = ${index} , value = ${value}") } set.forEachIndexed { index, value -> println("set index = ${index} , value = ${value}") }

中间,第二个参数是index,首个参数是value。这里的forEachIndexed函数具名如下

public inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit): Unit

Map的成分是Entry类型,由 entries属性持有

val entries: Set<Entry<K, V>>

以此Entry类型定义如下:

 public interface Entry<out K, out V> { public val key: K public val value: V }

我们得以向来访谈entries属性获取该Map中的全部键/值对的Set。代码示例

>>> val map = mapOf("x" to 1, "y" to 2, "z" to 3)>>> map{x=1, y=2, z=3}>>> map.entries[x=1, y=2, z=3]

那般,大家就足以遍历那一个Entry的Set了:

>>> map.entries.forEach({println("key="+ it.key + " value=" + it.value)})key=x value=1key=y value=2key=z value=3

行使 map 函数,大家能够把集结中的成分,依次使用给定的转移函数举办映射操作,成分映射之后的新值,会存入三个新的成团中,并再次回到这些新集结。这些进程能够用下图形象地来验证

图片 6map 函数

在List、Set 承接的Iterable 接口中,和Map接口中都提供了这么些 map 函数。使用map 函数的代码示比方下

 val list = listOf(1, 2, 3, 4, 5, 6, 7) val set = setOf(1, 2, 3, 4, 5, 6, 7) val map = mapOf(1 to "a", 2 to "b", 3 to "c") list.map { it * it } // [1, 4, 9, 16, 25, 36, 49] set.map{ it + 1 } // [2, 3, 4, 5, 6, 7, 8] map.map{ it.value + "$" } // [a$, b$, c$]

map 函数的签约如下

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

那边的Rubicon类型是绚烂之后的数据类型,大家也得以流传三个List

val strlist = listOf("a", "b", "c")strlist.map { it -> listOf(it + 1, it + 2, it + 3, it + 4) }

今年,再次来到值的项目将是List<List>, 也正是一个List里面嵌套四个List,上边代码的归来结果是

[[a1, a2, a3, a4], [b1, b2, b3, b4], [c1, c2, c3, c4]]

Kotlin中还提供了贰个 flatten() 函数,效果是把嵌套的List结构“压平”,形成一层的结构,代码示比如下

strlist.map { it -> listOf(it + 1, it + 2, it + 3, it + 4) }.flatten()

输出

[a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4]

flatMap 函数是把位置的先映射,再“压平”的两阶映射组合的结果,代码示譬如下

strlist.flatMap { it -> listOf(it + 1, it + 2, it + 3, it + 4) }

同等输出

[a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4]

在第5章中,大家早就讲过了filter函数,这里大家再举二个代码示例。首先,大家有二个Student 对象,我们使用数据类来声称如下

data class Student(var id: Long, var name: String, var age: Int, var score: Int){ override fun toString(): String { return "Student(id=$id, name='$name', age=$age, score=$score)" }}

为了有助于拜会打字与印刷音信,重写了toString()函数。然后,大家创立三个怀有Student 对象的List

 val studentList = listOf( Student(1, "Jack", 18, 90), Student(2, "Rose", 17, 80), Student(3, "Alice", 16, 70) )

那个时候,若是大家想要过滤出年龄大于等于18岁的上学的小孩子,代码能够写成下面那样

studentList.filter { it.age >= 18 }

输出:

[Student(id=1, name='Jack', age=18, score=90)]

倘诺,我们想要过滤出分数小于80分的上学的小孩子,代码如下

studentList.filter { it.score < 80 }

输出:

[Student(id=3, name='Alice', age=16, score=70)]

别的,假使大家想要访问下标来过滤,使用 filterIndexed 函数

val list = listOf(1, 2, 3, 4, 5, 6, 7)list.filterIndexed { index, it -> index % 2 == 0 && it > 3 } // [5, 7]

filterIndexed 函数签字如下

public inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>

倒序排列集结成分。代码示例

val list = listOf(1, 2, 3, 4, 5, 6, 7)val set = setOflist.reversed() // [7, 6, 5, 4, 3, 2, 1]set.reversed() // [2, 3, 1]

本条Iterable的扩大函数 reversed() 是直接调用的java.util.Collections.reverse()方法。其有关代码如下:

public fun <T> Iterable<T>.reversed(): List<T> { if (this is Collection && size <= 1) return toList() val list = toMutableList() list.reverse() return list}public fun <T> MutableList<T>.reverse(): Unit { java.util.Collections.reverse}

升序排序函数是 sorted(), 实例代码如下

>>> list.sorted()[1, 2, 3, 4, 5, 6, 7]>>> set.sorted()[1, 2, 3]

Kotlin的那些 sorted() 函数也是一向调用的 Java 的API 来贯彻的,相关代码如下

public fun <T : Comparable<T>> Iterable<T>.sorted(): List<T> { if (this is Collection) { if (size <= 1) return this.toList() @Suppress("UNCHECKED_CAST") return (toTypedArray<Comparable<T>>() as Array<T>).apply { sort() }.asList() } return toMutableList().apply { sort() }}

其幕后调用的是 java.util.Arrays.sort() 方法:

public fun <T> Array<out T>.sort(): Unit { if (size > 1) java.util.Arrays.sort}

若是大家想对多个 List 列表进行成分去重,可以向来调用 distinct() 函数

val dupList = listOf(1, 1, 2, 2, 3, 3, 3)dupList.distinct() // [1, 2, 3]

Kotlin中会集类中还提供了大多作用丰裕的API,此处不一一介绍。越来越多能够参照官方API文书档案:

本章大家介绍了Kotlin规范库中的集结类List、Set、Map,以及它们扩张的增进的操作函数,这一个函数使得大家应用那一个会集类越发简便易行轻便。

会集类持有的是指标,而什么的放入准确的目标类型则是我们写代码进程中需求注意的。下一章节中我们将学习泛型。

本国率先Kotlin 开辟者社区群众号,首要共享、交换 Kotlin 编制程序语言、Spring Boot、Android、React.js/Node.js、函数式编制程序、编程观念等连锁主旨。

图片 7开垦者社区 QRCode.jpg

除此而外还会有几个主导接口

  • Iterable ——全体集结的父类
  • MutableIterable —— 承袭于Iterabl接口,支持遍历的同一时间可以进行删除操作
  • Collection —— 承袭于Iterable接口,仅封装了对聚集的只读方法
  • MutableCollection ——继承于Iterable,Collection,封装了充分或移除集合桐月素的点子

另外,记住List ,MutableList,Set,MutableSet 归根结底都是Collection的子类。

会师的开创

Kotlin并未提供创立集合的函数,但我们能够运用如下方法来创立相应的会面

List

创建贰个不可变的list

val mList = listOf<Int>(1, 2, 3)

成立三个可变的list

val mList = mutableListOf<Int>(1, 2, 3)

这里mutableListOf伊始化了两个值,若无那多个值就一定于二个空集结,比如

 val mList = mutableListOf<Int>()
    Log.i(TAG, "mList size:" + mList.size)
    mList.add(1)
    mList.add(2)
    Log.i(TAG, "mList size:" + mList.size)

打字与印刷结果为

com.kotlin.collection.example I/MainActivity: mList size:0
com.kotlin.collection.example I/MainActivity: mList size:2

那样就能够给急需最初值为空的列表实行赋值了,比如ListView的Adapter开首值为空的状态。
其它还应该有多少个表明List集合的艺术

  • emptyList()——创立四个空集结
  • listOfNotNull ()—— 创造的汇合中不能够插入null值

Set

开创一个不可变的Set

val mList = setOf<Int>(1,2,3)

创办二个可变的Set

val mList = mutableSetOf<Int>(1,2,3)

别的还大概有如下方法

  • emptySet() ——创造三个空的set集合
  • linkedSetOf()—— 创立set链表群集

Map

创制二个不可变的Map

val mList = mapOf(Pair("key1", 1), Pair("key2", 2))

或者

val mList = mapOf("key1" to 1, "key2" to 2)

创造一个可变的Map

val mList = mutableMapOf("key1" to 1, "key2" to 2)

推荐介绍使用to的艺术创建
另外还会有

  • emptyMap()——成立二个空map
  • hashMapOf()——成立多个hashMap
  • linkedMapOf()——创设三个linkedMap
  • sortedMapOf()——成立一个sortedMap

如上正是三种会集常见的创立情势,上面再来讲说集结中的操作符,使用特别的操作符能够小幅度的缩减你的代码量

操作符

总和操作

any

申明:如若至少有三个因素符合剖断标准,则赶回true,不然false,例:

val list = listOf(1, 2, 3, 4, 5)
list.any { it > 10 }

结果为false

all

证实:假诺集结中具有的成分都符合测量尺度,则赶回true不然false,例:

val list = listOf(1, 2, 3, 4, 5)

list.any { it < 10 }

结果为true

count

表明:重返集合中符合判别标准的因素总的数量。例:

list.count { it <3 }

结果为2

fold

申明:在二个早先值的根基上从第一项到终极一项通过贰个函数累计全部的成分。例:

list.fold(0) { total, next -> total + next }

结果为15 (总结方法:0+1+2+3+4+5,第一个数0 为fold中的0,也正是开端值)

foldRight

申明:与fold同样,然则种种是从末了一项到第一项。例:

list.foldRight(0) { total, next -> total + next }

结果也为15

reduce

申明:与fold同样,可是尚未二个初叶值。通过二个函数从第一项到终极一项举行累计。例:

list.reduce{ total, next -> total + next}

结果为15

reduceRight

表明:与foldRight同样,只但是未有开首值。例:

list.reduceRight { total, next -> total + next }

结果也为15

forEach

证实:遍历全数因素,并实施给定的操作(类似于Java 中的for循环)。例:

list.forEach{ Log.i(TAG,it.toString()) }

结果为:1 2 3 4 5

forEachIndexed

表达:与forEach作用同样,不过还要能够赢得成分的index。例:

list.forEachIndexed { index, i -> Log.i(TAG, "index:" + index + " value:" + i.toString()) }

结果为
index:0 value:1
index:1 value:2
index:2 value:3
index:3 value:4
index:4 value:5

max

注解:重返集合中最大的一项,若无则赶回null。例:

Log.i(TAG, list.max().toString())

结果为:5

min

证实:重返集合中幽微的一项,若无则赶回null。例:

Log.i(TAG, list.min().toString())

结果为:1

maxBy

说明:依据给定的函数再次来到最大的一项,如果未有则赶回null。例:

Log.i(TAG, list.maxBy { it-10 }.toString())

结果为 :5 (因为从1到5那5个成分中独有5减去10后的值最大,所以回来元素5,注意再次回到的不是测算结果)

minBy

证实:再次来到最小的一项,如果未有则赶回null。例:

Log.i(TAG, list.minBy { it-10 }.toString())

结果为:1

sumBy

表明:再次回到全部各种通过函数转变之后的数码的总的数量。例:

list.sumBy { it + 2 }

结果为:25 (每一个成分都加2,最终求和)

过滤操作

drop

证实:重临去掉前n个要素的列表。例:

val list = listOf(1, 2, 3, 4, 5)
var s = list.drop(2)
s.forEach {
Log.i(TAG, it.toString())
}

结果为 :3 4 5(去掉了前多个成分)

dropWhile

证实:重返依据给定函数从第一项开首去掉内定成分的列表。例:

list.dropWhile { it < 3 }

结果为:3 4 5

dropLastWhile

表明:同dropWhile,但是是从最后一项初始。例:

list.dropLastWhile { it >3 }

结果为:1 2 3

filter

表明:过滤全体符合给定函数条件的因素。例:

list.filter { it > 2 }

结果为:3 4 5

filterNot

表明:过滤全数不切合给定函数条件的因素。例:

list.filterNot{ it > 2 }

结果为:1 2

filterNotNull

表达:过滤全体因素中不是null的因素。例:

list.filterNotNull()

结果为:1 2 3 4 5

slice

申明:过滤集结中钦赐index的要素(其实正是获取钦赐index的要素)。例:

list.slice(listOf(0,1,2))

结果为:1 2 3

take

证实:重临从第三个起来的n个成分。例:

list.take(2)

结果为:1 2

takeLast

证实:重返从最后多个伊始的n个成分。例:

list.takeLast(2)

结果为:4 5

takeWhile

证实:重返从第三个开始符合给定函数条件的因素。例:

list.takeWhile { it<3 }

结果为:1 2

炫丽操作

flatMap

证实:遍历全部的元素,为每二个成立三个集结,最终把全数的汇集放在四个聚众中。例:

list.flatMap { listOf(it, it + 1) }

结果为: 1 2 2 3 3 4 4 5 5 6(各个成分都推行加1后作为三个新因素)

groupBy

注明:重回一个按照给定函数分组后的map。例:

list.groupBy { if (it >3) "big" else "small" }

结果为:
small=[1, 2, 3]
big=[4, 5]

map

注明:重返三个每多个要素依照给定的函数转变所构成的联谊。例:

list.map { it * 2 }

结果为:2 4 6 8 10

mapIndexed

证实:重返叁个每一个成分依照给定的隐含成分index的函数转变所结合的会集。例:

list.mapIndexed { index, it -> index + it }

结果为:1 3 5 7 9

mapNotNull

注解:再次回到多少个每二个非null成分依照给定的函数调换所构成的集聚。例:

list.mapNotNull { it * 2 }

结果为:2 4 6 8 10

种种操作

reversed

表达:重回贰个与钦点集合相反顺序的成团。例:

list.reversed()

结果为:5 4 3 2 1

sorted

注解:返回叁个自然排序后的聚合。例:

val list = listOf(1, 2, 6, 4, 5)
var s = list.sorted()

结果为 1 2 4 5 6

sortedBy

注脚:重临二个依据钦定函数排序后的聚焦。例:

val list = listOf(1, 2, 6, 4, 5)
var s = list.sortedBy { it - 2 }

结果为 1 2 4 5 6

sortedDescending

申明:重返叁个降序排序后的联谊。例:

list.sortedDescending()

结果为:5 4 3 2 1

sortedByDescending

注解:重返一个依照钦赐函数降序排序后的集结。例:

list.sortedByDescending { it % 2 }

结果为: 1 3 5 2 4

生育操作

partition

表明:把二个加以的会集分割成多个,第多个聚众是由原会集每一种成分相配给定函数条件重回true的因素构成,第1个聚众是由原会集各个成分相称给定函数条件再次回到false的要素结合。例:

val list = listOf(1, 2, 3, 4, 5)
var s = list.partition { it > 2 }
s.first.forEach {
    Log.i(TAG, it.toString())
}
s.second.forEach {
    Log.i(TAG, it.toString())
}

结果为:
3 4 5
1 2

plus

表明:再次回到三个包括原集结和加以集合中兼有因素的汇集,因为函数的名字由来,大家得以选取+操作符。例:

list + listOf(6, 7)

结果为: 1 2 3 4 5 6 7

zip

注明:重临由pair组成的List,每一种pair由三个集聚中一模二样index的要素结合。那几个重回的List的大小由微小的充足集结决定。例:

list.zip(listOf(7, 8))

结果为:(1, 7) (2, 8)

unzip

表明:从包罗pair的List中生成包括List的Pair。例:

var s = listOf(Pair(1, 2), Pair(3, 4)).unzip()
s.first.forEach {
    Log.i(TAG, it.toString())
}
s.second.forEach {
    Log.i(TAG, it.toString())
}

结果为:1 2 3 4

要素操作

contains

证实:钦命成分得以在汇集中找到,则赶回true,不然false。例:

list.contains(1)

结果为:true

elementAt

表明:再次来到给定index对应的因素,如果index数组越界则会抛出IndexOutOfBoundsException。例:

list.elementAt(1)

结果为:2

elementAtOrElse

申明:重临给定index对应的要素,如若index数组越界则会基于给定函数再次回到暗中认可值。例:

list.elementAtOrElse(5, { it + 2 })

结果为:7

elementAtOrNull

证实:重返给定index对应的成分,如若index数组越界则会回到null。例:

list.elementAtOrNull(5)

结果为:null

first

表达:再次回到符合给定函数条件的首先个因素。例:

list.first { it > 2 }

结果为:3

firstOrNull

表达:再次来到符合给定函数条件的首先个因素,若无符合则赶回null。例:

list.first { it > 8 }

结果为:null

indexOf

证实:再次来到钦定成分的率先个index,假诺不真实,则赶回-1。例:

list.indexOf(2)

结果为:1

indexOfFirst

表达:重返第贰个适合给定函数条件的因素的index,如果未有符合则赶回-1。例:

list.indexOfFirst { it % 2 == 0 }

结果为:1

indexOfLast

注脚:重临最终叁个相符给定函数条件的要素的index,若无适合则赶回-1。例:

list.indexOfLast { it % 2 == 0 }

结果为:3

last

证实:重回符合给定函数条件的结尾二个成分。例:

list.last { it % 2 == 0 }

结果为:4

lastIndexOf

表达:重回钦定成分的最后二个index,假如一纸空文,则赶回-1。例:

list.lastIndexOf(4)

结果为:3

lastOrNull

注明:重回符合给定函数条件的结尾贰个要素,若无符合则赶回null。例:

list.lastOrNull { it > 6 }

结果为:null

single

证实:再次来到符合给定函数的单个成分,若无适合或许超过多少个,则抛出拾叁分。例:

list.single { it > 4 }

结果为:5

singleOrNull

注解:再次回到符合给定函数的单个成分,若无适合或许超过一个,则赶回null。例:

list.singleOrNull { it > 5}

结果为:null

本文由管家婆资料大全发布于关于管家婆,转载请注明出处:集合详解

关键词: