疯狂Kotlin讲义学习笔记04-05章：流程控制、数组和集合

最新推荐文章于 2021-12-08 19:09:11 发布

心湖中的石子

最新推荐文章于 2021-12-08 19:09:11 发布

阅读量248

点赞数

分类专栏： Kotlin学习笔记

本文链接：https://blog.csdn.net/weixin_43745804/article/details/108545076

版权

Kotlin学习笔记专栏收录该内容

10 篇文章 1 订阅

订阅专栏

1、when分支取代swith分支

不在需要使用case关键字
case后面的冒号改为->
default改为更有意义的else
如果一个case里有多条语句，需要将多条语句用大括号括起来
when分支可以匹配多个值
when分支后面的值不要求是常量，可以是任意表达式
when分支对条件表达式的类型没有任何要求

import java.util.*

fun main() {
    var num=6;

    when(num){
        7->
        {println("今天是周日")
        print("今天可以不用去上班")}
        1,2-> println("今天是周一或周二")
        5-2-> println("今天是工作日")
        in 4..6-> println("这是在一个区间范围内")
        else-> println("不上班，也不能随意地玩耍")
    }

    var date=Date()

    when (date){
        Date()-> println("when 的判断参数可以是任意类型")
        else-> print("需要输入一个日期")
    }

}

打印
这是在一个区间范围内
when 的判断参数可以是任意类型

2、when分支处理类型判断

通过使用is，!is运算符，我们还可以使用when分支检查表达式是否为指定类型。

fun main() {
   var inputPrice=34
    realPrice(inputPrice)
}

fun realPrice(inputPrice: Any) {//这里有个Any（任意类型）
    when(inputPrice){
        is Int-> print("参数是一个整数${inputPrice.toInt()}")
        is Float->print("参数是一个浮点数${inputPrice.toFloat()}")
        is String->print("参数是一个字符串${inputPrice.toString()}")
        else -> print("我也不知道是什么类型")
    }
}

打印
参数是一个整数34

3、while，do while结构

和所有的while和do while结构一致

4、for-in循环

for(常量名 in 字符串 | 范围 |集合){
循环体
}

循环条件里的常量无需声明，无需使用let关键字
for-in循环可用于遍历任何可迭代对象。（可迭代对象指该对象包含一个Iterator（）方法，且该方法的返回值对象具有next（）、hasnext（）方法）

fun main() {
    var max=7
    var resualt=0

    for (num in 1..max){
        resualt+=num
    }
    println(resualt)
}

打印28

5、嵌套循环

没什么特别的

6、控制循环结构

break
continue
return

以上均为常规操作，同java

7、数组和集合概说

kotlin增加了一个Array类，为元素是基本类型的数组增加了XxxArray类（Xxx可以是Byte,Short,Int等），因此完全可以用面向对象的语法来使用kotlin数组，包括创建数组对象，调用数组对象的属性和方法等。
list：有序，元素可重复
set：无需，元素不可重复
Map：使用键值对的形式存储数据

8、数组

创建数组
创建数组其实就是创建Array的实例，kotlin既可以通过Array类的构造器来创建实例，也可通过arrayOf（）等工具函数来创建实例
两种方式创建

使用arrayOf（）、arrayOfNulls（）、emptyArray（）工具函数
使用Array（size：Int，init:(Int）->T）构造器

fun main() {
    var arr1= arrayOf("java","kotlin","swift","go")

    var arr2= arrayOfNulls<Int>(5)
    //使用lambada表达式初始化数组元素的数组
    var arr3=Array(5,{(it*2+97).toChar()})
    for (num in arr3){
        println(num)
    }

}

打印
a
c
e
g
i

创建数组的方式

使用arrayOf()函数：不用指定数组长度，要依次列出每个数组元素
使用arrayOfNull（）函数：需要显示指定数组长度，数组元素全部被初始化为null（实际就是类似java的动态初始化）
使用emptyArray（)函数：这种方式会创建一个长度为0的空数组，由于没有指定数组袁术，因此需要使用泛型来指定数组元素的类型
使用Array（size：Int,init:(Int)->）构造器：这种方式需要显示指定数组的长度，并可以通过lambda表达式来动态计算各数组元素的值

