一、条件分支

1.1 简单分支

最简单的分支莫过于if…else了吧,Java中相信都用过，那么在Kotlin中又是怎么用的呢？其实也比较类似，来看看吧！布局文件中：

<TextView
        android:layout_marginTop="20dp"
        android:textColor="#000"
        android:padding="20dp"
        android:id="@+id/tv_puzzle"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_if_else"
        android:text="IF ELSE"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

代码中

var is_odd:Boolean = true
        tv_puzzle.text = "随心所欲，为所欲为，二选一"
        btn_if_else.setOnClickListener {
            if(is_odd == true){
                tv_puzzle.text = "随心所欲"
            }else{
                tv_puzzle.text = "为所欲为"
            }
            is_odd = !is_odd
        }

运行效果图

点一下按钮：

再点一下：

点击次数为奇数时显示随心所欲，为偶数时显示为所欲为，但是上面的代码和Java不是一毛一样吗？特养特僧破，我们注意到无论是奇数还是偶数点击，都是显示在这个TextView上面，Kotlin在这里做的优化便是允许分支语句返回字符串，从而在条件语句外层直接对tv_puzzle赋值，优化之后如下所示：

btn_if_else.setOnClickListener {
            tv_puzzle.text = if(is_odd == true){
                "随心所欲"
            }else{
                "为所欲为"
            }
            is_odd = !is_odd
        }

判断还是原来的判断但是，更加的精简了，再优化一下去掉这个大括号，如下所示

btn_if_else.setOnClickListener {
            tv_puzzle.text = if(is_odd == true) "随心所欲" else "为所欲为"
            is_odd = !is_odd
        }

一个if…else…语句一行代码就可以了，精简至此，夫复何求！说完了简单分支，接下来说一下多路分支

1.2 多路分支

多说多路分支，你首先想到的是不是switch/case呢？但是switch/case存在自身的局限性，Kotlin推出新的关键字，when/else,使用这个来处理多路分支的条件判断：

var count:Int = 0
        btn_when_else.setOnClickListener {
            when(count){
                0 -> tv_result.text = "你说你有点难追"
                1 -> tv_result.text = "我就打断你的腿"
                //if语句可以没有else，但是when语句必须带上else
                else -> tv_result.text = "《告白气球》"
            }
            count = (count + 1 ) % 3
        }

运行后的效果就是点击按钮之后不同的文字出现，出现的条件由count = (count + 1 ) % 3的结果控制对比when/else和switch/case，有以下区别（1）关键自switch被when取代（2）判断语句“case 常量值：” 被新语句 “常量值 ->”取代（3）每个分支后面的break语句取消了，因为Kotlin默认一个分支处理完就直接跳出多路语句，所以不需要break。（4）关键自default被else取代。就像之前我们优化if/else一样，Kotlin中的when/else也允许有返回值，所以上面的代码还可以再优化，优化后代码如下：

var count:Int = 0
        btn_when_else.setOnClickListener {
            tv_result.text = when(count){
                0 -> "你说你有点难追"
                1 -> "我就打断你的腿"
                else ->  "《告白气球》"
            }
            count = (count + 1 ) % 3
        }

还有一点就是以往Java使用switch/case时有个限制，就是case后面只能跟常量，不能跟变量，否则编译不通过，现在Kotlin去掉了这个限制，进行了分支处理是允许引入变量判断，当然引入具体的运算表达式也是可以的，代码演示如下：

var odd:Int = 0
        var event:Int = 1
        var count:Int = 1
        btn_when_else.setOnClickListener {
            tv_result.text = when(count){
                odd -> "你说你有点难追"
                event -> "我就打断你的腿"
                else ->  "《告白气球》"
            }
            count = (count + 1 ) % 3
        }

在Java中的switch/case机制中，每个case仅仅对应一个常量值，如果5个常量值都要进入某个分支，就只能并列写5个case语句，然后才跟上具体的分支处理语句，现在when/else机制中便无须如此麻烦了，这5个常量值并排在一起用逗号隔开即可，如果几个常量刚好是连续数字，可以使用“in 开始值…结束值”指定区间范围，举一反三，若要求不在某个区间范围，则使用语句“!in 开始…结束值”。扩展功能后的多路分支代码如下所示：

