Kotlin基础知识学习(二)

控制语句

条件分支

条件分支是最简单的控制语句。

简单分支

简单分支主要是if…else语句，kotlin对比java有一些变化。

• 跟Java一样

    if (isAdd){
        str = "今天很开心"
    } else {
        str = "今天不开心"
    }

• 条件分支可以返回值

    //方式二，if分支可以直接返回一个字符串
    var number:Int = 0
    str = if(number == 0){
        "今天天气很好"
    } else if(number == 1) {
        "今天天气不好也不坏"
    }else {
        "今天天气很差"
    }

• 类似于java中三元运算符

    //方式二，去掉大括号，有点像Java三元运算符
    str = if(number == 0) "今天天气很好" else if(number == 1) "今天天气不好也不坏" else "今天天气很差"

多路分支

类似Java中的switch…case,kotlin改成when…else。

• 关键字switch被when取代。
• 判断语句“case 常量值:”被新语句“常量值 ->”取代。
• break语句取消，kotlin默认一个分支处理完就跳出当前语句。
• default语句被else替换。
• 判断语句可以是变量值。
• 如果多个条件值要进入多个分支，java中要写多个case，而kotlin只需要用逗号将条件值并列。
• 如果条件值是连续的数字还可以使用in 开始值…结束值。
• 如果不在这个范围还可以用!in 开始值…结束值。

/**
 * 多路分支，替换Java中switch case
 * when代替switch
 * 常量 ->代替 case 常量：
* @param count
 */
fun whenTest(count:Int){
    var str:String = ""
    when(count){
        0 -> str = "今天星期一"
        1 -> str = "今天星期二"
        else -> str = "今天星期三"
    }
    println(str)
}

/**
 * 直接返回值
 * @param count
 */
fun whenTest1(count:Int){
    var str:String = ""
    str = when(count){
        0 -> "今天星期一"
        1 -> "今天星期二"
        else -> "今天星期三"
    }
    println(str)
}

/**
 * 条件判断允许是变量
 * @param count
 */
fun whenTest2(count:Int){
    var str:String = ""
    var condition:Int = 0
    var condition1:Int = 1
    str = when(count){
        condition -> "今天星期一"
        condition1 -> "今天星期二"
        else -> "今天星期三"
    }
    println(str)
}

/**
 * 如果多个条件值要进入多个分支，java中要写多个case，而kotlin只需要用逗号将条件值并列
 * 如果条件值是连续的数字还可以使用in 开始值..结束值
 * 如果不在这个范围还可以用!in 开始值..结束值
 * @param count
 */
fun whenTest3(count:Int){
    var str:String = ""
    str = when(count){
        0,1,2 -> "今天星期一"
        in 3..5 -> "今天星期二"
        !in 8..9 -> "今天星期四"
        else -> "今天星期三"
    }
    println(str)
}

类型判断

类型判断：类似Java中instanceof，kotlin用is代替。

fun isTest(count:Number){
    var str:String = ""
    when(count){
        is Int -> str = "count是整型"
        is Double -> str = "count是双精度"
        else -> str = "count什么都不是"
    }
    println(str)
}

循环处理

kotlin循环依然采用for和while

循环遍历

for循环方式主要有两种

• for(item in list)
  item是数组的每项元素、list则是数组

    //1、for(item in list)
    val poemArray:Array<String> = arrayOf("两个黄鹂鸣翠柳","一行白鹭上青天","窗含西岭千秋雪","门泊东吴万里船")
    for (item in poemArray){
        println(item)
        /*
        两个黄鹂鸣翠柳
        一行白鹭上青天
        窗含西岭千秋雪
        门泊东吴万里船
        */
    }

• for(i in 数组变量.indices)

indices表示该数组变量的下标数组，每次循环都从下标数组依次取出当前元素的下标。

    //2、for(i in array.indices),indices表示数组下标数组
    for(i in poemArray.indices){
        if(i % 2 == 0){
            println("${poemArray[i]},")
        } else {
            println("${poemArray[i]}。")
        }
        /*
        两个黄鹂鸣翠柳,
        一行白鹭上青天。
        窗含西岭千秋雪,
        门泊东吴万里船。
        */
    }

