Kotlin 进阶之路2 区间与集合类型

Kotlin 进阶之路 目录

1.区间(Range)

• 一个数学上的概念，表示范围
• ClosedRange的子类，IntRange最常用
• 基本写法：

- 0..100表示[0,100]
- 0 until 100 表示[0，100)
- i in 0..100 判断i是否在区间[0,100]中

val range: IntRange = 0..1024 //[0,1024]---闭区间
val range_exclusive: IntRange = 0 until 30 //[0,30)---半闭区间
val emptyRange: IntRange = 0..-1

fun main(args: Array<String>) {
    println(emptyRange.isEmpty())
    println(range.contains(100))
    println(50 in range)

    for (i in range_exclusive) {
        print("$i  ")
    }
}

true
true
true
0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  

2.数组类型

基本写法：

- val array:Array<String> = arrayOf(...)

基本类型的数组

为了避免不必要的装箱费和拆箱，基本类型的数组是定制的

Java	Kotlin
int[]	IntArray
short[]	ShortArray
long[]	LongArray
float[]	FloatArray
double[]	DoubleArray
char[]	CharArray

基本操作

- print array[i] 输出第i个元素
- array[i] = "Hello" 给第i个成员赋值
- array.length 数组的长度

val arrayOfInt: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7)
val arrayOfChar: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o', ',', 'W', 'o', 'r', 'l', 'd', '!')
val arrayOfString:Array<String> = arrayOf("你好","美女")

fun main(args: Array<String>) {
    println(arrayOfInt.size)
    for (i in arrayOfInt){
        println(i)
    }
    println(arrayOfInt.slice(2..4))

    println(arrayOfChar.joinToString())
    println(arrayOfChar.joinToString(""))

    println(arrayOfString[0])
    arrayOfString[1] ="帅哥"
    println(arrayOfString[1])

}

1
2
3
4
5
6
7
[3, 4, 5]
H, e, l, l, o, ,, W, o, r, l, d, !
Hello,World!
你好

/**
 *集合类型
 *
 * 同类型的值的组合，根据整体特性分：
 * 1.有序可重复 - Array ，索引从0开始(index,i)
 * 2.无序不重复 - set
 * 3.无序可重复 - Map ,有唯一的键(key)
 * */
fun main(args: Array<String>) {
    //Array: Array<类型> 或arrayOf(元素一、元素二、元素三，...元素三)
    var country = arrayOf("China", "Japan", "American", "Germany", "China", "China")

    for (s in country) {
        println(s)
    }
    //创建一个有默认值的数组，Array(计算,{默认值})
    println("----------------创建一个有默认值的数组----------------")
    var countryPlaceHolder = Array(5, { "Australian" })
    for (s in countryPlaceHolder) {
        println(s)
    }


    //创建1到10的数组:Array(10,{i -> i+1})
    //i代表元素的索引值，从0开始
    println("----------------创建1到10的Array数组----------------")
    var oneToTen = Array(10, { i -> i + 1 })
    for (i in oneToTen) {
        println(i)
    }
    //元素计数：count，空否:isEmpty()
    println("元素计数：" + oneToTen.count())
    println("元素是否为空：" + oneToTen.isEmpty())

    //获取其中元素：数组名{索引}，首元素：数组名.frist，尾元素：数组名.last
    //获取前5各元素的快捷方法.compoent 1到5
    println("${oneToTen.component1()},${oneToTen.component2()}")
    println("获取第三个元素" + oneToTen[2])
    println("获取最后一个元素" + oneToTen.last())

    //获取筛选重复后的数组：.distinct() 或用.toSet()转换为set。
    println("----------------获取筛选重复后的数组----------------")
    val countryNotRepeat = country.distinct()
    for (i in countryNotRepeat) {
        println(i)
    }
    println("----------------获取筛选重复后的set----------------")
    val countryNotRepeat2 = country.toSet()
    for (i in countryNotRepeat2) {
        println(i)
    }
    //切割数组：sliceArray
    println("----------------切割数组：sliceArray----------------")
    val countrySlice = country.sliceArray(2..3)
    for (s in countrySlice) {
        println(s)
    }

    //mutableList：MutableList<类型>或mutableListOf(元素1，元素2，...，元素n)
    //大小可变，类型不可变
    println("----------------新建mutableList----------------")
    var mutableCountry = mutableListOf("China", "Japan", "American", "Germany", "China", "China")

    for (s in mutableCountry) {
        println(s)
    }

    println("----------------移除首位置元素----------------")
    mutableCountry.removeAt(0)
    for (s in mutableCountry) {
        println(s)
    }



    //在末尾增加元素:add元素，添加另一个数组addAll方法
    println("----------------add添加元素----------------")
    mutableCountry.add("Korea")
    for (s in mutableCountry) {
        println(s)
    }
    val newCountry = arrayOf("Britain", "France")
    println("----------------整体添加元素----------------")
    mutableCountry.addAll(newCountry)
    for (s in mutableCountry) {
        println(s)
    }

    println("----------------移除新加的数组元素----------------")
    mutableCountry.removeAll(newCountry)
    for (s in mutableCountry) {
        println(s)
    }

    println("----------------获取筛选重复后的mutableList----------------")
    for (s in mutableCountry.distinct()) {
        println(s)
    }
}

