* [20、takeIf 内置函数](about:blank#20takeIf__452)
* [21、takeUnless 内置函数](about:blank#21takeUnless__471)
================================================================
任何语言都有自己的特性，了解特性，才能深入的学习
// kotlin 在声明参数的时候，默认是不可空类型。
var name: String = "tiger"
// name = null 如果赋值为null 将会报错， 可以赋值成 空串 ""
println(name)
// 但是我们在声明时，使用 ？ 指定成可空类型
var name2: String ?
name2 = null
name2 = "tiger"
println(name2)
var name: String ?
name = "tiger"
name = null
// name 是可空类型，可能是null 想要使用name，必须给出补救措施，在name后面添加 ？ 符号
// name 是可空类型 如果真的是null，？后面的代码不执行，就不会引发空指针异常
val str = name?.capitalize()
println(str)
var name: String? = null
name = "tiger"
name = ""
// name 是可空类型，可能是null 想要使用name，必须给出补救措施，在name后面添加 ？ 符号
// name 是可空类型 如果真的是null，？后面的代码不执行，就不会引发空指针异常
val str = name?.let {
// 如果能进入这里，it 一定不为null
if (it.isBlank()){ // isBlank name是空串 "" 没有内容
"Default"
}else{
"我是：$it"
}
}
println(str)
var name: String? = null
// name 是可空类型，可能是null 想要使用name，必须给出补救措施，在name后面添加 ？ 符号
name = "tiger"
// !! 断言操作符，和Java一样，不论name 是否为空，都会走后面的代码
// 如果不能保证name 被赋值，就会出现崩溃的情况
val str = name!!.capitalize()
println(str)
var name: String? = null
// name 是可空类型，可能是null 想要使用name，必须给出补救措施，在name后面添加 ？ 符号
if (name != null){ // if 也算是补救措施，代码会自动识别， 和Java一样
val str = name.capitalize()
println(str)
}else{
println("name is null")
}
var name: String? = "tiger"
name = null
// ?: 空合并操作符， 如果name 等于 null ，就会执行 ?: 后面的区域
println(name ?: "原来你没名字啊")
// let 函数 + 空合并操作符
println(name?.let { "$it" ?: "原来你没名字啊" })
try {
var name: String? = null
checkException(name)
println(name!!.capitalize())
}catch (e: Exception){
println("啊呀，又出差了 $e")
}
fun checkException(name: String?) {
name ?: throw CustomException()
}
// 自定义的异常
class CustomException : IllegalArgumentException("传null 还想使用 非空断言操作符？不出错才怪呢")
val info = "You are handsome."
val indexOf = info.indexOf(".")
println(info.substring(0, indexOf))
// kotlin 基本使用下面的这种方式截取， 从0 直到（until） indexOf
println(info.substring(0 until indexOf))
val jsonText = "张三，王五，大漂亮，杨美丽"
// list 自动类型推断成 list == List<String>
val list = jsonText.split("，")
// 直接输出list 集合
println(list)
// C++ 里面有解构操作。 kotlin 里面也有解构操作
val (v1, v2, v3, v4) = list
println("解构之后的4个数据，分别是: v1:$v1, v2: $v2, v3: $v3, v4: $v4")
val sourcePwd = "qwertyuiopasdfghjklzxcvbnm"
println(sourcePwd)
// 加密操作：就是把字符替换打乱的操作
val newPwd = sourcePwd.replace(Regex("[asdwq]")){
when(it.value){ // 轮询字符串中的每个字符
"a" -> "2"
"s" -> "4"
"d" -> "3"
"w" -> "5"
"q" -> "7"
else -> it.value //不做任何操作，直接返回原值
}
}
println(newPwd)
// 解密操作
val sourcePwdNew = newPwd.replace(Regex("[24357]")){
when(it.value){
"2" -> "a"
"4" -> "s"
"3" -> "d"
"5" -> "w"
"7" -> "q"
else -> it.value
}
}
println(sourcePwdNew)
// == 是内容的比较，相当于Java 中的 equals()
// === 是引用的比较，对比的是状态池里面的引用
val name1 = "Tiger"
val name2 = "tiger"
val name3 = "tiger"
val name4 = name2.capitalize()
println(name1 === name2)
println(name3 == name2)
println(name1 === name4)
val str = "qwertyuiopasdfghjklzxcvbnm"
str.forEach {
// it 隐式函数，是str 中的每一个字符
println("遍历出来的数据 $it")
}
val number: Int = "666".toInt()
println(number)
val number1: Int = "666.6".toInt() // 字符串里面放入double 类型，转换成int 类型，会失败导致程序崩溃
println(number1)
// 解决 上面崩溃的问题
val number2: Int? = "666.6".toIntOrNull()
println(number1 ?: "字符类型转换失败，返回一个null ")
// 四舍五入 算法转int
println(54.2334.toInt())
// 四舍五入 算法转int
println(54.2334.roundToInt())
// 保留小数点后三位
val r = "%.3f".format(53.3432212)
println(r)
val info = "The tiger you are the most handsome"
// 普通写法
println("info 字符串的长度是 ${info.length}")
println("info 的最后一个字符是 ${info[info.length-1]}")
println("info 全部转换成大写字符 ${info.toUpperCase()}")
// apply 内置函数的方式
// info.apply 的特点：apply 函数始终是返回 info 本身 String 类型
val str = info.apply {
// 大部分情况下，匿名函数，都会持有一个it ，但是apply 不会持有it，却会持有当前 this == info 本身
println("info 字符串的长度是 ${this.length}")
println("info 的最后一个字符是 ${info[this.length-1]}")
println("info 全部转换成大写字符 ${this.toUpperCase()}")
// 也可以直接把this 去掉
println("info 字符串的长度是 ${length}")
println("info 的最后一个字符是 ${info[length-1]}")
println("info 全部转换成大写字符 ${toUpperCase()}")
}
println(str)
// 真正使用apply 函数的方法如下
// info.apply 特点： apply 函数始终是返回 info 本身，可以使用链式调用
info.apply {
println("info 字符串的长度是 ${length}")
}.apply {
println("info 的最后一个字符是 ${info[length-1]}")
}.apply {
println("info 全部转换成大写字符 ${toUpperCase()}")
}
// 文件读取小例子
// 普通写法
val file = File("/Users/tiger/Desktop/aaa.text")
file.setExecutable(true)
file.setReadable(true)
println(file.readLines())
// apply 写法
val r = file.apply {
setExecutable(true)
}.apply {
setReadable(true)
}.apply {
println(file.readLines())
}
// 普通方式，对集合 中的第一个数据进行相加
val list = listOf(4, 3, 43, 345, 2)
val value1 = list.first()
val result = value1 + value1
println("普通方式 集合第一个数字相加和 $result")
// let 方式，对集合 中的第一个数据进行相加
val result2 = list.let {
// 隐式函数 it == list 集合本身
it.first() + it.first() // 匿名函数的最后一行，作为返回值，确定返回值类型
}
println(result2)
println(getMethod("tiger"))
println(getMethod2("tiger"))
// 普通方式 对值判断null 并返回
fun getMethod(value: String?): String {
return if (value == null) "你传递的内容是个null" else "你传递了一个数据过来，我还给你 $value"
}
// let方式 + 空合并操作符 对值判断null 并返回
fun getMethod2(value: String? ) : String {
return value?.let {
"你传递了一个数据过来，我还给你 $it"
} ?: "你给了一个null ，还想让我返回？"
}
val str = "tiger is Ok"
str.run {
// run 匿名函数和 apply 一样，它们都有一个 this == str 本的函数
println("输入的字符串是： $this")
}
/**
* 使用run 写一个小例子
* 1、具名函数判断字符串的长度，
* 2、具名函数判断长度是否合格
* 3、具名函数 获得合格参数
* 4、打印输出
*/
str.run(::isLong)
.run(::showText)
.run(::resultText)
.run(::println)
// 再来一个匿名函数的例子
str.run {
length > 5
}