由于Array类要求她的元素必须是应用类型，kotlin会将基本类型的值自动装箱包装秤包装类的实例。然后再添加到Array的数组中，为此Kotlin专门提供了ByteArray，ShortArray，IntArray，LongArray，CharArray，FloatArray，DoubleArray，BooleanArray分别映射java的byte[]，short[],int[],long[],char[],float[],double[],boolean[]这8种基本类型的数组

fun main() {
    var intArray=intArrayOf(2,4,5,6)
    for (num in intArray){
        println(num)
    }

    println("-------------------")

    var intArray2= IntArray(5,{it*it})

    for (num in intArray2){
        println(num)
    }
    println("-------------------")
    var intArray3=arrayOfNulls<Int>(4);
    intArray3[0]=122;
    intArray3[1]=232;
    intArray3[2]=562;
    intArray3[3]=532;

    for (num in intArray3){
        println(num)
    }
}

打印

2
4
5
6
-------------------
0
1
4
9
16
-------------------
122
232
562
532

使用数组

使用方括号如同[]+索引的方法：同java
使用get（）+索引的方法：同集合的获取方法
所有的数组都提供了一个size属性，通过这个属性可以访问到数组的长度

fun main() {
    var intArray=intArrayOf(2,4,5,6)
    println(intArray[2])
    println(intArray.get(2))
    intArray.set(2,19)
    println(intArray.get(2))

}

打印
5
5
19

使用for-in循环遍历数组

fun main() {
    var intArray=intArrayOf(2,4,5,6)
    for (num in intArray){
        println(num)
    }
}

打印
2
4
5
6

使用数组索引
数组的indices属性，可以返回数组的索引区间。

fun main() {
    var intArray=intArrayOf(2,4,5,6)
    for (num in intArray.indices){
        println(intArray[num])
    }
}

打印
2
4
5
6

lastIndex属性返回最后一个元素的索引值（通常是size-1）

fun main() {
    var intArray=intArrayOf(2,4,5,6)
    print(intArray.lastIndex)
}

打印
3

如果需要同时访问数组的索引和元素，也可以使用数组的withIndex（）方法，该方法返回一个iterable对象，该对象的所有元素都是indexedValue.

fun main() {
    var books=arrayOf("java","swift","android","object-c")
    for ((index,value)in books.withIndex()){
        println("${index}--${value}")
    }
}

打印
0–java
1–swift
2–android
3–object-c

数组的常用方法
太多了，略

多维数组
把多为数组当作一维数组初始化，然后再多这个一维数组的元素进行数组的声明或复制

fun main() {
    //创建一个二维数组，一维是空数组，二维是整形数组
    var a= arrayOfNulls<Array<Int>>(4)
    //遍历二维数组中的每个第一维度元素
    for ( i in a.indices){
        println(a[i])//打印出4个空出来
    }
    println("--------")

    //初始化第一维度的第一个元素（整型数组）
    a[0]= arrayOf(2,5,44,5)
    for (i in a[0]!!.indices){
        println(a[0]?.get(i))
    }
    println("--------")
    a[0]?.set(1,666)//给a[0]一维数组的第2个元素的元素值设置为666
    for (i in a[0]!!.indices){
        println(a[0]!![i])
    }
    println("--------")

    a[2]= arrayOf(33,44,77,99)
    for (i in a[2]!!.indices){
        println(a[2]!![i])
    }
}

打印

null
null
null
null
--------
2
5
44
5
--------
2
666
44
5
--------
33
44
77
99

同时初始化二维数组

使用Array方式初始化二维数组

fun main() {
    var b=Array<IntArray>(3,{IntArray(4,{0})})
    for (i in b.indices){
        for (j in b[i].indices){
            print("  ${b[i][j]}")
        }
        println()
    }

}

打印
0 0 0 0
0 0 0 0
0 0 0 0

使用arrayOf方式来初始化二维数组

