Skip to content
Able Blog
Home
Others
  • Home
      • 学习笔记
          • Android
            • 简历_赵思琦_Android_5年经验
                • Kotlin
                    • HandFirstKotlin程序设计
                      • 01. 快速入门
                        • 02. 基本类型和变量:关于变量
                          • 03. 函数
                            • 04. 类和对象
                              • 05. 子类和父类
                                • 06. 抽象和接口
                                  • 07. 数据类
                                    • 08. 空值和异常
                                      • 09. 集合
                                        • 1. 数组
                                          • 1.1 数组的创建
                                          • 2. 集合
                                            • 2.1 有序的集合 List
                                              • 2.2.1 List
                                                • 2.2.2 MutableList
                                                  • 2.2.3 改变元素顺序
                                                    • 2.2.4 批量操作
                                                    • 2.2 元素唯一的集合 Set
                                                      • 2.2.1 Set是如何查重的
                                                        • 2.2.2 使用复制,改变集合的功能
                                                        • 2.3 键检索集合 Map
                                                          • 2.3.1 创建并为Map赋值
                                                            • 2.3.2 key/value是否存在
                                                              • 2.3.3 转换为list
                                                                • 2.3.4 访问keys,values
                                                                  • 2.3.5 不重复的values
                                                                • 10. 泛型
                                                                  • 11. Lambda和高阶函数
                                                                    • 12. 内置高阶函数
                                                                      • 12. 协程

                                                                09. 集合

                                                                author iconAblecalendar icon2022年5月13日category icon
                                                                • Kotlin
                                                                tag icon
                                                                • 学习笔记
                                                                • 集合
                                                                word icon约 679 字

                                                                此页内容
                                                                • 1. 数组
                                                                  • 1.1 数组的创建
                                                                • 2. 集合
                                                                • 2.1 有序的集合 List
                                                                  • 2.2.1 List
                                                                  • 2.2.2 MutableList
                                                                  • 2.2.3 改变元素顺序
                                                                  • 2.2.4 批量操作
                                                                • 2.2 元素唯一的集合 Set
                                                                  • 2.2.1 Set是如何查重的
                                                                  • 2.2.2 使用复制,改变集合的功能
                                                                • 2.3 键检索集合 Map
                                                                  • 2.3.1 创建并为Map赋值
                                                                  • 2.3.2 key/value是否存在
                                                                  • 2.3.3 转换为list
                                                                  • 2.3.4 访问keys,values
                                                                  • 2.3.5 不重复的values

                                                                # 09. 集合

                                                                # 1. 数组

                                                                # 1.1 数组的创建

                                                                数组一旦创建,那么它的大小是固定的,并且无法阻止数组中的值被修改

                                                                # 1.1.1 空数组

                                                                空数组必须指定类型,否则编译器无法做出类型推导,无法知道应分配的内存大小

                                                                    val intArray: Array<Int> = arrayOf()
                                                                    val intArray: Array<Int> = arrayOf(2) //指定数组大小
                                                                    val array: Array<Serializable> = arrayOf() //存储任意类型的数组
                                                                
                                                                1
                                                                2
                                                                3

                                                                # 1.1.2 一些常用函数

                                                                    val array: Array<Int> = arrayOf()
                                                                    val newArray=array.plus(1) //复制数组并在后面增加新元素
                                                                    array.contains(1) //是否存在该元素
                                                                    val sum=array.sum()//求和
                                                                    val average=array.average()//求平均值
                                                                    val max=array.maxOrNull()//最大值
                                                                    val mix=array.minOrNull()//最小值
                                                                    array.sort()//正序
                                                                    array.reverse()//倒序
                                                                
                                                                1
                                                                2
                                                                3
                                                                4
                                                                5
                                                                6
                                                                7
                                                                8
                                                                9

                                                                # 1.1.3 创建元素为空的数组

                                                                由于指定的是初始元素为空,所以他必须设置数组长度。

                                                                    val arrayOfNulls = arrayOfNulls<Int>(2)
                                                                
                                                                1

                                                                # 2. 集合

                                                                # 2.1 有序的集合 List

                                                                list允许重复的值,并且知道索引的位置

                                                                # 2.2.1 List

                                                                不可变,不可修改存放的引用

                                                                # 2.2.2 MutableList

                                                                可被增删改,并且可按索引操作

                                                                    val list: MutableList<String> = mutableListOf()
                                                                    list.add("赵思琦")
                                                                    list.add("比尔盖茨")
                                                                    list.add("埃隆马斯克")
                                                                    list.add(1,"扎克伯格") //增加至指定位置,之后的其他元素后移
                                                                    list.removeAt(0)
                                                                    list[1] = "张三"
                                                                
                                                                1
                                                                2
                                                                3
                                                                4
                                                                5
                                                                6
                                                                7

                                                                # 2.2.3 改变元素顺序

                                                                    list.sort() //正序
                                                                    list.reverse() //倒序
                                                                    list.shuffle() //随机
                                                                
                                                                1
                                                                2
                                                                3

                                                                # 2.2.4 批量操作

                                                                    val copyMutableList = list.toMutableList() //复制为可变集合
                                                                    val copyList = list.toList() //复制为不可变集合
                                                                    list.removeAll(removeList)//批量删除
                                                                    list.addAll(saveList)//批量增加
                                                                    list.retainAll(saveList) //保留另一集合的所有元素
                                                                
                                                                1
                                                                2
                                                                3
                                                                4
                                                                5

                                                                # 2.2 元素唯一的集合 Set

                                                                set不允许重复的值

                                                                # 2.2.1 Set是如何查重的

                                                                Set存放的是Hashcode

                                                                1. 新对象与已有对象hashcode相同。 -> true进入下一步 false 添加。

                                                                2. 比对这些同样hashcode一样的值是否,来自同一个引用/是同一个对象。 -> true进入下一步 false 添加。

                                                                3. 比对同一个对象的值是否相同。 -> true 拒绝 false 添加。

                                                                # 2.2.2 使用复制,改变集合的功能

                                                                Copy ,Set为其他类型的集合,自然就可以使用其他集合的能力。

                                                                    val list  = mutableSetOf<String>("赵思琦","赵思琦") //集合里只存在一个“赵思琦”
                                                                    list.toSet()
                                                                    list.toList()
                                                                    list.toMutableList()
                                                                
                                                                1
                                                                2
                                                                3
                                                                4

                                                                # 2.3 键检索集合 Map

                                                                map不允许重复的键,但允许重复的值。

                                                                # 2.3.1 创建并为Map赋值

                                                                    val map:MutableMap<Int,String> = mutableMapOf(0 to "赵思琦",2 to "马斯克")
                                                                    map[5] = "奥里给"
                                                                
                                                                1
                                                                2

                                                                # 2.3.2 key/value是否存在

                                                                    map.containsKey(0) //存在key
                                                                    map.containsValue("马斯克") //存在value
                                                                
                                                                1
                                                                2

                                                                # 2.3.3 转换为list

                                                                    val list=map.toList()
                                                                    for (pair in list) {
                                                                        println(pair)
                                                                    }
                                                                
                                                                1
                                                                2
                                                                3
                                                                4

                                                                输出

                                                                (0, 赵思琦)
                                                                (2, 马斯克)
                                                                (5, 奥里给)
                                                                
                                                                1
                                                                2
                                                                3

                                                                # 2.3.4 访问keys,values

                                                                    map.keys
                                                                    map.values
                                                                
                                                                1
                                                                2

                                                                # 2.3.5 不重复的values

                                                                map.keys.toSet()
                                                                
                                                                1
                                                                edit icon编辑此页open in new window
                                                                上次编辑于: 2022/5/15 22:47:10
                                                                贡献者: zsqan
                                                                上一页
                                                                08. 空值和异常
                                                                下一页
                                                                10. 泛型
                                                                默认页脚
                                                                Copyright © 2022 Able