我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

Kotlin - 集合 Collection（List、Set）_kotlin tocollection

作者：我家小花儿 | 2024-05-16 00:56:58

踩

kotlin tocollection

一、概念

1.1 继承关系

元素不可变的集合类型：List<E>、Set<E>、Map<K,V>

元素可变的集合类型：MutableList<E>、MutableSet<E>、MutableMap<K,V>

Iterable	可以遍历元素。提供了next()、hasNext()
MutableIterable	提供了remove()
Collection	元素的通用的范性集合，提供了size、isEmpty()、contains()、containsAll()
MutableCollection	提供了add()、addAll()、remove()、removeAll()、retainAll()、clear()
List	一个范性有序的只读集合。提供了get()、indexOf()、lastIndexOf()、sunList()
MutableList	提供了set()、removeAt()
Set	一个无序并不支持重复元素的集合。
MutableSet	一个无序的集合并且不支持重复元素。
Map	一个key-value的只读集合。并且key唯一。提供了size、keys、values、entries、isEmpty()、containsKey()、containsValue()、get()、getOrDefault()、
MutableMap	提供了put()、putAll()、remove()、clear()

1.2 集合类型的协变

当一个集合赋值给另一个集合，或者可变集合与不可变集合互转的时候，如果集合类型不相同，子类可以赋值给父类。例如 List<Son> 可以赋值给 List<Father>，List<Son>可以 .toMutableList() 转为 List<Father>。

List 类型

元素是有序的，可以重复，因为该类型具备索引。

创建方式	说明
listOf (元素 / 数组)	listOf（）用于创建没有 element 的空 List
	listOf（element：T）用于创建只有一个 element 的 List
	listOf（vararg element：T）用于创建拥有多个 element 的 List
mutableListOf ()
arrayListOf ()
List()	public inline fun <T> List(size: Int, init: (index: Int) -> T): List<T> size是大小，init是每个元素的初始化。


val list1 = listOf(1,'A',"哈哈",false)        //随意类型
val list2 = listOf<String>("你","我","他")        //确定类型
val list3 = listOf(arr)        //传入数组

转换

toList ()

toMutableList ()

toSet ()

toMutableSet ()

换换为 List 集合，有序

转换为 Set 集合，去重

转换为 Mutable***元素可变集合

associate ()

associateBy ()

转换为 Map

to***Array ()

转换为基本类型数组

增删

plus (元素/数组/集合/序列)

minus (元素/数组/集合/序列)
plusElement (元素)

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]

获取

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

获取所有元素的平均值（元素之和/元素数量，仅限数值类型）

查询

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

集合中是否没有元素满足条件

子集

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，并返回子集合

排序

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

运算

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

映射（新集）

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，满足条件的在左边

遍历

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

根据函数对集合中的元素进行降序排序

Set 类型

元素是无序的，不可以重复(任意两个元素 hashCode() 和 equals() 都不相等)，存入和取出的顺序不一定相同。

创建方式	举例 / 说明
setOf ()	实际上使用的是LinkedHashSet构造函数当元素格式 N<3，初始容量为 N+1 当元素个数 N<最大值/2+1，初始容量为 N+N/3 否则初始容量为 2147483647
mutableSetOf ()
hashSetOf () linkedSetOf ()5 sortedSetOf ()	HashSet LinkedHashSet TreeSet
emptySet ()	val empty = emptySet<Int>() empty.size //0 empty.isEmpty() //true empty.hashCode() //0


val ss = mutableSetOf (1,3,5,7 )
ss + 9        // [1,3,5,7,9]
ss - listOf (1,3)        // [5,7]

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/575915