var count:Int = 1
        btn_when_else.setOnClickListener {
            tv_result.text = when(count){
                1,3,5,7,9 -> "你说你有点难追"
                in 13..19 -> "我就打断你的腿"
                !in 6..10 -> "周杰伦"
                else ->  "《告白气球》"
            }
            count = (count + 1 ) % 20
        }

虽然已经知道这种方式了，但在要熟练运用还有一些实践才行，而不是写几个示例就可以掌握的，路漫漫其修远兮，吾将上下而求索！

1.3 类型判断

在Java代码若想知道某个变量是否为字符串类型，则使用一下代码格式进行判断

if(str instanceof String){
	...
}

而在Kotlin中，关键字instanceof被is所取代，下面是示例代码：

if(str is String){
	...
}

同事，多路分支的when/else语句也支持类型判断，只不过在分支判断时采取"is 变量类型 ->"这种形式，下面是代码示例，在变量countType为Long、Double、Float三种类型时做多路判断处理：布局文件activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:gravity="center_horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_marginTop="20dp"
        android:textColor="#000"
        android:padding="20dp"
        android:id="@+id/tv_result"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_when_instance"
        android:text="WHEN INSTANCE"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</LinearLayout>

MainActivity.kt

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var count:Int = 1
        var countType:Number
        btn_when_instance.setOnClickListener {
            count = (count + 1) % 3
            countType = when(count){
                0 -> count.toLong()
                1 -> count.toDouble()
                else -> count.toFloat()
            }
            tv_result.text = when(countType){
                is Long -> "天若有情天亦老"
                is Double -> "人间正道是沧桑"
                else -> "无问西东"
            }
        }


    }
}

判断类型为Long 时，运行效果图如下

判断类型为Double 时，运行效果图如下

为其他类型时，运行效果图如下

二、循环处理

2.1 遍历循环

Java遍历某个队列，可以通过“for(item:list)”形式的语句进行循环操作。同样，Kotlin也能使用类似形式的循环，区别在于吧冒号“:”换成了关键字“in”,示例代码如下：布局文件的代码我就不贴了，都差不多直接看代码吧

val txArray:Array<String> = arrayOf("十年生死两茫茫","不思量","自难忘","千里孤坟",
            "无处话凄凉","纵使相逢应不识","尘满面","鬓如霜","夜来幽梦忽还乡","小轩窗","正梳妆",
            "相顾无言","惟有泪千行","料得年年肠断处","明月夜","短松冈")
        btn_test.setOnClickListener {
            var desc:String = ""
            for (item in txArray){
                desc = "$desc$item, n"
            }
            tv_result.text = desc
        }

运行效果图如下：

但是一首词不可能结尾都是逗号，所以要改一下判断的代码，同时也改一下文章的格式，改为七言绝句，奇数为逗号，偶数为句号，在Kotlin中使用“for(i in 数组变量.indices)”语句，其中indices表示该数组变量的下标数组，每次循环从下表数组依次取出当前元素的下标，代码如下：

val txArray:Array<String> = arrayOf("日照香炉生紫烟","遥看瀑布挂前川","飞流直下三千尺","疑是银河落九天")
        btn_test.setOnClickListener {
            var desc:String = ""
            //indices表示该数组变量的下标数组
            for (i in txArray.indices){
                if (i % 2 == 0){
                    desc = "$desc${txArray[i]},n"
                }else{
                    desc = "$desc${txArray[i]}。n"
                }
            }
            tv_result.text = desc
        }

运行效果图：

2.2 条件循环

使用while进行循环判断，示例代码如下：

val txArray:Array<String> = arrayOf("日照香炉生紫烟","遥看瀑布挂前川","飞流直下三千尺","疑是银河落九天")
        btn_test.setOnClickListener {
            var poem:String = ""
            var i:Int = 0
            while (i < txArray.size){
                if(i % 2 == 0){
                    poem = "$poem${txArray[i]}, n"
                }else{
                    poem = "$poem${txArray[i]}。 n"
                }
                i++
            }
            poem = "${poem}该诗歌一共有${i}句。"
            tv_result.text = poem
        }

