Kotlin 的Set
分为 可变的 和 不可变的 两种
声明和创建 Set
-
setOf(): Set<T>
该函数返回不可变的Set
集合,按添加顺序(Kotlin 1.1 返回的是LinkHashSet
) -
mutableSetOf(): MutableSet<T>
该函数返回可变的Set
集合,按添加顺序(Kotlin 1.1 返回的是LinkHashSet
) -
hashSetOf(): HashSet<T>
该函数返回可变的HashSet
集合,不保证顺序 -
linkedSetOf(): LinkedHashSet<T>
该函数返回可变的LinkedHashSet
集合,按添加顺序 -
sortedSetOf(): TreeSet<T>
该函数返回可变的TreeSet
集合,按从小到大顺序
val set = setOf("Java", "Kotlin", "Go")
// 按添加顺序
println(set) //[Java, Kotlin, Go]
println("setOf() 返回的对象实例是:${set.javaClass}") //setOf() 返回的对象实例是:class java.util.LinkedHashSet
val mutableSet = mutableSetOf("Java", "Kotlin", "Go")
// 按添加顺序
println(mutableSet) //[Java, Kotlin, Go]
println("mutableSetOf() 返回的对象实例是:${mutableSet.javaClass}") //mutableSetOf() 返回的对象实例是:class java.util.LinkedHashSet
val hashSet = hashSetOf("Java", "Kotlin", "Go")
// 不保证顺序
println(hashSet) //[Go, Java, Kotlin]
println("hashSetOf() 返回的对象实例是:${hashSet.javaClass}") //hashSetOf() 返回的对象实例是:class java.util.HashSet
val linkedHashSet = linkedSetOf("Java", "Kotlin", "Go")
// 按添加顺序
println(linkedHashSet) //[Java, Kotlin, Go]
println("linkedSetOf() 返回的对象实例是:${linkedHashSet.javaClass}") //linkedSetOf() 返回的对象实例是:class java.util.LinkedHashSet
val treeSet = sortedSetOf("Java", "Kotlin", "Go")
// 按从小到大顺序
println(treeSet) //[Go, Java, Kotlin]
println("sortedSetOf() 返回的对象实例是:${treeSet.javaClass}") //sortedSetOf() 返回的对象实例是:class java.util.TreeSet
注意:如果期望使用
LinkedHashSet
的话,最好使用linkedSetOf()
,而不要使用setOf()
和mutableSetOf()
,以免 Kotlin 底层修改逻辑导致程序出现bug
使用 Set 中的方法
-
set.all { ... }: Boolean
如果所有的元素都满足给定的条件,则返回 true -
set.any { ... }: Boolean
如果至少有一个元素满足给定的条件,则返回 true -
set.associateBy { ... }: Map<K, T>
以 Lambda 表达式的值为 key(K),集合元素的值为 value(T),组成 map 集合 -
(T in set): Boolean
/(T !in set): Boolean
由于有 contains() 方法,所以可以使用 in 、!in -
set.drop(n: Int): List<T>
删除 Set 集合前面 n 个元素,返回 List 集合 -
set.filter { ... }: List<T>
对 Set 集合中的元素进行过滤,返回 List 集合 -
set.find { ... }: T?
查找 Set 中满足条件的第一个元素,若未找到,返回 null -
set.fold(initial: R, operation: (acc: R, T) -> R): R
从 [initial] 值开始累加值,然后从左到右对当前累加器值和每个元素进行运算
acc:当前累加器值;s:当前元素值,若 set 为空,return initial -
set.indexOf(element: T): Int
返回集合元素 T 在 Set 中的索引 -
set.map(transform: (T) -> R): List<R>
将每个集合元素 T 映射成新值 R,返回所有新值组成的 List 集合 -
set.max(): T?
/set.min(): T?
获取最大/最小值 -
set.reversed(): List<T>
翻转集合顺序,返回 List 集合 -
(set intersect bSet): Set<T>
/(set union bSet): Set<T>
/(set + bSet): Set<T>
/(set - bSet): Set<T>
计算两个集合的交集(由于 intersect 方法被 infix 修饰,所以能以运算符的方式进行调用)
计算两个集合的并集(由于 union 方法被 infix 修饰,所以能以运算符的方式进行调用)
两个集合相加,相当于并集(由于 Set 提供了 operate 修饰的 plus 方法,因此可以使用 "+" 运算符操作集合)
两个集合相减,减去他们的公共元素(由于 Set 提供了 operate 修饰的 minus 方法,因此可以使用 "-" 运算符操作集合)
// set.all 如果所有的元素都满足给定的条件,则返回 true
println(set.all { it.length > 4 }) //false
// set.any 如果至少有一个元素满足给定的条件,则返回 true
println(set.any { it.length > 4 }) //true
// 以 Lambda 表达式的值为 key,集合元素的值为 value,组成 map 集合
val map = set.associateBy { "$it 书籍" }
println(map) //{Java 书籍=Java, Kotlin 书籍=Kotlin, Go 书籍=Go}
// 由于有 contains() 方法,所以可以使用 in 、!in
println("Java" in set) //true
println("Go" !in set) //false
// 返回删除 Set 集合前面2个元素后的集合
println(set.drop(2)) //[Go]
// 对 Set 集合中的元素进行过滤,包含 "li" 的元素
println(set.filter { "li" in it }) //[Kotlin]
// 查找 Set 中满足条件的第一个元素,若未找到,返回 null
println(set.find { "li" in it }) //Kotlin
println(set.find { "gang" in it }) //null
// 从 [initial] 值开始累加值,然后从左到右对当前累加器值和每个元素进行运算
// acc:当前累加器值;s:当前元素值,若 set 为空,return initial
println(set.fold("", {acc, s -> acc + s })) //JavaKotlinGo
// 返回集合元素在 Set 中的索引
println(set.indexOf("Go")) //2
// 将每个集合元素映射成新值,返回所有新值组成的 List 集合
println(set.map { "$it 书籍" }) //[Java 书籍, Kotlin 书籍, Go 书籍]
// 获取最大/最小值
println(set.max()) //Kotlin
println(set.min()) //Go
// 翻转集合顺序
println(set.reversed()) //[Go, Kotlin, Java]
val bSet = setOf("Swift", "TypeScript", "Kotlin")
// 计算两个集合的交集(由于 intersect 方法被 infix 修饰,所以能以运算符的方式进行调用)
println(set intersect bSet) //[Kotlin]
// 计算两个集合的并集(由于 union 方法被 infix 修饰,所以能以运算符的方式进行调用)
println(set union bSet) //[Java, Kotlin, Go, Swift, TypeScript]
// 两个集合相加,相当于并集(由于 Set 提供了 operate 修饰的 plus 方法,因此可以使用 "+" 运算符操作集合)
println(set + bSet) //[Java, Kotlin, Go, Swift, TypeScript]
// 两个集合相减,减去他们的公共元素(由于 Set 提供了 operate 修饰的 minus 方法,因此可以使用 "-" 运算符操作集合)
println(set - bSet) //[Java, Go]
Set 的遍历
-
for(item in set) { ... }
for-in 遍历,遍历元素 -
for(index in set.indices) { ... }
for-in 遍历,遍历下标(由于 set 没有提供 get 方法,故需使用 elementAt 获取元素) -
for ((index, item) in set.withIndex()) { ... }
withIndex() 方法返回一个 Iterable 对象,该对象的所有元素都是 IndexedValue -
set.forEach { ... }
forEach Lambda 表达式遍历
val set = setOf("Java", "Kotlin", "Go")
// for-in 遍历,遍历元素
for (item in set) {
println(item)
}
// for-in 遍历,遍历下标(由于 set 没有提供 get 方法,故需使用 elementAt 获取元素)
for (index in set.indices) {
println(set.elementAt(index))
}
// for-in 遍历,使用 withIndex
for ((index, item) in set.withIndex()) {
println("第 $index 个元素是 $item")
}
// forEach Lambda 表达式遍历
set.forEach {
println(it)
}
可变 Set 的添加、删除和替换
-
add(element: E): Boolean
添加新元素 -
addAll(elements: Collection<E>): Boolean
批量添加新元素 -
remove(element: E): Boolean
删除指定元素 -
removeAll(elements: Collection<E>): Boolean
批量删除多个元素 -
retainAll(elements: Collection<E>): Boolean
只保留 Set 集合中与 elements 集合共有的元素 -
clear(): Unit
清空 Set 集合中的所有元素 -
setOf().iterator(): Iterator
/mutableSetOf().iterator(): MutableIterator
Set 返回 Iterator 对象,只有 hasNext() 和 next() 方法
MutableSet 返回 MutableIterator 对象,除了有 hasNext() 和 next() 方法,还有 remove() 方法
(简而言之,Kotlin 的 MutableIterator 才相当于 Java 的 Iterator)
val mutableSet = mutableSetOf("Java", "Kotlin", "Go")
// 添加新元素
mutableSet.add("Swift")
println(mutableSet) //[Java, Kotlin, Go, Swift]
println(mutableSet.size) //4
// 批量添加新元素
mutableSet.addAll(setOf("Kotlin", "TypeScript"))
println(mutableSet) //[Java, Kotlin, Go, Swift, TypeScript]
println(mutableSet.size) //5
// 删除指定元素
mutableSet.remove("Java")
println(mutableSet) //[Kotlin, Go, Swift, TypeScript]
println(mutableSet.size) //4
// 批量删除多个元素
mutableSet.removeAll(setOf("Kotlin", "Go"))
println(mutableSet) //[Swift, TypeScript]
println(mutableSet.size) //2
// 只保留 Set 集合中与 elements 集合共有的元素
mutableSet.retainAll(setOf("Kotlin", "Go", "Swift"))
println(mutableSet) //[Swift]
println(mutableSet.size) //1
// 清空 Set 集合中的所有元素
mutableSet.clear()
println(mutableSet) //[]
println(mutableSet.size) //0
// iterator()
// Set 返回 Iterator 对象,只有 hasNext() 和 next() 方法
// MutableSet 返回 MutableIterator 对象,除了有 hasNext() 和 next() 方法,还有 remove() 方法
val set1 = setOf("Java", "Kotlin", "Go")
val setIterator = set1.iterator()
while (setIterator.hasNext()) {
println(setIterator.next()) //Java, Kotlin, Go
}
println(set1) //[Java, Kotlin, Go]
val mutableSet1 = mutableSetOf("Java", "Kotlin", "Go")
val mutableSetIterator = mutableSet1.iterator()
while (mutableSetIterator.hasNext()) {
println(mutableSetIterator.next()) //Java, Kotlin, Go
mutableSetIterator.remove()
}
println(mutableSet1) //[]