fun main() {
   var b= arrayOf(arrayOfNulls<String>(3), arrayOf("hello","world"))//一维为2个元素，第一个元素为包含3个空元素的数组，第二个元素为包含hello和world的数组
   b[0]= arrayOf("java","swift","android")
    for (i in b.indices){
        for (j in b[i].indices){
            print("  ${b[i][j]}")
        }
        println()
    }

}

打印
java swift android
hello world

9、集合概述

kotlin的集合类由两个接口派生：Collection 和 Map
kotlin的集合分两大类：可变集合（MutableSet，MutableList）和不可变集合（Map，List）

每个接口下都有一个抽象实现类，并只提供了HashSet，LinkedHashSet，ArrayList集合实现类
kotlin并未真正实现任何集合类，只是借用了集合框架原有的集合类。

10、声明和创建Set集合

推荐使用kotlin的工具函数来创建Set集合
setOf（）：不可变集合
mutableSet（）：可变集合
hashSet（）集合：可变的hashset集合
linkedSet（）：可变的linkedhashset集合
sortedHashset（）：可变的TreeSet集合

fun main() {
   var set =setOf("java","swift","android","object-c")
    println(set.javaClass)//打印出对应的java类型
    println("---------")

    for (str in set){//有序的集合
        println(str)
    }

    var mutableSet= mutableSetOf<String>("html","css","javascript")
    mutableSet.add("python")
    println("---------")

    for (str in mutableSet){//可变集合也是有序的
        println(str)
    }
    println("---------")

    //hashset不保证元素有序
    var myhahset= hashSetOf<String>("chinese","math","nature","english")
    for (str in myhahset){
        println(str)
    }
    println("---------")

    //linkedset集合元素按添加顺序排列
    var linkedHashSet= linkedSetOf<String>("张三","李四","王二")
    linkedHashSet.add("赵六")
    for (str in linkedHashSet){
        println(str)
    }
    println("---------")
    //集合元素又小到大的排列
    var treeSet= sortedSetOf("java","kotlin","android")
    for (str in treeSet){
        println(str)
    }
}

打印：

class java.util.LinkedHashSet
---------
java
swift
android
object-c
---------
html
css
javascript
python
---------
english
chinese
math
nature
---------
张三
李四
王二
赵六
---------
android
java
kotlin

11、使用set的方法

扩展了一些java元素，与array的使用相似度较大，直接上代码

fun main() {
   var set= setOf<String>("java","kotlin","go")
    //判断所有元素是不是都大于4
    println("判断所有元素是不是都大于4:"+set.all { it.length > 4 })//集合set的所有（all）元素，内部是lambda表达式，it是遍历器，遍历每个元素计算其长度（leng）
    //判断是否任一元素都大于4
    println("判断是否任一元素都大于4:"+set.any { it.length > 4 })
    //以lambda表达式的值为key，集合元素为value，组成map集合
    //associateBy：以集合元素生成map
    val map=set.associateBy ({"疯狂"+it+"讲义"})
    println("输出map集合："+map)
    //contains方法检测包含
    println("检测contains包含："+("java" in set))
   //返回删除set和前两个元素后的集合
    var dropedSet=set.drop(2)
    println("打印dropedSet："+dropedSet)

    var set2= setOf<String>("java","kotlin","go")
    //对元素进行过滤，通过lambda表达式设置过滤规则
    val filterSet=set2.filter { "li" in it }
    println("包含li的元素为："+filterSet)
    val foundStr=set2.find { "li" in it }//实际上函数方法是set2.find（{"li" in it}）
    println("包含li的元素为："+foundStr)
    //将集合中的所有字符拼接到一起,第一个参数为初始字符
    val longstr=set2.fold("",{acc,e ->acc +e})
    println("拼接后的文字："+longstr)
    //查找某个元素出现的位置
    println(set2.indexOf("go"))
    //将每个元素映射成新值，返回所有新值组成的set集合
    val mappedSet=set2.map { "《疯狂"+it+"讲义》" }//set2.map( { "《疯狂"+it+"讲义》" })也是对的
    println(mappedSet)
    //获取最大值，最小值
    println(set2.max())
    println(set2.min())
    //反转集合
    val reverseSet=set2.reversed()
    println(reverseSet)
    var set3= setOf("android","kotlin","swift")
    //计算两个集合的交集，并集
    println("两个元素的交集:"+(set2 intersect set3))
    println("两个元素的并集:"+(set2 union set3))
    //另一种计算交并的方法
    println("两个元素的并集:"+(set2 + set3))
    println("两个元素的交集的补集:"+(set2 - set3))

}