再来看看do/while

val txArray:Array<String> = arrayOf("日照香炉生紫烟","遥看瀑布挂前川","飞流直下三千尺","疑是银河落九天")
        btn_test.setOnClickListener {
            var poem:String = ""
            var i:Int = 0
            do {
                if(i % 2 == 0){
                    poem = "$poem${txArray[i]}, n"
                }else{
                    poem = "$poem${txArray[i]}。 n"
                }
                i++
            }while (i < txArray.size)
            poem = "${poem}该诗歌一共有${i}句。"
            tv_result.text = poem
        }

2.3 跳出多重循环

之前的诗句都是中规中矩的，没有什么问题，但是实际开发中则不然，所以合理性判断时很重要的，Kotlin中的判断代码如下

val txArray:Array<String?> = arrayOf("日照香炉生紫烟",null,"遥看瀑布挂前川","","飞流直下三千尺","     ","疑是银河落九天","望庐山瀑布")
        btn_test.setOnClickListener {
            var poem:String =""
            var pos:Int = -1
            var count:Int = 0
            while (pos <= txArray.size){
                pos++
                //若发现该行时空串或者空格串，则忽略该行
                if(txArray[pos].isNullOrBlank())
                    continue
                if(count % 2 == 0){
                    poem = "$poem${txArray[pos]},n"
                }else{
                    poem = "$poem${txArray[pos]}。n"
                }
                count++
                //若合法行数达到4行，则结束循环
                if(count == 4)
                    break
            }
            tv_result.text = poem
        }

从上面的代码来看，合法性的判断用到的是continue和break,和Java一样，那么Kotlin真的就没有做什么改变吗？其实不然，Kotlin中，只要遇到有异常情况即可跳出循环，不管你是单层循序还是多层循环，说的跟真的一样，我们来实现一下吧

val txArray:Array<String?> = arrayOf("日照香炉生紫烟",null,"遥看瀑布挂前川","","飞流直下三千尺","     ","疑是银河落九天","望庐山瀑布")

        btn_test.setOnClickListener {
            var i:Int = 0
            var is_found = false
            //给外层循环加一个名为outside的标记
            outside@ while (i < txArray.size){
                var j:Int = 0
                var item = txArray[i]

                if (item != null) {
                    while ( j < item.length){
                        if(item[j] == '飞'){
                            is_found = true
                            //发现 这个飞 字直接跳出outside循环
                            break@outside
                        }
                        j++

                    }
                }
                i++
            }
            tv_result.text = if (is_found) "有" else "无"
        }

上面的代码运行效果如下

上面的循环与判断时多层的，直接跳出显示结果，这就是用了 @ 的好处，这也是Kotlin中的新的改变。

三、空安全

3.1 字符串的有效判断

开发中有很多的异常要进行判断处理，常见的异常种类包括空指针异常NullPointerException、数组越界异常IndexOutOfBoundsException、类型转换异常ClassCastException的等。其中，最讨嫌的就是空指针异常，这个异常会潜伏，藏的很深，运行过程中容易出错，但是编码编译的时候又可以“萌混过关”,有时候的APP突然闪退，就有空指针的缘故，这个判断在Java中是比较烦的，涉及到值的地方都得加一层判断"if(*** != null)",烦不胜烦。而Android的SDK中提供了"TextUtils.isEmpty(" ** ")"这个方法，专门用于校验某个字符串是否为空值，Kotlin的研发人员当然也想到这个了，下面列举Kotlin校验空字符串的方法。

（1）isNullOrEmpty:为空指针或者字串长度为0时返回true,非空串与可空串均可调用。（2）isNullOrBlank:为空指针、字串长度为0或者全为空格时返回true,非空串与可空串均可调用。（3）isEmpty:字串长度为0时返回true,只有非空串可调用。（4）isBlank:字串长度为0或者全为空格时返回true,只有非空串可调用。（4）isNotEmpty:字串长度大于0时返回true,只有非空串可调用。（5）isNotBlank:字串长度大于0且不是全空格串时返回true,只有非空串可调用。