China
Japan
American
Germany
China
China
----------------创建一个有默认值的数组----------------
Australian
Australian
Australian
Australian
Australian
----------------创建1到10的Array数组----------------
1
2
3
4
5
6
7
8
9
10
元素计数：10
元素是否为空：false
1,2
获取第三个元素3
获取最后一个元素10
----------------获取筛选重复后的数组----------------
China
Japan
American
Germany
----------------获取筛选重复后的set----------------
China
Japan
American
Germany
----------------切割数组：sliceArray----------------
American
Germany
----------------新建mutableList----------------
China
Japan
American
Germany
China
China
----------------移除首位置元素----------------
Japan
American
Germany
China
China
----------------add添加元素----------------
Japan
American
Germany
China
China
Korea
----------------整体添加元素----------------
Japan
American
Germany
China
China
Korea
Britain
France
----------------移除新加的数组元素----------------
Japan
American
Germany
China
China
Korea
----------------获取筛选重复后的mutableList----------------
Japan
American
Germany
China
Korea

3.Set集合

/**
 * 集合类型 Set:无序不重复
 * 主要方法 交差并补
 * */
fun main(args: Array<String>) {

    //Set<类型> 或 setOf(元素1，元素2，...，元素n)
    //大小不固定，元素类型不可变

    val country = setOf("Britain", "France", "China", "Japan", "American", "Germany")
    val countryAsia = setOf("China", "Japan", "Korea", "Vietnam")
    val countryPermanent = setOf("American", "China", "France", "Britain", "Russia")
    for (s in country) {
        println(s)
    }

    //元素计数：count()，空否：isEmpty()
    println("元素计数：" + country.count())

    //检查是否包含某个元素：contains，包含另一个set：containAll
    println("否包含China元素：" + country.contains("China"))

    //转换成数组：toTypedArray()
    println("----------------转换成数组：toTypedArray()----------------")
    val array = country.toTypedArray()
    for (s in array) {
        println(s)
    }
    //结合之间的运算：intersect/subtract/union/minus(补集的被操作对象无需是Set类型)
    println("----------------集合交集数据：intersect----------------")
    val interCountry = country.intersect(countryAsia)
    for (s in interCountry) {
        println(s)
    }
    println("----------------集合差集数据：subtract----------------")
    val subtractCountry = country.subtract(countryAsia)
    for (s in subtractCountry) {
        println(s)
    }
    println("----------------集合并集数据：union----------------")
    val unionCountry = country.union(countryAsia).union(countryPermanent)
    for (s in unionCountry) {
        println(s)
    }
    println("----------------集合补集数据：minus----------------")
    val minusCountry = country.minus(countryAsia)
    for (s in minusCountry) {
        println(s)
    }
    //MutableSet<类型>或mutableSetOf(元素1，元素2，...，元素n)
    //大小可变，类型不可变
    val mutableCountry = country.union(countryAsia).toMutableSet()
    println("----------------MutableSet----------------")
    for (s in mutableCountry) {
        println(s)
    }
    println("----------------MutableSet添加数据：add----------------")
    mutableCountry.add("Thailand")
    for (s in mutableCountry) {
        println(s)
    }
    println("----------------MutableSet添加集合数据：addAll----------------")
    val newCountry = setOf("Brazil","Mexico")
    mutableCountry.addAll(newCountry)
    for (s in mutableCountry) {
        println(s)
    }
    println("----------------MutableSet移除数据：remove----------------")
    //移除元素：remove，移除另一集合：removeAll
    mutableCountry.remove("Thailand")
    for (s in mutableCountry) {
        println(s)
    }
    println("----------------MutableSet移除集合数据：removeAll----------------")
    //移除集合元素：removeAll，移除另一集合：removeAll
    mutableCountry.removeAll(newCountry)

    for (s in mutableCountry) {
        println(s)
    }
}

