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

一、条件分支

1.1 简单分支

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

代码语言：javascript复制

<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"/>

代码中

代码语言：javascript复制

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赋值，优化之后如下所示：

代码语言：javascript复制

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

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

代码语言：javascript复制

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,使用这个来处理多路分支的条件判断：

代码语言：javascript复制

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也允许有返回值，所以上面的代码还可以再优化，优化后代码如下：

代码语言：javascript复制

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去掉了这个限制，进行了分支处理是允许引入变量判断，当然引入具体的运算表达式也是可以的，代码演示如下：

代码语言：javascript复制

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 开始…结束值”。扩展功能后的多路分支代码如下所示：

代码语言：javascript复制

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代码若想知道某个变量是否为字符串类型，则使用一下代码格式进行判断

代码语言：javascript复制

if(str instanceof String){
	...
}

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

代码语言：javascript复制

if(str is String){
	...
}

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

代码语言：javascript复制

<?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

代码语言：javascript复制

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”,示例代码如下： 布局文件的代码我就不贴了，都差不多 直接看代码吧

代码语言：javascript复制

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表示该数组变量的下标数组，每次循环从下表数组依次取出当前元素的下标，代码如下：

代码语言：javascript复制

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进行循环判断，示例代码如下：

代码语言：javascript复制

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

代码语言：javascript复制

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中的判断代码如下

代码语言：javascript复制

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中，只要遇到有异常情况即可跳出循环，不管你是单层循序还是多层循环，说的跟真的一样，我们来实现一下吧

代码语言：javascript复制

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 声明可空变量

代码语言：javascript复制

var strNotNull:String = ""

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

代码语言：javascript复制

var strCanNull:String?

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

代码语言：javascript复制

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

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

布局文件代码

代码语言：javascript复制

<?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代码

代码语言：javascript复制

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属性会抛出空指针异常，可以加个标记，告诉编译器遇到空指针别抛异常，直接返回空指针就可以了，对应的代码如下：

代码语言：javascript复制

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的三元运算符，接下来看看怎么是使用这个“?:”代码如下：

代码语言：javascript复制

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

运行效果图如下：

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

代码语言：javascript复制

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

        }

运行效果图如下：

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

代码语言：javascript复制

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

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

代码语言：javascript复制

<?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代码

代码语言：javascript复制

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方法克隆而来的变量复制品），则其结构相等，但引用不等。

下面用代码来演示一下：

代码语言：javascript复制

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 类型名称”。下面用代码来实践一下：

代码语言：javascript复制

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 数组名”来判断数组是否不存在等值元素，下面用代码来实践一下：

代码语言：javascript复制

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 java 编程算法

0 人点赞