对于上面的非空串与可空串，在Kotlin中每个类型的变量都分作不可为空和可以为空两种，就是非空串和可空串，正常的声明变量默认都是非空串（不可为null），比如下面的这个代码：

3.2 声明可空变量

var strNotNull:String = ""

可以为空的变量，代码如下：

var strCanNull:String?

有兴趣的可以自己自己用上面6个方法测试一下，不为空的6个方法都可以用，可为空只能用前两个，这是对字符串判断是否为空串，如果要获取字符串的长度，或者调用其他的字符串方法，这时仍然要判断空指针，举个例子，下面有三个字符串：

		var strA:String = "非空" //非空串
        var strB:String? = null //可空串实际为空
        var strC:String? = "可空串"//可空串实际不为空

对于strA来说，它是非空串，可以直接获取length长度属性，对于strB和strC必须进行非空判断，否则编译器可提示改行代码存在错误，这三个字符串的长度获取代码如下：

布局文件代码

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:gravity="center_horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:textColor="#000"
        android:id="@+id/tv_result"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    
    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_a"
        android:text="A"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_b"
        android:text="B"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_c"
        android:text="C"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</LinearLayout>

MainActivity.kt代码

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        var strA:String = "非空" //非空串
        var strB:String? = null //可空串实际为空
        var strC:String? = "可空串"//可空串实际不为空

        var length:Int = 0
        btn_a.setOnClickListener {
            length = strA.length
            tv_result.text = "字符串A的长度为$length"
        }

        btn_b.setOnClickListener {
            //length = strB.length  //这样写是会报错的
            length = if(strB!=null) strB.length else -1
            tv_result.text = "字符串B的长度为$length"
        }

        btn_c.setOnClickListener {
            //因为字符串为可空，所以要先判断才可以获取长度这样写是会报错的
            length = if(strC!=null) strC.length else -1
            tv_result.text = "字符串C的长度为$length"
        }

    }
}

运行效果图如下：

3.3 校验空值的运算符

Kotlin在访问空串的length属性会抛出空指针异常，可以加个标记，告诉编译器遇到空指针别抛异常，直接返回空指针就可以了，对应的代码如下：

var strB:String? = null //可空串实际为空
        var length_null:Int?
        btn_test.setOnClickListener {
            //？表示变量为空时直接返回null,所以返回值的变量必须被声明为可空类型
            length_null = strB?.length
            tv_result.text = "使用？,得到字符串B的长度为$length_null"
        }

运行效果如下：

从上面代码来看只是多了一个问号，语句strB?.length其实等于"length_null = if(strB!=null) strB.length else null" ,所以我们看的是null,如果不想在界面上显示null，还得另外判断length_null是否为空，也就是说还有操作空间，当然这不是Kotlin想看到的，所以它又引入了一个新的运算符"?：",学名叫作：“Elvis操作符”，可以当做Java的三元运算符，接下来看看怎么是使用这个“?:”代码如下：

var strB:String? = null //可空串实际为空
        var length:Int?
        btn_test.setOnClickListener {
            //?:表示为空时就返回右边的值
            length = strB?.length ?: -1
            tv_result.text = "使用?:,得到字符串B的长度为$length"
        }

运行效果图如下：

刚才是判断，接下来是强制转换，把双感叹号加在变量名称后面表示将可空类型转为非空类型，从而避免变量是否非空的校验，代码如下：

var strB:String? = null //可空串实际为空
        var length:Int?
        btn_test.setOnClickListener {
            strB = "Kotlin"
            length = strB!!.length
            tv_result.text = "使用！！得到字符串B的长度$length"

        }

运行效果图如下：

刚才用运算符“！！”强行放弃了非空判断，那么是否就万无一失了呢，是否还会抛出异常呢，看如下代码：