Britain
France
China
Japan
American
Germany
元素计数：6
否包含China元素：true
----------------转换成数组：toTypedArray()----------------
Britain
France
China
Japan
American
Germany
----------------集合交集数据：intersect----------------
China
Japan
----------------集合差集数据：subtract----------------
Britain
France
American
Germany
----------------集合并集数据：union----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Russia
----------------集合补集数据：minus----------------
Britain
France
American
Germany
----------------MutableSet----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
----------------MutableSet添加数据：add----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Thailand
----------------MutableSet添加集合数据：addAll----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Thailand
Brazil
Mexico
----------------MutableSet移除数据：remove----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Brazil
Mexico
----------------MutableSet移除集合数据：removeAll----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam

4.Map集合

/**
 * 集合类型 Map ：无序可重复，类似于"字典"的意思
 *
 * */
fun main(args: Array<String>) {

    //mapOf<Key,Value>(Pair(key,value)，...)
    //显示指定类型，可防止初始化值类型的错误

    val products = mapOf<String, String>(Pair("IPhone", "6888"), Pair("Xiaomi", "3499"), Pair("Huawei", "5999"))

    //元素计数：size，空否：isEmpty
    println("元素计数：" + products.size)

    //获取某个key对应的value：get，getOrDefalt
    println("获取某个key对应的value：" + products.get("IPhone"))
    println("获取某个key对应的value，给定默认值：" + products.getOrDefault("ZTE", "0"))
    println("----------------获得map所有的key：keys----------------")
    //返回所有的key：keys，所有的value：values
    for (key in products.keys) {
        println(key)
    }
    println("----------------获得map所有的value：values----------------")
    for (value in products.values) {
        println(value)
    }

    //mutableMapOf<Key,Value>(Pair(key,value),...)
    val mutableProducts = products.toMutableMap()
    println("----------------获得map所有的value：values----------------")
    //添加或更新:下标方法 map变量名[key] = value
    mutableProducts["IPhone"]="7999"
    mutableProducts["Xiaomi"]="1999"
    for (mutableProduct in mutableProducts) {
        println("${mutableProduct.key}，"+"${mutableProduct.value}")
    }
    
    
    println("----------------移除元素:remove----------------")
    //移除元素:remove
    mutableProducts.remove("IPhone")
    for (mutableProduct in mutableProducts) {
        println("${mutableProduct.key}，"+"${mutableProduct.value}")
    }
    
    
    println("----------------添加元素:put----------------")
    //添加元素:remove
    mutableProducts.put("Samsung","6999")
    for (mutableProduct in mutableProducts) {
        println("${mutableProduct.key}，"+"${mutableProduct.value}")
    }
}

元素计数：3
获取某个key对应的value：6888
获取某个key对应的value，给定默认值：0
----------------获得map所有的key：keys----------------
IPhone
Xiaomi
Huawei
----------------获得map所有的value：values----------------
6888
3499
5999
----------------获得map所有的value：values----------------
IPhone，7999
Xiaomi，1999
Huawei，5999
----------------移除元素:remove----------------
Xiaomi，1999
Huawei，5999
----------------添加元素:put----------------
Xiaomi，1999
Huawei，5999
Samsung，6999