1kotlin可空性

提前在编译期强迫重视null问题
除非另有规定，变量不能为null值。
为了避免NullPointerException，Kotlin的做法是不让我们给非空类型变量赋null值，但null在Kotlin中依然存在。

fun main(){
  var str = "asds"
  str = null //报错！！

  var str:String ?="asdasd"
  str = null
}

安全调用操作符

Kotlin区分可空类型和非可空类型，所以你要一个可空类型变量运行，而他有可能不存在，对于这种潜在危险，编译器时刻警惕着。为了应对这种风险，Kotlin不允许你在可控类型值上调用函数，除非你主动接受安全管理

选项一：安全调用操作符（？.）
如果遇到null值，他就跳过函数调用，而不是返回null。

fun main(){
  val str = readLine()?.capitalize()
  println(str)
}

使用带let的安全调用

安全调用允许在可空类型上调用函数，但是如果还想做点额外的事比如创建新值，或判断不为null就调用其他函数，怎么办？可以使用带let函数的安全调用操作符。你可以在任何类型上调用let函数，他的主要作用是让你在指定的作用域内定义一个或多个变量。

fun main(){
  val str = readLine()?.let{
    if(it.isNotBlank()){
      it.capitalize()
    }else{
      "butterfly"
    }
  }
  println(str)
}

非空断言操作符（!!.）

选项二：非空断言操作符
!!.又称感叹号操作符，当变量是null时，会抛出KotlinNullPointerException。

fun main(){
  val str = readLine()!!.capitalize()
  println(str)
}

当变量是null时 ，会去执行函数。

对比使用if判断null值情况

选项三：使用if判断null值情况

fun main(){
  var str = readLine()
  if(str!= null){
    str = str.capitalize()
  }else{
    println("为null。")
  }

  //安全操作符支持链式调用
  str = str?.capitalize()?.plus(" is great.")

  println(str)
}

空合并操作符（?:）

?:操作符的意思是，如果左边的求值结果为null，就用右边的结果值。

val str = str ?: "butterfly"

空合并操作符也可以和let函数一起使用来替代if/else语句

fun main(){
  var str = readLine()
  str = str?.let{it.capitalize()}?:"butterfly"
  println(str)
}

异常处理与自定义异常

fun main(){
  car number:Int ?=null
  try{
    checkOperation(number)
    number!!.plus(1)//这里会报异常
  }catch(e:Exception){
    println(e)
  }
}
fun checkOperation(number:Int?){
  number?:throw UnskilledException ()
}

//自定义异常
class UnskilledException :IlldgalArgumentException("操作不当")

先决条件函数

可以抛出带自定义信息的异常，可以用它定义先决条件，条件必须满足，目标代码才能执行。

9.png

fun main(){
  car number:Int ?=null
  try{
    checkOperation(number)
    number!!.plus(1)//这里会报异常
  }catch(e:Exception){
    println(e)
  }
}
fun checkOperation(number:Int?){
  checkNotNull(number,{"Something error"})
}

substring

字符串截取，substring函数支持IntRange类型（表示一个整数范围的类型）的参数，until创建的范围不包括上限值

const cal NAME = "Jimmy's friend"
fun main(){
  val index = NAME.indexOf('\'')
  //NAME.substring(0,index)
  val str= NAME.substring(0 until index)
  println(str)
}

split

split函数返回的是List集合数据，List集合又支持解构语法特性,它允许你在一个表达式里给多个变量赋值，解构常用来简化变量的赋值

const val NAMES = "jack,jacky,jason"
fun main(){
  val data :List<String>= NAMES.split(',')
  //data[0]

  val(origin,dest,proxy) = NAMES.split(',')

  println("$origin $dest $proxy")
}

replace

fun main(){
  val str1 = "The people's Republic of China."
  //第一个参数是正则表达式，用来决定要替换那些字符
  //第二个参数是匿名函数，用来确定该如何替换正则表达式搜索到的字符
  val str2:String = str1.replace(Regex("[aeiou]")){
    when(it.value){
      "a"->"8"
      "e"->"6"
      "i"->"9"
      "o"->"1"
      "u"->"3"
      else ->it.value
    }
  }
  println(str1)
  println(str2)
}

==与===比较

==检查两个字符串中的字符是否匹配；
===检查两个变量是否指向内存堆上同一个对象。

fun main(){
  val str1 = "Jason"
  val str2= "jason".capitalize()

  println("$str1, $str2")
  println(str1==str2)//true
  println(str1===str2)//false
}

字符串遍历

