Kotlin 集合函数速查

「本文已参与好文召集令活动，点击检查：后端、大前端双赛道投稿，2万元奖池等你应战！」

原文：medium.com/mobile-app-…

作者：Elye

前言

你们知道 Kotlin Collection 的操作函数有多少个？200多个。依照函数名的字母顺序实例化目标阅览一遍或许都得花点时刻链表排序，更别提快速找到满意自己业务场景的函数了，乃至有些函数你或许都不知道它的存在，此情此景甚是苦恼啊！好在最近阅览一遍关于 Kotlin 集结操作函数的文章，作者依据函数的功用性，将其分为 5 类：Creation、Congithub永久回家地址vert、Change、Choose 和 Conclude，针对每个大类作者进一步差异子类，悉数类型称号皆以 C 开始以照顾 Collection 集结，情怀如斯啊！经过分类构成的快查备忘录让悉数函数以树形结构呈现在各位面前，查找起来更便利。谈心的作者关于一些不太简略了解的函数，还在文章中供应一些插图辅佐说明，关于一些常见的函数，作者也添加了官方文档的链接以便咱们深化了解前端。感谢作者的收拾，下面开始正文。

分类

首要分为 5 种类别：

1. Creation：新建集结，例如 listOf

2. Convert：转化集结，例如 asMap

3. Change：改动集结，例如 map

4. Choose：拜访集结，例如 get

5. Conclude：汇总集结，例如 sum

怎样快速查找

场景一：

假定你想寻找一前端学什么个能够将列表中的悉数整数项值相乘的函数，考虑到最后的作用是由集结内悉数元素相乘得到，所以你应该去 Conclude 类别下查找，阅览该类别下的悉数函数后，你将实例化servlet类反常如愿找到 reduce 函数

list.reduce{ result, item -> result * item }

场景二：

假定你想找一个能够将列表拆分红几个固定巨细的子列表的函数，考虑到究竟作用是将现有列表转化为另一种方法的集结。所以你应该去 Change 类别中去查找。查阅该类别下的悉数函数后，你会如愿找到 chunk前端面试题 函数

list.chunked(3)

类别之间的关系

上面 5 种类别，咱们能够用状况机的概念将其联系起来，因为 Creation 类别是用于创立集结的，所以它是初始状况，Change 和 C前端技能onvert 是能够互相转化的中间链表和数组的差异状况，而究竟状况为 Conclude 或 Choose。 例如：

listOf(1, 2, 3)   // Cgithub是干什么的reation
.map { it * 2 }   // Change
.sum()            // Conclude

也能够直接从初始状况到究竟状况，例如：

listOf(1, 2, 3)   // Creation
.sum前端技能()            // Conclude

Creation

咱们能够链表排序对 Creation 类别进行进一步的细分，实例化一个类以便咱们更快的查找函数。

1. Creation Compose — 实例化新集结
2. Creation Copy — 复制集结
3. Creation Catch — 相似 try-catapp是什么意思ch 的方法创立集结

Creation Compose — 实例化新集结

// 空集结

emptappstoreyList, emptyMap, emptySet

// 只读集结

listOf, mapOf, setOf

// 可变集结

mutableListOf, mutable实例化目标MapOf, mutableSetOf, arrayLiappearstOf

// 混合源构建集结

buildList, buildMap, buildSet

// 链表前端开发集结

linkedMapOf, linkedSetOf (more in stackOverflow)

// 有序集结

sorte实例化servlet类反常dMapOf, sortedSetOf (实例化需求more in stackOverflow)

// 哈希集结

hashMapOf, ha前端和后端哪个工资高shSetOf (more in stackOverflow)

// 运用代码逻辑创立集结

List, MutableList,Iterable

Cr实例化eation Copy — 复制集结

co前端pyInto // 将数组或其子规划复制到方针数组中并回来方针数组

copyOfR链表是选用链式存储结构的线性表ange // 部分复制