• for(i in 循环下标初始值 until 循环下标结束值)
  可以修改条件判断的初始值和结束值。

    //3、for(i in 循环下标初始值 until 循环下标结束值) 左闭右开，即包含初始值不包含结束值
    var numberArray:Array<Int> = arrayOf(1,2,3,4,5,6,7,8,9)
    for (i in 2 until numberArray.size){
        print("${numberArray[i]} ")//3 4 5 6 7 8 9
    }

• for(i in 数组下标范围 step 下标递增值)
  更改条件判断值每次递增值大小

    //3、for(i in 数组下标范围 step 下标递增值)
    //表示每次下标递增为2
    for(i in numberArray.indices step 2){
        print("${numberArray[i]} ")//1 3 5 7 9
    }

• for (i in 10 downTo 2)
  判断条件循环递减进行运算

    //循环递减
    for (i in numberArray.size - 1 downTo 0){
        print("${numberArray[i]} ")//9 8 7 6 5 4 3 2 1
    }

条件循环

• while循环

    val poemArray:Array<String> = arrayOf("两个黄鹂鸣翠柳","一行白鹭上青天","窗含西岭千秋雪","门泊东吴万里船")
    //1、while()
    var i:Int = 0
    while (i < poemArray.size){
        if(i % 2 == 0){
            println("${poemArray[i]},")
        } else {
            println("${poemArray[i]}。")
        }
        i++
    }
    /*
    两个黄鹂鸣翠柳,
    一行白鹭上青天。
    窗含西岭千秋雪,
    门泊东吴万里船。
    */

• do … while()循环

    //do..while()
    i = 0
    do {
        if(i % 2 == 0){
            println("${poemArray[i]},")
        } else {
            println("${poemArray[i]}。")
        }
        i++
    } while (i < poemArray.size)

循环的跳出

• continue和break
  continue 结束本次循环继续下个循环。
  break 跳出当前循环。

    val poemArray: Array<String?> = arrayOf("两个黄鹂鸣翠柳","一行白鹭上青天"," ","窗含西岭千秋雪","门泊东吴万里船",null,"风急天高猿啸哀")
    var i = -1
    var count = 0
    //1、continue、break
    while (i <= poemArray.size) {
        i++
        if (poemArray[i].isNullOrBlank()) {
            //跳出本次循环进入下次循环
            continue
        }

        if (count % 2 == 0) {
            println("${poemArray[i]},")
        } else {
            println("${poemArray[i]}。")
        }
        count++
        if (count == 4) {
            //结束循环
            break
        }
    }

• 标记名称@跳出到标记上的循环

如果有双重循环，在内循环中想直接跳到最完成循环，可以用@标记名称进行跳转。

    //2、跳到标记位置@
    val heArray: Array<String?> = arrayOf("今天天气真好","每一天都很美好","好好学习天天向上")
    var j = 0
    //标记
    end@ while (j < heArray.size){
        var str = heArray[j]
        var k = 0
        if (str == null) {
            continue
        }
        while (k < str.length) {
            if(str[k] == '一'){
                //跳到标记位置
                break@end
            }
            k++
        }
        j++
        print("$str ")
    }

字符串的处理

kotlin中字符串声明有两种方式
1、非空字符串

    //1、非空字符串需要初始化，否则会报错
    var str:String = "111"
    var str4:String = ""
    var str6:String = "  "

2、可空字符串(String?)

    //String?表示该字符串可以是空字符串
    var str1:String? = null
    var str2:String? = "222"
    var str3:String? = ""

