文章目录
- 一、List 创建与元素获取
- 二、安全获取集合元素
- 三、List 创建与元素获取代码示例
- 四、MutableList 可变列表集合
- 五、修改 MutableList 集合的 mutator 函数
- 六、List 集合遍历
- 七、List 通过解构一次性给多个元素赋值
- 八、Set 集合
- 九、可变 Set 集合
- 十、List 与 Set 之间相互转换
- 十一、数组类型
- 十二、Map 集合
- 十三、获取 Map 值
- 十四、Map 遍历
- 十五、可变 Map 集合
一、List 创建与元素获取
Kotlin 中的集合分为两类 , 只读集合 和 可变集合 ;
调用 listOf 函数 , 可以 直接创建 List 集合 ;
通过 [] 下标可以 直接获取 List 集合中的元素 ;
fun main() { val list = listOf("Tom", "Jerry") println("${list[0]}")}上述代码执行结果 :
Tom二、安全获取集合元素
除了使用 [] 下标获取 List 集合元素外 , Kotlin 还提供了 安全获取集合元素的 方法 : getOrElse 和 getOrNull 函数 ;
1、getOrElse 函数
List
@kotlin.internal.InlineOnlypublic inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T { return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)}参数分析 : 在该函数中 , 传入了两个参数 , 第一个参数是元素的索引 , 第二个参数是一个 Lambda 表达式 ; 该 Lambda 表达式的 Int 类型参数就是 index: Int 参数 ;
返回值分析 : 返回给定[index]处的元素，如果[index]不在列表范围内，则 返回调用[defaultValue]函数的结果。
2、getOrNull函数
List
public fun <T> List<T>.getOrNull(index: Int): T? { return if (index >= 0 && index <= lastIndex) get(index) else null}参数分析 : 在该函数中 , 传入函数索引参数 ;
返回值分析 : 返回给定[index]处的元素，如果[index]不在列表范围内，则返回’ null '。
三、List 创建与元素获取代码示例
代码示例 :
fun main() { var list = listOf("Tom", "Jerry") println("${list[0]}") println(list.getOrElse(2, {"UnKnown"})) println(list.getOrNull(3))}执行结果 :
TomUnKnownnull
四、MutableList 可变列表集合
使用 listOf 函数 创建的 List 集合 是 只读列表集合 ;
使用 mutableListOf 函数 创建的 MutableList 集合 是 可变列表集合 ;
调用 MutableList#toList 函数 , 可以 将 可变列表集合 转为 只读列表集合 ;
调用 List#toMutableList 函数 , 可以 将 只读列表集合 转为 可变列表集合 ;
代码示例 :
fun main() { // 创建可变列表集合 var mutableList = mutableListOf("Tom", "Jerry") // 添加元素 mutableList.add("Jack") // 删除元素 mutableList.remove("Tom") println(mutableList) // 将 可变列表集合 转为 只读列表集合 val list: List<String> = mutableList.toList() // 将 只读列表集合 转为 可变列表集合 val mutable: MutableList<String> = list.toMutableList()}执行结果 :
[Jerry, Jack]五、修改 MutableList 集合的 mutator 函数
修改 MutableList 集合 的 函数 统称为 mutator 函数 ;
1、添加元素运算符 += 和 删除元素运算符 -=
运算符重载 : MutableList 集合 还有一些 运算符重载 , 添加元素运算符 += 和 删除元素运算符 -= ;
- 向 MutableList 集合 中添加一些元素 , 可使用 += 运算符 :
mutableList += "Jack"其效果等同于
mutableList.add("Jack")- 从 MutableList 集合 中删除一些元素 , 可使用 -= 运算符 :
mutableList -= "Tom"其效果等同于
mutableList.remove("Tom")2、通过 Lambda 表达式筛选要删除的元素
通过 Lambda 表达式筛选要删除的元素 : Lambda 表达式返回 boolean 值 , 如果返回 true , 则删除该元素 , 返回 false 则不处理该元素 ;
fun main() { // 创建可变列表集合 val mutableList = mutableListOf("Tom", "Jerry") // 通过 Lambda 表达式筛选要操作的元素 // 删除包含 字母 T 的元素 mutableList.removeIf { it.contains("T") } println(mutableList)}执行结果 :
[Jerry]六、List 集合遍历
List 集合遍历 :
- for in 循环遍历 :
// 使用 for in 循环遍历 for (name in list) { println("for : $name") }- forEach 遍历 :
@kotlin.internal.HidesMemberspublic inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit { for (element in this) action(element)}- forEachIndexed 遍历并同时获取索引值 :
public inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit): Unit { var index = 0 for (item in this) action(checkIndexOverflow(index++), item)}代码示例 :
fun main() { // 创建可变列表集合 val list = listOf("Tom", "Jerry", "Jack") // 使用 for in 循环遍历 for (name in list) { println("for : $name") } // 使用 forEach 遍历 list.forEach { println("forEach : $it") } // 遍历时获取索引位置 list.forEachIndexed { index, s -> println("$index : $s") }}执行结果 :
for : Tomfor : Jerryfor : JackforEach : TomforEach : JerryforEach : Jack0 : Tom1 : Jerry2 : Jack七、List 通过解构一次性给多个元素赋值
List 通过解构一次性给多个元素赋值 :
fun main() { // 创建可变列表集合 val list = listOf("Tom", "Jerry", "Jack") // 使用 list 集合一次性给 3 个元素赋值 val (name1, name2, name3) = list println("name1 = $name1") println("name2 = $name2") println("name3 = $name3")}执行结果 :
name1 = Tomname2 = Jerryname3 = Jack如果集合中有 3 个元素 , 但是只需要给 2 个元素赋值 , 这里可使用 _ 跳过某个元素的赋值 ;
代码示例 :
fun main() { // 创建可变列表集合 val list = listOf("Tom", "Jerry", "Jack") // 使用 list 集合一次性给 2 个元素赋值, 第 1 个元素跳过 val (name1, _, name3) = list println("name1 = $name1") println("name3 = $name3")}执行结果 :
name1 = Tomname3 = Jack八、Set 集合
List 集合中的元素是 可以重复 的 , Set 集合中的元素 不可重复 ;
调用 setOf 函数 , 可以创建 Set 集合 ;
调用 Set#elementAt 函数 , 可以 读取 Set 集合中的元素 ;
代码示例 :
fun main() { val set = setOf("Tom", "Jerry", "Jack") println(set.elementAt(1))}执行结果 :
Jerry九、可变 Set 集合
调用 mutableSetOf 函数 , 可以创建 可变 Set 集合 ;
可变 Set 集合 , 可以
- 使用
+=运算符 添加元素 , - 使用
-=运算符删除元素 ;
代码示例 :
fun main() { val mutableSet = mutableSetOf("Tom", "Jerry", "Jack") mutableSet += "Bill" mutableSet -= "Jerry" println(mutableSet) println(mutableSet.elementAt(2))}执行结果 :
[Tom, Jack, Bill]Bill十、List 与 Set 之间相互转换
调用 List#toSet() 函数 , 可以将 List 集合转为 Set 集合 , 转换过程中会 自动删除重复的元素 ;
调用 List#distinct() 函数 , 可以去除重复元素 ;
调用 Set#toList() 函数 , 可以将 Set 集合转为 List 集合 ;
代码示例 :
fun main() { val list = listOf("Tom", "Jerry", "Jack", "Tom", "Jerry", "Jack") println(list) println(list.distinct()) val list2 = listOf("Tom", "Jerry", "Jack", "Tom", "Jerry", "Jack") val set = list2.toSet() println(set)}执行结果 :
[Tom, Jerry, Jack, Tom, Jerry, Jack][Tom, Jerry, Jack][Tom, Jerry, Jack]十一、数组类型
数组类型 :
- Int 类型数组 : IntArray 数组类型 , 使用 intArrayOf 函数创建 ;
- Double 类型数组 : DoubleArray 数组类型 , 使用 doubleArrayOf 函数创建 ;
- Long 类型数组 : LongArray 数组类型 , 使用 longArrayOf 函数创建 ;
- Short 类型数组 : ShortArray 数组类型 , 使用 shortArrayOf 函数创建 ;
- Byte 类型数组 : ByteArray 数组类型 , 使用 byteArrayOf 函数创建 ;
- Float 类型数组 : FloatArray 数组类型 , 使用 floatArrayOf 函数创建 ;
- Boolean 类型数组 : BooleanArray 数组类型 , 使用 booleanArrayOf 函数创建 ;
- 普通对象类型数组 : Array 数组类型 , 使用 arrayOf 函数创建 ;
代码示例 :
fun main() { var intArray = intArrayOf(0, 1, 2, 3) var doubleArray = doubleArrayOf(0.1, 0.2, 0.3) var longArray = longArrayOf(0, 1, 2, 3) var shortArray = shortArrayOf(0, 1, 2, 3)}十二、Map 集合
调用 mapOf 函数 创建 Map 集合 , 键值对 元素有两种初始化方式 :
- 使用 to 函数进行初始化 : 在参数中使用
键 to 值的方式进行初始化 ; - 使用 Pair 对象进行初始化 : 传入
Pair(键, 值)进行初始化 ;
to 函数原型如下 , 其本质也是返回 Pair 类型的实例对象 ;
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)代码示例 :
fun main() { val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20) println(map) val map2 = mapOf(Pair("Tom", 18), Pair("Jerry", 12), Pair("Jack", 20)) println(map2)}执行结果 :
{Tom=18, Jerry=12, Jack=20}{Tom=18, Jerry=12, Jack=20}十三、获取 Map 值
获取 Map 值 :
- 使用 取值运算符
[]获取 Map 集合中的值 , 运算符中传入 键 , 如果找不到 键 对应的 值 , 返回 null ; - 使用 Map#getValue 函数 , 获取 键 对应的 值 , 如果没有找到则抛出异常 ;
public fun <K, V> Map<K, V>.getValue(key: K): V = getOrImplicitDefault(key)- 使用 Map#getOrElse 函数 , 获取 键 对应的 值 , 如果没有找到则返回 Lambda 表达式 参数 的返回值 ;
public inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V = get(key) ?: defaultValue()- 使用 Map#getOrDefault 函数 , 获取 键 对应的 值 , 如果没有找到则返回默认值 ;
public fun getOrDefault(key: K, defaultValue: @UnsafeVariance V): V { // See default implementation in JDK sources throw NotImplementedError() }代码示例 :
fun main() { val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20) println(map) val map2 = mapOf(Pair("Tom", 18), Pair("Jerry", 12), Pair("Jack", 20)) println(map2) // 使用 取值运算符 `[]` 获取 Map 集合中的值 , 运算符中传入 键 , 如果找不到 键 对应的 值 , 返回 null println(map["Tom"]) // 使用 Map#getValue 函数 , 获取 键 对应的 值 , 如果没有找到则抛出异常 println(map.getValue("Tom")) // 使用 Map#getOrElse 函数 , 获取 键 对应的 值 , 如果没有找到则返回 Lambda 表达式 参数 的返回值 println(map.getOrElse("Tim", {20})) // 使用 Map#getOrDefault 函数 , 获取 键 对应的 值 , 如果没有找到则返回默认值 println(map.getOrDefault("Tim", 88))}执行结果 :
{Tom=18, Jerry=12, Jack=20}{Tom=18, Jerry=12, Jack=20}18182088十四、Map 遍历
Map 遍历方式 :
- forEach 函数 , 传入 Lambda 表达式参数 , 该 Lambda 表达式的参数为
Map.Entry类型 ;
public inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit): Unit { for (element in this) action(element)}- forEach 函数 , 传入 Lambda 表达式参数 , 该 Lambda 表达式的 两个参数为 实际的 键值对 的类型 ;
default void forEach(BiConsumer<? super K, ? super V> action) { Objects.requireNonNull(action); for (Map.Entry<K, V> entry : entrySet()) { K k; V v; try { k = entry.getKey(); v = entry.getValue(); } catch(IllegalStateException ise) { // this usually means the entry is no longer in the map. throw new ConcurrentModificationException(ise); } action.accept(k, v); } }代码示例 :
fun main() { val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20) println(map) map.forEach { // 可操作 Entry 对象 println("${it.key} = ${it.value}") } map.forEach { key: String, value: Int -> // 可获取具体的键和值 println("$key = $value") }}执行结果 :
{Tom=18, Jerry=12, Jack=20}Tom = 18Jerry = 12Jack = 20Tom = 18Jerry = 12Jack = 20十五、可变 Map 集合
通过调用 mutableMapOf 函数 , 可创建 可变 Map 集合 ;
代码示例 :
fun main() { val mutableMap = mutableMapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20) println(mutableMap) // 增加元素 mutableMap += "Rose" to 18 mutableMap.put("Tim", 21) println(mutableMap) // 查询是否有 某个键 对应的值, 如果没有则添加一个默认值进去 mutableMap.getOrPut("Kate", {19} ) println(mutableMap)}执行结果 :
{Tom=18, Jerry=12, Jack=20}{Tom=18, Jerry=12, Jack=20, Rose=18, Tim=21}{Tom=18, Jerry=12, Jack=20, Rose=18, Tim=21, Kate=19}来源地址：https://blog.csdn.net/han1202012/article/details/128717667