copyOf // 完全复制

toCollection // 复制到集结

Creation Catch — 相似 try-catch 的方法创立集结

ifEmpty // 若为空则赋予默认值

orEmpty /实例化目标/ 若为 null 则赋予空值

requireNoNulls // 若某个元素为 null 则程序崩溃

listOfNotNull // 运用传入参数中悉数非 null 元素组成列表

Conversion

Conversion 类别下的函数首要用于将集结的类型更改为另一种类型。

咱们能够对 Conversion 类别进行进一步的细分，以便咱们更快的查找函数。

1. Conversion Copy — 转化为另一种类型的新集结
2. Co链表c语言nversion Cite — 转化为另一种类型的原集结引证

一个很好的比方就是 toIntArray (Copy)github是干什么的 和 asIntArray (Cite)：

// to实例化目标有几种方法IntArray example (a new copy)
val uIntArray = UIntArray(3) { 1U }
val toapproachIntArappointmentray = uIntArray.toIntArray()toIntArray[1] = 2
println(toIntArray.toList()实例化目标有几种方法)  // [1, 2, 1]
println(uIntArray.toList())   /github是干什么的/ [1, 1, 1]// asIntArray example (a reference copy)
val uIntArray = UIntArray(3) { 1U }
val asIntArr链表反转ay = uIntArray.asIntArray()
asIntArray[1] = 2
println(asIntArray.tGitoList())  // [1, 2, 1]
println(uIntArray.toList())   // [1, 2, 1]

Conversion C前端opy — 转化为另一种类型的新集结

// 转化为数组类型

toBooleanArray, toByteArray, toCharArray, toDoubleArray, toFloatArray, toIntArrayapp是什么意思, toLongArray, toShortArray, toTypedArray, toUByteArray, toUIntArray, toULongArray, to实例化需求UShortArray

// 转化为只读appearance集结

toList, toMap, toSet

// 转化为可变集结

toMu实例化类tableList, toMutableMap, toMutableSet, toHashSet

// 转化为有序集结

toSortedMap, toSortedSet

// 转 Entries 为 Pair

toPair

toPair 能够将 map 的 entry 转化为 Pair。示例代码如下：

m前端工程师ap.entries.map { it.toPair() }
// This is essentially 
map.t实例化oList()
// Underlying `toList` of Map, it is using `toPair()`
// to do all the conversion of entries to Pair

// 转 Map 为 Properties

toProperties

toProperties 能够将 Map 转化成 Properties（Java原生类），它是Map<String, String>的子类。

val map = mapOf("x" to "value A", "y" to "valu实例化数组e B")
val props = map.toProperties()
pr实例化intln(props.getProperty("x"))         // vgithub是干什么的alue A
println(props.getProperty("z"))         // null
println(props.getProperty("y", "fail")) // value B
println(props.getProperty("z", "fail")) // fail
println(map.get("x"))                   // value实例化目标的关键字 A
printlgiteen(map.get("z"))前端                   // n前端开发ull
println(map.getOrDefault("y", "fail"))  // value B
println(map.getOrDefault("z", "fail"))  // fail

Congit指令version Cite — 转化为另一种类型的原集结引证

// 作为数组类型

asByteArray, asInt前端学什么Array, asLongArray, asShortArray, asUByteArray, asUIntArray, asULongArray, asUShortArrappearay,

// 作为集结类型. 关于 list 和 seqapplicationuestion, 请转阅 此文

asIterable, asList, asSequence

// 转为带索引的迭代器

withIn前端和后端的差异dex

withIndex 能够将 List 转化为 IndexedValue iterable （带索引的 iterable ）

val list = listOf("A", "B", "C")
val ind前端开发需求学什么exed = list.withIndex()
println(list)  // [A, B, C]
println(indexed.toList())
// [IndexedValue(index=0, value=A), 
//  IndexedValue(index=1, value=B), 
//  IndexedValue(index=2, value=C)]

