本文主要介绍Kotlin中集合Collection里的List和Set。阐述了集合的概念，包括继承关系、集合区别和类型协变；说明了List和Set的创建特点，如List有序可重复，Set无序不可重复；还提及了集合操作符，如转换、增删、获取等，最后提到了MutableList。
一、概念
1.1 继承关系
只读接口提供访问元素的操作，可变接口通过扩展只读接口提供变更元素的操作。
|
Iterable MutableIterable | 提供了：next()、hasNext()。 |
| 提供了：remove()。 | |
|
ListIterable MutableListIterable | 提供了：hasNext()、hasPrevious()、next()、nextIndex()、previous()、previousIndex()。 |
| 提供了：add()、remove()、set()。 | |
|
Collection MutableCollection | 提供了：size、isEmpty()、contains()、containsAll()。 |
| 提供了：add()、addAll()、remove()、removeAll()、retainAll()、clear()。 | |
|
List MutableList | 提供了：get()、indexOf()、lastIndexOf()、sunList()。 |
| 提供了：set()、removeAt()。 | |
|
Set MutableSet | 无。 |
|
Map MutableMap | 提供了：entries、keys、values、containsKey()、containsValue()、get()、getOrDefault()、isEmpty()。 |
| 提供了：clear()、put()、putAll()、remove()。 |
1.2 集合区别
| 元素不可变（只读） | 元素可变（增删改） | |
| 有序（有索引，元素可以重复） | List<E> | MutableList<E> |
| 无序（无索引，元素不可重复） | Set<E> | MutableSet<E> |
| 键值对（key具有唯一性） | Map<K, V> | MutableMap<K, V> |
1.3 集合类型的协变
当一个集合赋值给另一个集合，或者可变集合与不可变集合互转的时候，如果集合类型不相同，子类可以赋值给父类。例如 List<Son> 可以赋值给 List<Father>，List<Son>可以 .toMutableList() 转为 List<Father>。
二、创建
2.1 List
元素是有序的，可以重复，因为该类型具备索引。底层使用的是ArrayList。
|
由元素构造 |
public inline fun <T> listOf(): List<T> = emptyList() public inline fun <T> mutableListOf(): MutableList<T> = ArrayList() 创建空集合。 |
|
public fun <T> listOf(vararg elements: T): List<T> public fun <T> mutableListOf(vararg elements: T): MutableList<T> 通过指定元素创建集合。 | |
| 空集合 |
public fun <T> emptyList(): List<T> 创建空List。 |
|
工厂函数 |
public inline fun <T> List(size: Int, init: (index: Int) -> T): List<T> public inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T> 参数size是指定大小， 参数init是每个元素的初始化方式。 |
| 构建器函数 |
public inline fun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E> public inline fun <E> buildList(capacity: Int, @BuilderInference builderAction: MutableList<E>.() -> Unit): List<E> 参数initialCapacity是指定大小，参数builderAction是每个元素的初始化方式。作用域中调用的是 MutableList 的方法，最后返回的是一个 List。 |
| 具体类型的集合 |
public inline fun <T> arrayListOf(): ArrayList<T> = ArrayList() Kotlin有自己包装过的ArrayList（不推荐，Kotlin的List底层就是由它实现的）。 |
|
public LinkedList() 通过 Java 构造函数创建 LinkedList。 | |
| 避免装箱开销 |
public fun intListOf(): IntList = EmptyIntList public inline fun mutableIntListOf(): MutableIntList = MutableIntList() public fun emptyIntList(): IntList = EmptyIntList 空集合。 通过指定元素创建集合。 构建器函数。 非线程安全，且遍历中修改可能引发问题，总之别用就行。同理还有 Long、Double、Float。 |
val list1 = listOf(1,"哈哈",false) //自动类型推断
val list2 = listOf<String>("你","我","他") //声明确定类型
val list3 = buildList {
add(1)
add(2)
add(3)
}
val linkedList1 = LinkedList<Int>(listOf(1,2,3)) //类型是 LinkedList<Int>
val linkedList2 = LinkedList(listOf(1,2,3)) //类型是 LinkedList<Int!>
2.2 Set
元素是无序的，不可以重复(任意两个元素 hashCode() 和 equals() 都不相等)，存入和取出的顺序不一定相同。底层使用的是LinkedHashSet，当元素个数 N<3，初始容量为 N+1当元素个数 N<最大值/2+1，初始容量为 N+N/3，否则初始容量为 2147483647。
| 由元素构造 |
public inline fun <T> setOf(): Set<T> = emptySet() public inline fun <T> mutableSetOf(): MutableSet<T> = LinkedHashSet() 创建空集合。 |
| 空集合 |
public fun <T> emptySet(): Set<T> = EmptySet 创建空Set。 |
| 构建器函数 | public inline fun <E> buildSet(@BuilderInference builderAction: MutableSet<E>.() -> Unit): Set<E> public inline fun <E> buildSet(capacity: Int, @BuilderInference builderAction: MutableSet<E>.() -> Unit): Set<E> |
| 具体类型的集合 | public inline fun <T> linkedSetOf(): LinkedHashSet<T> = LinkedHashSet() public fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T> |
| public inline fun <T> hashSetOf(): HashSet<T> = HashSet() public fun <T> hashSetOf(vararg elements: T): HashSet<T> | |
| public fun <T> sortedSetOf(vararg elements: T): java.util.TreeSet<T> public fun <T> sortedSetOf(comparator: Comparator<in T>, vararg elements: T): java.util.TreeSet<T> |
val ss = mutableSetOf (1,3,5,7 )
ss + 9 // [1,3,5,7,9]
ss - listOf (1,3) // [5,7]
三、操作符
3.1 转换
|
toList () toMutableList () toSet () toMutableSet () |
换换为 List 集合，有序 转换为 Set 集合，去重 转换为 Mutable***元素可变集合 |
|
associate () associateBy () |
转换为 Map |
| to***Array () | 转换为基本类型数组 |
3.2 增删
|
plus (元素/数组/集合/序列) minus (元素/数组/集合/序列) numusElement (元素) |
plus（T）：List<T> plus（Iterable<T>）：List<T> plus（Array<out T>）：List<T> plus（Sequence<T>）：List<T> 往集合中添加一个元素/数组/集合/序列，返回一个新集合不会修改原集合，推荐使用操作符 “+” |
|
minus（T）：List<T> minus（Iterable<T>）：List<T> minus（Array<out T>）：List<T> minus（Sequence<T>）：List<T> 往集合中删除一个元素/数组/集合/序列，返回一个新集合，推荐使用操作符 “-” | |
|
plusElement（T）：List<T> 同上，底层使用的 plus(T) | |
|
minusElement（T）：List<T> 同上，底层使用的 minus(T) |
val list1 = listOf(1,2,3)
val list2 = listOf(7,8)
val list3 = list1 + 4 //返回的是一个新集合，不会修改原集合list1，[1,2,3,4]
val list4 = list1.plus(list2)//返回的是一个新集合，不会修改原集合list1,[1,2,3,7,8]
3.3 获取
|
get (索引) getOrElse (索引，默认值) getOrNull (索引) elementAt (索引) elementAtOrElse (索引，默认值) elementAtOrNull (索引) |
get（Int）：T 获取该索引位置上的元素，没有则报错，推荐使用运算符 [ ] |
|
getOrElse（Int，Int -> T）：T 获取该索引位置上的元素，没有则返回默认值 | |
|
getOrNull（int）：T? 获取该索引位置上的元素，没有则返回 null | |
|
elementAt（Int）：T 获取该索引位置上的元素，没有则报错，推荐使用运算符 [ ] | |
|
elementAtOrElse（Int，Int -> T）：T 获取该索引位置上的元素，没有则返回默认值 | |
|
elementAtOrNull（Int）：T? 获取该索引位置上的元素，没有则返回 null | |
|
indexOf (元素) indexOfFrist (predicate) indexOfLast (predicate) lastIndexOf (元素) |
indexOf（T）：Int 获取该元素在List中对应的索引，没有则返回-1 |
|
indexOfFrist（T -> Boolean）：Int 获取第一个符合条件的元素索引，没有则返回-1 | |
|
indexOfLast（T -> Boolean）：Int 获取最后一个符合条件的元素索引，没有则返回-1 | |
|
lastIndexOf （T）：Int 获取该元素最后一次出现的索引，没有则返回-1 | |
|
frist () frist (predicate) fristOrNull () fristOrNull (predicate) last () last (predicate) lastOrNull () lastorNull (predicate) find () findLast () |
frist（）：T 获取第一个元素，没有则报错 |
|
frist（T ->Boolean）：T 获取第一个符合条件的元素，没有则抛异常 | |
|
fristOrNull（）：T? 获取第一个元素，没有则返回 null | |
|
fristOrNull（T ->Boolean）：T? 获取符合条件的第一个元素，没有则返回 null | |
|
last（）：T 获取最后一个元素，没有则报错 | |
|
last（T -> Boolean）：T 获取最后一个符合条件的元素，没有则抛异常 | |
|
lastOrNull（）：T? 获取最后一个元素，没有则返回 null | |
|
lastOrNull（T -> Boolean）：T? 获取符合条件的最后一个元素，没有则返回 null | |
|
find（T -> Boolean）：T 同理 frist()，获取第一个符合条件的元素，没有则抛异常 | |
| 同理 lastOrNull ()，获取符合条件的最后一个元素，没有则返回 null | |
|
single () single (predicate) singleOrNull () |
single（） 集合只能且必须包含一个元素，并返回该元素，否则报错 |
|
single（T -> Boolean）：T 集合只能且必须包含一个符合条件的元素，并返回该元素，否则报错 | |
|
singOrNull（）：T? 集合只能且必须包含一个符合条件的元素，并返回该元素，否则返回 null | |
| average () |
average （）：T 获取所有元素的平均值（元素之和/元素数量，仅限数值类型） |
3.4 查询
|
count () count (predicate) |
count（）：Int 集合中元素的个数 |
|
count（T -> Boolean）：Int 集合中满足条件的元素个数 | |
|
min () minBy (function(索引)) : T max () maxBy (function(索引)) : T |
min（）：T? 返回集合中最小值的元素，空集返回 null |
|
minBy（T -> R）：T? 根据条件，返回集合中最小值的元素，空集返回 null。比较的是运算后的R，但返回的是元素T | |
|
max（）：T? 返回集合中最大值的元素，空集返回 null | |
|
maxBy（T -> R）：T? 根据条件，返回集合中最小值的元素，空集返回 null。比较的是运算后的R，但返回的是元素T | |
|
contains (元素) containsAll (集合) |
contains（T）：Boolean 集合中是否包含该元素，包含返回true |
|
contains（Collection）：Boolean 集合中是否包含该子集，包含返回true | |
|
any () any (predicate) all (predicate) none () none (predicate) |
any（）：Boolean 集合中是否至少有一个元素 |
|
any（T -> Boolean）：Boolean 集合中是否至少有一个元素满足条件 | |
|
all（T -> Boolean）：Boolean 集合中是否所有元素都满足条件 | |
|
none（）：Boolean 集合中是否没有元素 | |
|
none（T -> Boolean）：Boolean 集合中是否没有元素满足条件 |
3.5 子集
|
slice (区间) slice (集合) |
slice（IntRange）：List<T> 截取该索引区间的元素，返回一个子List |
|
slice（Iterable<Int>）：List<T> 返回一个子List，所包含的 element 是传入 Iterable 的 element 当作 index 对应的 element | |
|
distinct () distinctBy (function) | distinct（）：List<T> |
| distinctBy（T -> K）：List<T> | |
|
take (数量) takeLast (数量) takeWhile (predicate) takeLastWhile (predicate) |
take（Int）：List<T> 截取前 N 个元素，返回一个子集合，N=0返回空集，N>size返回该集合，N<0报错 |
|
takeLast（Int）：List<T> 截取后 N 个元素，返回一个子集合，N=0返回空集，N>size返回该集合，N<0报错 | |
|
takeWhile（T -> Boolean）：List<T> 正序，返回一个满足条件元素的子集合，遇到不满足条件就停止 | |
|
takeLastWhile（T -> Boolean）：List<T> 倒序，返回一个满足条件元素的子集合，遇到不满足条件就停止 | |
|
drop (数量) dropLast (数量) dropWhile (predicate) dropLastWhile (predicate) |
drop（Int）：List<T> 去除前 N 个元素，返回一个包含剩下元素的子集合，N=0返回该集合，N>size返回空集，N<0报错 |
|
dropLast（Int）：List<T> 去除后 N 个元素，返回一个包含剩下元素的子集合，N=0返回该集合，N>size返回空集，N<0报错 | |
|
dropWhile（T -> Boolean）：List<T> 正序，去除满足条件的元素，返回一个包含剩下元素的子集合，遇到不满足条件就停止 | |
|
dropLastWhile（T -> Boolean）：List<T> 倒序，去除满足条件的元素，返回一个包含剩下元素的子集合，遇到不满足条件就停止 | |
|
filter (predicate) filterIndexed (predicate(索引，元素)) filterNot (predicate) filterNotNull (predicate) filterTo (子集合，predicate) |
filter（T -> Boolean）：List<T> 返回一个包含满足条件元素的子集合 |
| 同上，多了索引可使用 | |
|
filterNot（T -> Boolean）：List<T> 返回一个包含不满足条件元素的子集合？？？？？？？ | |
|
filterNotNull（T -> Boolean）：List<T> 返回一个不包含null元素的子集合？？？？？？？ | |
|
filterTo（MutableCollection,T -> Boolean）：MutableCollection 用传入的子集合 MutableCollection 去装满足条件的 element，并返回子集合 |
3.6 排序
| reversed () |
reversed（）：List<T> 反转集合中的元素，返回一个新集合 |
|
sorted () sortedDescending () sortedBy (function) sortedDescendingBy (function(元素)) |
sorted（）：List<T> 将集合中的元素按照自然排序进行升序排列 |
|
sortedDescending（）：List<T> 将集合中的元素按照自然排序进行降序排列 | |
|
sortedBy（T -> R?）：Unit 根据函数对集合中的 element 进行计算，按结果进行升序排列，结果类型要实现Comparable | |
|
sortedDescendingBy（T -> R?）：Unit 根据函数对集合中的 element 进行计算，按结果进行降序排列，结果类型要实现Comparable |
3.7 运算
| sumBy ( 元素 -> 累加值 ) |
sumBy（T -> Int）：Int 对元素挨个进行累加计算，初始值为0 |
|
reduce ( (累加值,下一个元素) -> 累加值 ) reduceRight ( (下一个元素,累加值) -> 累加值 ) fold ( 初始值，(累加值,下一个元素) -> 累加值 ) foldRight ( 初始值, (下一个元素, 累加值) -> 累加值 ) |
reduce（ (S,T) -> S）：S 根据给定的函数，正序对元素挨个进行运算 |
|
reduceRight（ (T,S) -> S）：S 根据给定的函数，倒序对元素挨个进行运算 | |
|
fold（R，(R,T) -> R）：R 带初始值的 reduce | |
|
foldRight（R，(T,R) -> R）：R 带初始值的 reduceRight |
3.8 映射（新集）
|
map (function(元素)) mapIndexed (function(索引,元素)->新值) mapNotNull (function(元素)) flatMap (function(元素)) |
map（T -> R）：List<R> 通过函数对元素进行运算，返回一个包含运算后元素的新集合。 T元素，R运算后的值 |
|
mapIndexed（ (Int,T) -> R）：List<R> 通过函数对元素进行运算，返回一个包含运算后元素的新集合，多了一个索引可使用 | |
| 通过函数对元素进行运算，返回一个包含运算后元素的新集合，会去掉null元素 | |
|
flatMap（T -> Iterable<R>）：List<R> 区别是：如果有元素的类型是数组或集合，则拆散将每个子元素都变成元素。 | |
|
groupBy (T -> 键): Map(键, List<T>) groupBy (T -> 键,T -> 值): Map<键,值> groupBy (T -> 值): Grouping<T,值> |
groupBy（T -> K）：Map<K，list<T> > 对 element 进行运算，结果当作 key，相同结果的 element 为一组 List 当作 Value |
|
groupBy (T -> K,T -> V): Map<K,V> 对 element 进行运算，第一个运算结果当作 Key，第二个运算结果当作 Value | |
| groupBy（T -> K）： Grouping<T,K> | |
| zip (集合2): List<Pair<集合1元素, 集合2元素>> |
zip（Iterable<R>）：List<Pait<T,R>> 对两个集合进行配对，相同 index 的两个 element 存入 Pair，作为返回的新List 的 element |
| partition (predicate): Pair<List1包含所有满足条件的元素,List2包含所有不满足条件的元素> |
partition（T -> Boolean）：Pair<List<T>,List<T>> 根据条件，将集合拆成2个子集合组成的Pair，满足条件的在左边 |
3.9 遍历
| forEach (元素 -> Unit) |
forEach（T -> Unit）：Unit 遍历 |
| forEachIndexed ( (索引,元素) -> Unit ) |
forEachIndexed（ (Int,T) -> Unit）：Unit 带索引遍历，Int是索引，T是元素 |
| flatten () | 遍历集合中的元素，元素包含子元素也遍历 |
MutableList
| toList () | 转换为 List 元素不可变集合 |
|
add (元素) add (索引，元素) addAll (子集合) addAll (索引，子集合) |
add（E）：Boolean 在集合尾部添加新元素，成功则返回true |
|
add（Int，E）：Boolean 往该索引位置上插入新元素，索引不存在则报错 | |
|
addAll（Collection<E>）：Boolean 添加子集合，成功则返回true | |
|
addAll（Int，Collection<E>）：Boolean 往该索引位置上插入子集合，成功则返回true | |
|
remove (元素) removeAt (索引) removeAll (子集合) |
remove（E）：Boolean 删除集合中第一次出现的该元素，成功则返回true |
|
removeAt（Int）：E 删除该索引位置上的元素，索引不存在则报错 | |
|
removeAll（Collection<E>）：Boolean 删除子集合，成功则返回true | |
| set (索引，元素) |
set（Int，E）：E 对该索引上的元素赋值 |
| clear () |
clear（）：Unit 清空集合中的元素 |
| retainAll (另一个集合) |
retainAll（Collection<E>）：Boolean 取交集：只保留两个集合都有的元素，成功则返回true |
|
sorted() sortedBy (function(索引)) sortedByDescending (function(索引)) sortBy (function(索引)) sortByDescending (function(索引)) |
sorted（）：List<T> 对集合中的元素进行自然排序 |
|
sortedBy（T -> R）：List<T> 根据函数对集合中的元素进行升序排序，并返回一个新集合 | |
|
sortedByDescending（T -> R）：List<T> 根据函数对集合中的元素进行降序排序，并返回一个新集合 | |
|
sortBy（T -> R）：Unit 根据函数对集合中的元素进行升序排序 | |
|
sortByDescending（T -> R）：Unit 根据函数对集合中的元素进行降序排序 |
扫一扫
913
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