var strB:String? = null //可空串实际为空
        var length:Int?
        btn_test.setOnClickListener {
            //!!表示不做非空判断，强制执行后面的表达式，如果变量为空，就会抛出异常
            //所以只有在确保为非空时，才能使用!!
            try {
                //即使返回给可空变量length_null，也会抛出异常
                length = strB!!.length
                tv_result.text = "使用！！得到字符串B的长度$length"
            }catch (e:Exception){
                tv_result.text = "空指针异常"
            }

        }

运行效果如下：

最后来总结一下吧：（1）声明变量示例时，在类型名称后面加问号，表示该变量可以为空。（2）调用变量方法时，在变量名称后面加问号，表示一旦变量为空就返回null。（3）新引入运算符“?:”，表示一旦变量为空，就返回该运算符右边的表达式。（4）新引入运算符“!!”，通知编译器不做非空校验，如果运行时发现变量为空，就抛出异常。

四、等式判断

4.1 结构相等

基本数据类型如整型、长整型、浮点型、双精度、布尔类型，无论是在C/C++还是在Java抑或是在Kotlin，都使用双等号 “==”进行两个变量的相等性判断，而Kotlin中把字符串当作整型一样的判断，不等则用“！=”,用一个表来说明

字符串的等值性判断要求	Java的判断方式	Kotlin的判断方式
判断两个字符串是否相等	strA.equals(strB)	strA == strB
判断两个字符串是否相等	!strA.equals(strB)	strA != strB

下面通过代码来实践一下布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:gravity="center_horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">


    <TextView
        android:textColor="#000"
        android:id="@+id/tv_title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <TextView
        android:textColor="#000"
        android:id="@+id/tv_result"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <Button
        android:layout_marginTop="20dp"
        android:id="@+id/btn_test"
        android:text="test"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>


</LinearLayout>

MainActivity.kt代码

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val he:String = "他"
        val she:String = "她"
        var isEqual:Boolean = true
        btn_test.setOnClickListener {
            if(isEqual){
                tv_title.text = "比较 $he 和 $she 是否相等"
                val result = he == she
                tv_result.text = "== 的比较结果是$result"

            }else{
                tv_title.text = "比较 $he 和 $she 是否不等"
                val result = he != she
                tv_result.text = "!= 的比较结果是$result"
            }
            isEqual = !isEqual

        }

    }
}

运行效果：

再点一次

不单单是字符串String类型，凡是Java中实现了equals函数的类，其变量均可在Kotlin中通过运算符"==“和”!="进行等式判断，这种不比较存储地址，而是比较变量结构内部值的行为，Kotlin称之为结构相等。

4.2 引用相等

在Kotlin中，结构相等的运算符是双等号,那么引用相等的运算符便是三个等号 " === “,多出来的一个等号表示连地址都要相等，结构不等是“!=”,那么引用不等就是”!=="。不过大多数场合，结构相等和引用相等的判断结果是一致的，如以下场合：

（1）对于基本数据类型，包括整数、浮点型、布尔型、字符串、结构相等和引用相等没有区别（2）同一个类声明的不同变量，只要有一个属性不相等，则其他既是结构不等，也是引用不等。（3）同一个类声明的不同变量，若equals方法校验的每个属性都相等（譬如通过clone方法克隆而来的变量复制品），则其结构相等，但引用不等。

下面用代码来演示一下：

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.util.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var count: Int = 0
        val date1: Date = Date()
        val date2: Any = date1.clone()//从date1克隆过来的
        btn_test.setOnClickListener {
            when (count++ % 4) {
                0 -> {
                    tv_title.text = "比较date1和date2是否结构相等"
                    //结构相等比较的是二者的值
                    val result = date1 == date2
                    tv_result.text = "==的比较结果是$result"
                }
                1 -> {
                    tv_title.text = "比较date1和date2是否结构不等"
                    //结构不等比较的是二者的值
                    val result = date1 != date2
                    tv_result.text = "!=的比较结果是$result"
                }
                2 -> {
                    tv_title.text = "比较date1和date2是否引用相等"
                    //引用相等比较的时二者是不是同一个东西，即使克隆的一模一样也不是一个东西
                    val result = date1 === date2
                    tv_result.text = "===的比较结果是$result"
                }
                else -> {
                    tv_title.text = "比较date1和date2是否引用不等"
                    val result = date1 !== date2
                    tv_result.text = "!==的比较结果是$result"
                }
            }
        }


    }
}