字符串常用判断方法

    //1、非空字符串需要初始化，否则会报错
    var str:String = "111"

    //String?表示该字符串可以是空字符串
    var str1:String? = null

    var str2:String? = "222"

    var str3:String? = ""

    var str4:String = ""

    var str5:String? = "  "

    var str6:String = "  "

    //kotlin校验字符串空值的相关方法
    //isNullOrBlank 非空和可空字符串均可调用，判断字符串是否为空null、长度为0、全都是空白格
    println("${ str.isNullOrBlank()}")//false
    println("${ str1.isNullOrBlank()}")//true
    println("${ str2.isNullOrBlank()}")//false
    println("${ str3.isNullOrBlank()}")//true
    println("${ str4.isNullOrBlank()}")//true
    println("${ str5.isNullOrBlank()}")//true
    println("${ str6.isNullOrBlank()}")//true

    //isNullOrEmpty 非空和可空字符串均可调用，判断字符串是否为null、长度为0
    println("${ str.isNullOrEmpty()}")//false
    println("${ str1.isNullOrEmpty()}")//true
    println("${ str2.isNullOrEmpty()}")//false
    println("${ str3.isNullOrEmpty()}")//true
    println("${ str4.isNullOrEmpty()}")//true
    println("${ str5.isNullOrEmpty()}")//false
    println("${ str6.isNullOrEmpty()}")//false

    //isEmpty 只有非空字符串才能调用，判断字符串长度是否为0
    println("${ str.isEmpty()}") //false
    //println("${ str1.isEmpty()}") 不能调用
    //println("${ str2.isEmpty()}") 不能调用
    //println("${ str3.isEmpty()}") 不能调用
    println("${ str4.isEmpty()}") //true
    //println("${ str5.isEmpty()}") 不能调用
    println("${ str6.isEmpty()}")//false

    //isBlank 只有非空字符串才能调用，判断字符串长度是否为0、都是空格
    println("${ str.isBlank()}") //false
    //println("${ str1.isBlank()}") 不能调用
    //println("${ str2.isBlank()}") 不能调用
    //println("${ str3.isBlank()}") 不能调用
    println("${ str4.isBlank()}") //true
    //println("${ str5.isBlank()}") 不能调用
    println("${ str6.isBlank()}")//true

    //isNotEmpty 只有非空字符串才能调用，判断字符串长度是否大于0
    println("${ str.isNotEmpty()}") //true
    //println("${ str1.isNotEmpty()}") 不能调用
    //println("${ str2.isNotEmpty()}") 不能调用
    //println("${ str3.isNotEmpty()}") 不能调用
    println("${ str4.isNotEmpty()}") //false
    //println("${ str5.isNotEmpty()}") 不能调用
    println("${ str6.isNotEmpty()}")//true

    //isNotBlank 只有非空字符串才能调用，判断字符串长度是否大于0且不全是空格
    println("${ str.isNotBlank()}") //true
    //println("${ str1.isNotBlank()}") 不能调用
    //println("${ str2.isNotBlank()}") 不能调用
    //println("${ str3.isNotBlank()}") 不能调用
    println("${ str4.isNotBlank()}") //false
    //println("${ str5.isNotEmpty()}") 不能调用
    println("${ str6.isNotBlank()}")//false

字符串长度获取

• .length获取长度只有在非空字符串中才可以直接使用。

var str1:String = "123"
println("str1的长度等于${str1.length}")//str1的长度等于3

• 可空字符串不能直接调用长度，需要判空,否则会报错。

    var str2:String? = null
    var str3:String? = ""
    var str4:String? = "456"
        //可空字符串不能直接调用长度，需要判空
    if(str2 != null){
        println("str2的长度等于${str2.length}")
    } else {
        println("str2的长度等于空")//str2的长度等于空
    }
    if(str3 != null){
        println("str3的长度等于${str3.length}")//str3的长度等于0
    } else {
        println("str3的长度等于空")
    }

    if(str4 != null){
        println("str4的长度等于${str4.length}")//str4的长度等于3
    } else {
        println("str4的长度等于空")
    }