// 转为带自定义前端工程师默认值的 Map

withDefault

withDefault 能够将 Map 转化成带自定义默认值的 Map

val map = mutableMapOf前端学什么(1 to 1)
// customize defaappearanceult value return x 2 of key
val default = map.withDefault { k -> k * 2 }
println(defaultgithub.getValue(10)) // return 20
printlnapplication(map.getValue(10))     // crash as no key 10

Change

Change 类别下的函数首要用于改动集结内容或许github永久回家地址集结的结构。对其进行进一步的细分：

1. ChGitange Content (改动内容)：改动集结类型和元素类型，只改动集结的内容。例如 filter函数。

2. Change Co实例化ntour (改动结构)：改动集结类型（例如，List 实行 groupBy 函数会输出 Map 类型）或更改元素链表与数组的存储结构有什么不同类型（例如， chunked 函数会把元素github类型从 Int 转变为 List<Int>）

Chgitiange-Content — 只改内容不改结构

改动内容有两种状况：

• 创立一个新的集结且改动内容并回来
• 改动原集结且不回来任何内容

看链表排序一个简略的示例，add 和 plugithub永久回家地址s

val list = listOf(1)
val mutableList = mutableListOf(1)
println(list)          // [1]
println(mutableList)   // [1]
val newList = list.plus(2)
mutableList.add(2giti轮胎)
println(list)          // [1]
println(newList)       // [1, 2]
println(mutablGiteList)   // [1, 2]

两前端和后端的差异个函数的目的是共同的，可是作用如上图所示，有所不同。为了差异两者，咱们用斜体标明改动原集结这一类函数，如***add***，用正常字体标明其他一类函数，如 plus 。

plus, add

看看函数列表（留神差异斜体）

// 改动内容

set, setValue //(more info in stackoverflow)

// 添加内容

plus, plusElement, //(more info in stackoverflow)
plusAssign, //(more info in stackoverflow)
add, addAll, put, putAll

/实例化/ 移除内容

minus, min链表是选用链式存储结构的线性表u链表的创立sElemgiteeent, //(moappearre info in stackoverflow)
minusAssign, //(more info in sta链表结构ckoverflow)
remove

// 从集结的头部或许尾部移除

drop, dropLast, drogiti轮胎是什么品牌pLastWhile, dropWhile,removeFirst, removeFirstOrNull, removeLast, removeLastOrNull,

// 从集结的头部或许尾部选取

take, t链表c语言akeLastWhi链表不具有的特点是le, takeL前端工程师ast, takeWhile,

//链表反转 从集结中选取

slice, sliceArray

// 仅获取不同（仅有实例化目标的关键字）值

distinct, distinctBy

// 给定两个集结实行维恩图操作

unioappreciaten, intersect, retainAll, subtract, remove链表的创立All

// 将元素转成其他一个值

map, mapTo,mapIndexed, mapIndexedTo,mapKeys, mapKeysTo, mapValues, mapValuesTo, replaceAll实例化目标, fill

// 将非 null 元素转成其他一个值以确保作用集内无 null 值

mapNotNull, mapNotNullTo, mapIndexedNotNull, mapIndexedNotNullTo

留神：map 函数能够将 List 转化为另一种结构或许另一种元素类型，这些咱们会在后面的 Change Contour 类别中提及。

// 过滤部分内容

filter, filterI前端技能ndexed, filterIndexedTo, filterIsInstance, filterIsInstanceTo, filterKeys, filte链表rNot, filterNotNull, filterNotNullTo, filterNotTo, filterTo, filterValue实例化servlet类反常s

// 反转内容 (查阅此文以差异这几个函数的差异)

reversed,reversedArray, reverse, asReversed

// 排序

sorted, sortedArray, sortedArrayDescending, sortedArrayWith, sortedBy, sortedByDescending, sortedD链表不具有的特点是escending, sortedWiapplicationth sort, sortBy, sortByDescending, sortDescenappearding, sortWith