打印：
判断所有元素是不是都大于4:false
判断是否任一元素都大于4:true
输出map集合：{疯狂java讲义=java, 疯狂kotlin讲义=kotlin, 疯狂go讲义=go}
检测contains包含：true
打印dropedSet：[go]
包含li的元素为：[kotlin]
包含li的元素为：kotlin
拼接后的文字：javakotlingo
2
[《疯狂java讲义》, 《疯狂kotlin讲义》, 《疯狂go讲义》]
kotlin
go
[go, kotlin, java]
两个元素的交集:[kotlin]
两个元素的并集:[java, kotlin, go, android, swift]
两个元素的并集:[java, kotlin, go, android, swift]
两个元素的交集的补集:[java, go]

12、遍历set集合

使用for … in来遍历集合
但是遍历的时候无法修改集合元素，应为for in循环隐藏使用let（常量）来声明该常量
Set集合继承了Iterable，可以使用该接口的forEeach（）方法来遍历集合。该方法需要接受一个lambda表达式作为参数。
也可以使用索引号来遍历集合元素，集合有indices属性，且集合是有序的

fun main() {
   var books= setOf<String>("java","kotlin","go")
   for ( book in books ){
        println(book)
    }
    println("-----")
    books.forEach({println(it)})
    println("-----")
    for ( index in books.indices){
        println(books.elementAt(index))
    }
}

打印

java
kotlin
go
-----
java
kotlin
go
-----
java
kotlin
go

13、可变的set集合

添加元素
使用add（集合元素）和addAll（集合）
删除元素

使用remove（集合元素）
removeAll（集合）：把集合中的指定元素删除
retainAll（集合）保留和参数集合中共有的元素
clear():清空集合元素
fun main() {
   var books= mutableSetOf<String>("java","kotlin","go")
   var books2= setOf<String>("swift","android")
    var books3= setOf<String>("java","go")
    var book4= setOf<String>("android","python")
   books.add("swift")
    for (str in books){
        println(str)
    }
    println("-----")
    books.addAll(book4)
    for ( str in books){
        println(str)
    }
    println("-----")

    books.removeAll(books3)
    for ( str in books){
        println(str)
    }
    println("-----")

    books.remove("kotlin")
    books.removeAll(books3)
    for ( str in books){
        println(str)
    }
    println("-----")
    books.retainAll(books2)
    for ( str in books){
        println(str)
    }
    println("-----")
    books.clear()
    for ( str in books){
        println("清除后有元素吗："+str)
    }

}

打印

java
kotlin
go
swift
-----
java
kotlin
go
swift
android
python
-----
kotlin
swift
android
python
-----
swift
android
python
-----
swift
android
-----

14、List集合

声明和创建List集合
listOf()：参看set集合部分
listOfNulls()：参看set集合部分
mutableListOf()：参看set集合部分

可变List
使用mutableListOf（）和arrayListOf（）返回的函数都是可变的
总体可参考可变set集合的部分

15、Map集合

map是用键值对来存储数据

声明和创建Map集合
借用了java的集合和框架，推荐使用kotlin的工具函数来创建Map集合
maoOf（）
mutableMapOf（）
hashMapOf（）
linkedMapOf（）
sortedMapOf（）
以上类似于Set