运行效果图

结构相等的判断结果

结构不等的判断结果

引用相等的判断结果

引用不等的判断结果

4.3 is 和 in

除了判断两个变量是否相等之外，还有其他维度的等式判断，例如校验变量是否为某种类型、校验数组中是否存在某个元素等，对于这些特殊的等式判断，海的具体问题具体分析，下面对于is和in进行说明。 1.运算符 is 和 !is 在Kotlin中，若要校验变量是否为某种类型，使用的关键字是is，具体写法形如“变量名称 is 类型名称”；若要校验变量是否不为某种类型，使用的关键字时 !is形如“变量名称 !is 类型名称”。下面用代码来实践一下：

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.util.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val oneLong:Long = 1L
        var isEqual : Boolean = true
        btn_test.setOnClickListener {
            if(isEqual){
                tv_title.text = "比较oneLong是否为长整型"
                //is用于判断是否等于某种类型，对应的Java关键字时instanceof
                val result = oneLong is Long
                tv_result.text = "is的比较结果是$result"
            }else{
                tv_title.text = "比较oneLong是否为非长整型"
                //!is用于判断是否不等于某种类型
                val result = oneLong !is Long
                tv_result.text = "!is的比较结果是$result"
            }
            isEqual = !isEqual
        }

    }
}

运行效果如下：

"is"的判断结果

"!is"的判断结果

2.运算符 in 和 !in 另一种特殊的等式判断，是校验数组中是否存在某个元素，通过“变量名 in 数组名” 来判断数组是否存在等值元素，通过“变量名 !in 数组名”来判断数组是否不存在等值元素，下面用代码来实践一下：

package com.llw.kotlinstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.util.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val oneArray: IntArray = intArrayOf(1, 2, 3, 4, 5)
        val four: Int = 4
        val nine:Int = 9
        var count:Int = 0
        btn_test.setOnClickListener {
            when(count++%4){
                0 -> {
                    tv_title.text = "比较$four 是否存在数组oneArray中"
                    //in用于判断变量是否位于数组或容器中，Java判断数组中是否存在某元素只能采用循环遍历的方式
                    val result = four in oneArray
                    tv_result.text = "in的比较结果是$result"
                }
                1 -> {
                    tv_title.text = "比较$four 是否不存在数组oneArray中"
                    //in用于判断变量是否位于数组或容器中，Java判断数组中是否存在某元素只能采用循环遍历的方式
                    val result = four !in oneArray
                    tv_result.text = "!in的比较结果是$result"
                }
                2 -> {
                    tv_title.text = "比较$nine 是否存在数组oneArray中"
                    //in用于判断变量是否位于数组或容器中，Java判断数组中是否存在某元素只能采用循环遍历的方式
                    val result = nine in oneArray
                    tv_result.text = "in的比较结果是$result"
                }
                else -> {
                    tv_title.text = "比较$nine 是否不存在数组oneArray中"
                    //in用于判断变量是否位于数组或容器中，Java判断数组中是否存在某元素只能采用循环遍历的方式
                    val result = nine !in oneArray
                    tv_result.text = "!in的比较结果是$result"
                }
            }
        }

    }
}

运行效果图如下

对4进行“in”操作的校验结果

对4进行“!in”操作的校验结果

对9进行“in”操作的校验结果

对9进行“!in”操作的校验结果

Kotlin学习日志（三）控制语句

一、条件分支

1.1 简单分支

1.2 多路分支

1.3 类型判断

二、循环处理

2.1 遍历循环

2.2 条件循环

2.3 跳出多重循环

三、空安全

3.1 字符串的有效判断

3.2 声明可空变量

3.3 校验空值的运算符

四、等式判断

4.1 结构相等

4.2 引用相等

4.3 is 和 in