Kotlin常用操作符

2017-10-31

1.Elvis操作符?:

如果？：左边的表达式非空，则操作符返回左边的结果，否则返回右边的结果（仅在左侧为空的时候右侧的表达式才会进行计算）。
val a=b?.length?:-1
val a:Int = if(b!=null) b.length else -1

2.安全转换as?

当使用as转型的时候，可能会经常出现ClassCastException。所以，现在使用as?安全转型，当转型不成功的时候，它会返回null。当使用intent传值时有可能会出现空字符串不能用as强制转型，这时需要使用as？
val m:Int?=a as? Int

3.冒号

用于类的继承，变量的定义
1.类型和超类型（父类）之间的冒号前要有一个空格
2.实例和类型之间的冒号前不要空格
定义变量：var str: String?=null
类的继承与变量定义：class MainActivity< T : Serializable>(str : String) : Activity

4.类型判断符is

检查某个实例是否是某个类型，如果判断出属于某个类型，那么判断后的分支中可以直接当该类型使用，无需显式转换

fun getStringLength(obj: Any): Int?{
            if(obj is String && obj.length>0)
                return obj.length
        }

5.范围操作符 .. 以及 in

使用in运算符来检查某个数字是否在指定区间内

if(i in 1..10){//i<=10&&i>=1
                            println(i)
                            }

downTo()函数
区间内循环：

for(i in 4 downTo 1){
            println(i)//4321
        }

step()函数
可以进行任意数量的迭代，而不是每次变化都是1

for(i in 1..4 step 2) println(i)//1 3
        for(i in 4 downTo 1 step 2) println(i) //4 2

多行输入符三个双引号
三引号的形式用来输入多行文本，也就是说在三引号之间输入的内容将被原样保留，之中的单引号和双引号不用转义，其中的不可见字符比如/n和/t都会被保留

val str="""
        one
        two
        """
        val str ="one\ntwo"
        val str ="one"+"\n"+"two"

forEach遍历
遍历一个list可以用list.forEach{ b-> blist.add(b) }

6.$符号

这个我感觉在拼串上用的比较方便一点

val pair = Pair(1, "one")
 val (num, name) = pair
 println("num = $num, name = $name")

7.==和===的区别

==是判断是否相等，===判断值以及引用是否完全相等

val num: Int = 128;
val a:Int? = num
val b:Int? = num
println(a == b)
print(a === b)

8._（下划线）

我理解的是构造参数中在下文用不到的参数可以用_代替

val book = Book(1, "英语")
val (id, _) = book

9.::符号

1.常见的是得到类的class对象

//得到类的Class对象
startActivity(Intent(this@KotlinActivity, MainActivity::class.java))
//内联函数和reified后续介绍
inline  fun < reified T> Gson.fromJson(json:String):T
{
    return fromJson(json, T::class.java)
}

2.方法的引用

var setBook = setOf("hello", "hi", "你好")
//    setBook.forEach { print(it)}
    setBook.forEach(::print)

10.@符号

1.限定this的类型

class User {
    inner class State{
        fun getUser(): User{
            //返回User
            return this@User
        }
        fun getState(): State{
            //返回State
            return this@State
        }
    }
}

2.跳出双层for循环

loop@ for (itemA in arraysA) {
     var i : Int = 0
      for (itemB in arraysB) {
         i++
         if (itemB > 2) {
             break@loop
         }

         println("itemB:$itemB")
     }

}

3.命名函数自动定义标签（这个还不是很明白）

fun fun_run(){
    run {
        println("lambda")
    }
    var i: Int = run {
        return@run 1
    }
    println("$i")
    //匿名函数可以通过自定义标签进行跳转和返回
    i = run (outer@{
        return@outer 2
    })
    println(i)
}

4.从循环方法中跳出

fun forEach_label(ints: List< Int>)
{
    var i =2
    ints.forEach {
        //forEach中无法使用continue和break;
//        if (it == 0) continue //编译错误
//        if (it == 2) /*break //编译错误 */
        print(it)
    }
     run outer@{
         ints.forEach {
             if (it == 0) return@forEach //相当于在forEach函数中continue,实际上是从匿名函数返回
             if (it == 2) return@outer //相当于在forEach函数中使用break,实际上是跳转到outer之外
         }
     }

    if (i == 3)
    {
        //每个函数的名字代表一个函数地址，所以函数自动成为标签
        return@forEach_label //等同于return
    }
}

11.{}符号

这个还有->应该是lambda表达式

// 一个参数
var callback: ((str: String) -> Unit)? = null
callback = { println(it)}
// 判断并使用
callback?.invoke("hello")

//两个参数
var callback2: ((name: String, age: Int) -> Unit)? = null
callback2 = { hello: String, world: Int -> println("$hello's age is $world") }
callback2?.invoke("Tom", 22)

var callback3 :((num1:Int, num2: Int)->String)? = null
//类型可以推断
callback3 = { num1, num2 ->
    var res:Int = num1 + num2
    res.toString()
}

println(callback3?.invoke(1, 2))

12.?问号

表示对象可能为空

//在变量类型后面加上问号，代表该变量是可空变量
var name: String? = "zhangsan"
/**
 * 如果str不能转为Int类型，则返回null
 */
fun parseInt(str: String): Int? {
  // (代码略)
}
b?.length //如果 b非空，就返回 b.length ，否则返回 null，这个表达式的类型是 Int? 。