• 可空字符串，字符串后面加上?表示如果字符串为空则返回null

    //字符串后面加上?表示如果字符串为空则返回null
    println("str2的长度等于${str2?.length}")//str2的长度等于null
    println("str3的长度等于${str3?.length}")//str3的长度等于0
    println("str4的长度等于${str4?.length}")//str4的长度等于3

• 可空字符串可增加类似java中三元运算符一样，对长度进行判断。

    //?:类似于java中的三元运算符，表示字符串为空的话，返回-1
    println("str2的长度等于${str2?.length ?: -1}")//str2的长度等于-1
    println("str2的长度等于${str3?.length ?: -1}")//str3的长度等于0

• 可空字符串强制转成非空字符串

    //!!表示强制将可空字符串按非空字符串输出
    //println("str2的长度等于${str2!!.length}")//会抛异常，
    println("str3的长度等于${str3!!.length}")//str3的长度等于0

比较判断

操作符==

• 用于内容相等性比较（内容比较）。
• 对于基本数据类型（如 Int, Double, Char 等），== 比较的是它们的值。
• 对于对象类型，== 默认比较的是它们的引用（即内存地址），但如果类重写了 equals() 方法，那么 == 将调用该方法来进行内容比较。

//data修饰的自动生成了 equals 方法，比较的是内容
data class Person(val name: String)
class Student(val name: String)

    //操作符== 对于基本数据类型比较的是内容
    var a:Int = 3
    var b:Int = 3
    var c:Int = 4
    //println(a==b)//true
    //println(a==c)//false

    var str1 = "123"
    var str2 = "123"
    //println(str1==str2)//true

    //操作符== 对于对象类型，== 默认比较的是它们的引用（即内存地址），但如果类重写了 equals() 方法，那么 == 将调用该方法来进行内容比较。
    val person1:Person = Person("张三")
    val person2:Person = Person("张三")
    //println(person1==person2)//true

    val student1:Student = Student("李四")
    val student2:Student = Student("李四")
    //println(student1==student2)//false

操作符===

• 用于引用相等性比较（身份比较）。
• 比较的是两个引用是否指向同一个对象（即内存地址是否相同）。

    /*
    * 操作符===
    * 用于引用相等性比较（身份比较）。
    * 比较的是两个引用是否指向同一个对象（即内存地址是否相同）。
    */
    println(a===b)//可能为 false，也可能为 true，取决于 JVM 的实现和缓存机制（对于小整数，JVM 可能会缓存）
    println(a===c)//false

    println(str1===str2)//true 字符串是常量池

    println(person1===person2)//false
    println(student1==student2)//false

    var intArray:IntArray = intArrayOf(1,2)
    var intArray1 = intArray
    println(intArray===intArray1)//true  指向同一个对象

操作符is和!is

• is 操作符用于检查一个对象是否是某个类型的实例。如果对象是指定类型的实例，则表达式返回 true，否则返回 false。
• !is 操作符是 is 操作符的否定形式，用于检查一个对象是否不是某个类型的实例。如果对象不是指定类型的实例，则表达式返回 true，否则返回 false。

    //is 校验变量是否为某种类型 !is校验变量是否不为某种类型，使用的关键字是!is
    var a:Int = 1
    println(a is Int)//true
    var b = 3.2
    println(b is Double)//true
    var c = 'a'
    println(c is Char)//true
    var person = Person("张三")
    println(person is Person)//true

操作符in和!in

• in 操作符用于检查一个值是否存在于集合（如数组、列表、集合、映射的键或值集合等）或范围内。如果值存在于集合或范围内，则表达式返回 true，否则返回 false。
• !in 操作符是 in 操作符的否定形式，用于检查一个值是否不存在于集合或范围内。如果值不存在于集合或范围内，则表达式返回 true，否则返回 false。

    //in 校验数组中是否存在某个元素 格式：变量名 in 数组   !in 判断数组是否不存在等值元素
    val intArray = intArrayOf(1,4,6,8,9)
    println(1 in intArray)//ture
    println(2 in intArray)//false
    println(3 !in intArray)//true
    println(4 !in intArray)//false