// 打乱内容

shuffleapproach, shuffled

// 和 fold 或许 reduce相似, 可是实行进程是每个元素逐一完毕的

scan, scanIndexed, scanReduce, scanReduceIndexed

Change Contour — 既改内前端和后端的差异容又改结构

此类函数的作用要么会改动集结类型，例如 List 到 Map ，要么会改动元素的实例化目标类型，例如List<String> 到 List<Map&g前端开发是干什么的t;。

// 分组聚合 构成 Map

aggregate, aggregateTo // (必备条件：实例化目标的关键字 groupingBy)

// Example
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
val aggregated = number实例化需求s.groupingBy { it % 3 }
.aggregate { key, accumulator: Int?, eapplicationlement, first ->
if (first) element else前端开发 accu链表mulator?.plus(element)
}
println(aggregated) // {1=12appointment, 2=15, 0=18}

// 分组计数 构成 Map

eachCount, eachCountTo //(必备条件：groupingBy前端)

// Example Code
val numbers = listOf(1, 2, 3, 4, 5, 6gitee, 7, 8, 9)
val eachCount = numbers.groupingitigBy { it % 2 }.ea实例化一个类chCount()
println(eachCount) // {1=5, 0=4}

// 运用 Map key 链接每个元素

associate, associateBy, assgitiociateByTo, associateTo, associateWi前端结构th前端结构, associateWithTo //(查阅 此文 以了解它们的差异)

// Example code
val list = listOf(1, 2, 3, 4, 5)
val associa前端技能te = list.associateWith {appetite it * it }
println(associate) // {1=1, 2=4, 3=9, 4=16, 5=25}

// 按规则将集结分github组构成 value 类型为 List 的 Map

groupBy, groupByTo

// Example code
val list =appear listOf(1实例化是什么意思, 2, 3, 4,前端技能 5, 6, 7, 8,github 9)
v前端开发al groupBy = list.groupBy{it % 3}
println(groupBy)

// 展平成一个列表

flatMap, flatMapTo, flatten

// Example codgit指令e
val map = mapOf(1 to listOf(1, 2github永久回家地址), 2 to listOf(2, 4))
val前端 flatMap = map.flatMap { it.value }
println(flatMap)  // [1前端开发, 2, 2, 4]
// Exampleapple code
val list = listOf(listOf(1, 2), listOf(2, 4))
val flatten = lGitist.flatten(gitlab)
println(flatten)  // [1, 2, 2, 4]

// 将元素转链表和数组的差异为另一种类型

mapappointment, mapTo, mapIndexed, mapIndexedTo, mapKeys, mapKeysTo, mapValues, mapValuesTo

// 将非 null 元素转为另一种类型以确保作用集内无 null 值
mapNotNull, mapNotNullTo, mapIgiti轮胎是什么品牌ndexedNotNull, mapIndexedNotNullTo

// Example code
val days = listOf("Monday", "Tuesday", "Wednesday", "Thursday")
val daysLength链表的创立 = days.map { it.length }
println(daysLeappearancength)

// 将元素分类到不同的列表中

chunked, partition, windowed

/giti轮胎/ Example code
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
val chunked = list.chunked(4)
val windowed = list.windowed(实例化目标是什么意思4, 3, true)
val partition = list.partitiappstoreon { it % 2 == 0 }
prgiteeint实例化servlet类反常ln(chunked)  // [[1, 2, 3, 4], [5gitlab, 6, 7, 8], [9]]
printlAPPn(windowed) // [[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9]]
println(partition)// ([2, 4, 6, 8], [1, 3,appstore 5, 7, 9])

// 将两个元素联合在一起或许革除application联合

zip, zipWithNext, unzip