fun main(){
  val str1 = "The people's Republic of China.".forEach{
    print("$it *")
  }

数字类型的安全转换函数

kotlin所有数字类型都是有符号的

10.png

kotlin提供了toDoubleOrNull和toIntOrNull这样的安全转换函数，如果树脂不能正确转换，与其触发异常不如干脆返回null值。

fun main(){
  //抛出异常
  //val number:Int = "8.98".toInt()
  val number:Int ?= "8.98".toIntOrNull()

  println(number)
}

Double转int与类型格式化

double转int
精度损失与四舍五入

fun main(){
  //精度损失
  println(8.956756.toInt())//8
  //四舍五入
  println(8.956756.roundToInt())//9

  //格式化 
  val s = "%.2".format(8.956756)
  println(s)//8.96 四舍五入了
}

标准库函数

apply

可以看做一个配置函数，你可以传入一个接收者，然后调用一系列函数来配置它以便使用，如果提供lambda给apply执行，他会返回配置好的接收者。

fun main(){
  //配置一个file实例
  val file1 = File("E://i have a dream.txt")
  file1.setReadable(true)
  file1.setWritable(true)
  file1.setExrcutable(false)
  //使用apply
  val file2 = File("E://i have a dream.txt").apply{
    setReadable(true)
    setWritable(true)
    setExrcutable(false)
  }
}

可以看到，调用一个函数类配置接受者时，变量名就省略掉了，这是因为在lambda表达式里，apply能让每个配置函数都作用于接收者，这种行为有时又叫做相关作用域，因为lambda表达式里的所有函数调用都是针对接收者的，或者说，他们是针对接收者的隐式调用。

let

能使某个变量作用于其lambda表达式里，让it关键字能引用它。let与apply比较，let会把接收者传递给lambda，而apply什么都不传，匿名函数执行完，apply会返回当前接收者，而let会返回lambda的最后一行

fun main(){
  val res = listOf(3,2,1).first().let{
    it * it
  }
  println(res)//9

  println(format("Jack"))
}
fun format(guestName:String?):String{
  return guestName?.let{
    "Welcome, $it."
  }?:"what's your name?"
}

run

光看作用于来说，run和apply差不多，但run函数不返回接收者，run返回的是lambda结果，也就是true或者false

import java.io.File

fun main(){
  val file = File("E://i have a dream.txt")
  val result :Boolean = file.run{
    readText().contains("great")
  } 

  println(result)//true
}

run 也可以用来执行函数引用

fun main (){
  val result = "The people's Republic of China.".run(::isLong)
  println(result)
  //当有多个函数调用，run的优势就显而易见了
  "The people's Republic of China."
        .run(::isLong)
        .run(::showMessage)
        .run(::println)
}

fun isLong(name :String) = name.length>=10

fun showMessage(isLong:Boolean):String{
  return if(isLong){
     "Name is too long."
  }else{
     "please rename."
  }
}

with

with函数是run函数的变体，他们功能行为是一样的，但是with的调用凡事不同，需要值参作为其第一个参数传入

fun main(){
  val res = "The people's Republic of China.".run{
    length>=10
  }

  val isToolong:Boolean = with("The people's Republic of China."){
    length>=10
  }
}

also

和let类似，也是把接收者作为值参传给lambda，但有一点不同，also返回接收者对象，而let返回lambda结果。因为这个差异，also尤其适合针对同一原始对象，利用副作用做事，既然also返回的是接收者对象，你就可以基于原始接受者对象执行额外的链式调用

import java.io.File

fun main(){
  var fileContents:List<String>//没有初始化
  File("E://i have a dream.txt")
        .also{
          println(it.name)
        }.also{
          fileContents = it.readLines()//初始化
        }
  println(fileContents)
}

takeIf

takeIf函数需要判断lambda中提供的条件表达式，给出true或false结果。如果是true，从takeIf函数返回接收者对象，如果是false，则返回null。如果需要判断某个条件是否满足，再决定是否可以赋值变量或者执行某项任务，takeIf就非常有用，概念上讲，takeIf函数类似if语句，但他的优势是可以直接在对象实例上调用，避免了临时变量赋值的麻烦。

import java.io.File
fun main(){
  val res :String? = File("E://i have a dream.txt")
        .takeIf{
          it.canRead()&&it.canWrite()
        }
        ?.readText()
  println(res)
}

takeUnless

takeIf的辅助函数takeUnless，只有判断你给定条件结果是false时，takeUnless才会返回原石接收者对象。

import java.io.File

fun main(){
  val fileContent3 :String? = File("E://i hava a dream.txt")
        .takeUnless{it.isHidden}
        ?.readText()
  println(fileContent3)
}

小结回顾