fun main() {
   var map= mapOf("name" to "zhangsan","age" to 13,"address" to "wudaokou")
    println(map)
    var mutableMap= mutableMapOf("name" to "zhangsan","address" to "wudaokou","age" to 13)
    mutableMap.put("homeland" ,"china")
    println("----")
    println(mutableMap)

    var hashmap= hashMapOf("name" to "zhangsan","address" to "wudaokou","age" to 13)//不保证顺序
    println("----")
    println(hashmap)

    var linkedHashSet= linkedMapOf("name" to "zhangsan","address" to "wudaokou","age" to 13)
    println("----")
    println(linkedHashSet)//按添加顺序排列

    var treeMap= sortedMapOf("name" to "zhangsan","address" to "wudaokou","age" to 13)
    println("----")
    println(linkedHashSet)//按key值有小到大

打印

{name=zhangsan, age=13, address=wudaokou}
----
{name=zhangsan, address=wudaokou, age=13, homeland=china}
----
{name=zhangsan, address=wudaokou, age=13}
----
{name=zhangsan, address=wudaokou, age=13}
----
{name=zhangsan, address=wudaokou, age=13}

16、使用Map的方法

fun main() {
   var map= mapOf("java" to 84,"kotlin" to 92,"go" to 76)
    //判断是否所有key-Value的key的长度都大于4，value都大于80
    println(map.all({it.key.length>4 && it.value>80}))
    println("----")
    //可以使用in !in运算符，因为默认拥有contains方法
    println("java在map里吗")
    println("java" in map)
    println("----")

    //对map集合元素进行过滤，要求可以包含li
    val filteredMap=map.filter({"li" in it.key})
    println(filteredMap)
    println("----")

    //将每个key-value对映射成新值，组成新的map集合
    val mappedList=map.map({"《疯狂${it.key}讲义》,价格为：${it.value}元"})
    println(mappedList)
    println("----")

    //根据key获得最大值，最小值
    println(map.maxBy { it.key })
    println(map.minBy({it.value}))
    println("----")

    //集合相加减
    val map2= mapOf("lua" to 67,"erlang" to 47,"kotlin" to 92)
    println(map+map2)
    println(map2-map)//集合相减，减去他们公共的元素

}

打印：

false
----
java在map里吗
true
----
{kotlin=92}
----
[《疯狂java讲义》,价格为：84元, 《疯狂kotlin讲义》,价格为：92元, 《疯狂go讲义》,价格为：76元]
----
kotlin=92
go=76
----
{java=84, kotlin=92, go=76, lua=67, erlang=47}
{lua=67, erlang=47, kotlin=92}

17、遍历Map的方法

4种方法遍历

遍历键值对
遍历键，在通过key获得value
直接for in 变脸map
用lambda表达式遍历

fun main() {
   var map= mapOf("java" to 84,"kotlin" to 92,"go" to 76)

    for (en in map){
        println(en)
    }
    println("------")

    for (key in map.keys){
        println("${key}---${map[key]}")
    }
    println("------")

    for ((key,value) in map){
        println("${key}==${value}")
    }
    println("------")

    //用lambda表达式遍历map
    map.forEach ({println("${it.key}***${it.key}")})

}

打印

java=84
kotlin=92
go=76
------
java---84
kotlin---92
go---76
------
java==84
kotlin==92
go==76
------
java***java
kotlin***kotlin
go***go

18、可变的Map

使用mutableMapOf（），hashMapOf（），linkedMapOf（），sortedMapOf（）创建的集合都是可变的。可变map集合的元素增，删，替换操作为

clear（）
put（key：k，value：v）：放入key-value对，会覆盖相同的key-value
putAll（集合）：放入多个集合元素
remove（key：K）:删除一个键值对

fun main() {
   var mutbaleMap= mutableMapOf("java" to 84,"kotlin" to 92,"go" to 76)
    //方括号语法放入一个新的键值对
    mutbaleMap["swift"]=99
    println(mutbaleMap)
    println("---")

    mutbaleMap.put("android",88)
    println(mutbaleMap)
    println("---")

    mutbaleMap.remove("java")
    println(mutbaleMap)
    println("---")

    //删除所有元素后，集合的大小也被删除了
    mutbaleMap.clear()
    println(mutbaleMap)
    println(mutbaleMap.size)
}

打印：

{java=84, kotlin=92, go=76, swift=99}
---
{java=84, kotlin=92, go=76, swift=99, android=88}
---
{kotlin=92, go=76, swift=99, android=88}
---
{}
0

心湖中的石子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录