// Example code
val list = listOf(1, 2, 3, 4, 5)
val list2 = listOf(6, 7, 8, 9)
val zip = list.zip(list2)
println(zip)
// Example code
val li前端工程师st = listOf(1, 2, 3, 4)
val zipWithNext = list.zipWithNext()
println(zipWithNext)
// Egiti轮胎xam前端开发需求学什么ple code
val list = listOf(1 to 2, 3 to 4, 5 to 6)
val unzip = list.unzip()
printgiti轮胎ln(unzip)

Choose

Choose 类别下的函数首要用于拜访集结中的特定元素，将其进一步细分：

1. Choose Certain — 依据固定方位拜访集结元github是干什么的素
2. Choose Clue — 依据给定条件拜访集结元素

不管怎样，作用都是集结中的元素之一。

Capp是什么意思ho前端ose Certain — 依据github中文官网网页固定方位拜访集结元素

若你觉得下面这些函数看起来很相似，则下文链接将有助于链表与数组的存储结构有什么不同你差异它们之间的差异

l链表不具有的特点是evelup.gitconnected.com/kotlin-has-…

// 首要用于 List 和 Map

get, getOrDefault, getOrEl链表结构se, getOrNulapproachl, getOrPut,get链表与数组的存储结构有什么不同Value // (more info in stackoverflow and check withDefagithubult above)

// 首要用于 Sequence 和 S前端开发et

eapp是什么意思l实例化目标的关键字ementAt, elementAtOrElse, elementAtOrNull

// 用于解构

component1, component2, component3, component4,链表排序 component5

// 随机获取

random, rappreciateandomOrNull

// 手动appetite迭代

iterator

// 获取集结中的仅有元素

single, singleOrNulgithub永久回家地址l

Choose Clue — 依据给定条件拜访集结元素

// 从第一个元素开始查找

find, first, firstOrNull

/链表的创立/ 从倒数第一个元素开始查找

findLast, last, lastOrNull

// 查找所寻元素的索引

indexOf, lastIndexOf, indexOfFirst, indexOfLast

// 在有序集结内查找

binarySearch, binarySearchBy

Conclude

Conappleclude 类别下的函数首要是依照一定的规apple则运用集结中的元素生成一个作用，将其进一步细化：

1. Conclude Choice — 判别，例如 isEmpty。
2. Conclude Compute — 核算，例如 average。
3. Conclude Combine — 吞并，例如 string, hash code。
4. Conclude Carryover — 遍历，例如giteeforEach。

Conclude Choice — 判别

// 存在性检实例化查

all, any, ngithub中文官网网页one

contains, c前端开发是干什么的ontainsAll, contain链表不具有的特点是sKey, containsValue

isEmpty, isNotEmpty, isNullOrEmpty (查阅 此文)

// 比较

contentEquals, contentDeepEquals

Conclude Compute — 核算

// 核算相关

average, count, max, maxBy, maxWith, min,链表是选用链式存储结构的线性表 minBy, minWith

sum, sumBy, s实例化servlet类反常umByDouble (double float type)

// 演绎核算 (相似于 scan)

folgiti轮胎是什么品牌d, foldIndexe实例化servlet类反常d, foldRight, foldRightIndappointmentexed, foldTgitlabo,

redu链表怎样调节长度ce, reduceIndexedgiti轮胎, reduceO实例化类r链表c语言Null, r前端结构educeRight,

reduceRightIndexed, reduceRight实例化OrNull, reduceTo

Conclude Combine — 吞并

// 生成 Hash Code

contentHashCode, contentDeepHashCode

// 生成字符串

contentToStringiti轮胎是什么品牌g, conten链表不具有的特点是tDeepToStrappetiteing, joinTo, joinToString, subarrayCont实例化需求entToString

Conclude Car实例化servlet类反常rayover — 遍历

// 尾部循环实例化是什么意思

forEach,Git forEachIndexed

// 中段循环回来集结本身 (如 side effect function)

onEach

备忘录

综上所述，收拾出悉数功用的备忘录备检，能够打印出来贴在墙上

结语

依照作者的分类，我感觉树形结构或许更适合查找，所以收拾了一份思维导图。