Kotlin 控制流作为表达式和When语句

package com.init.demo.demo1

import java.io.IOException
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths

//Kotlin中控制流作为表达式
fun main(args: Array<String>) {

    /**
     * when不限制分支的组合次数
     * 混合型类型转换、语句、函数、常量都可以
     */
    if_elseAsExpression()
    try_catchAsExpression()
    println(whenAsReturnExpression(1))
    whenExpression(1)
    println(whenFunAsExpression(0))
    println(whenFunAsExpressionisZereo(0))
    println(isPositive(0))
    println(isPositiveSuo(0))
    println(singleNumber(0))
    println(singleNumberSuo(0))
    println(listNumber(0))
    println(listNumberSuo(0))
    println(isKotlinAny(0))
    println(isKotlinAnySuo(0))

    //无参数when，多用于重大的语句判断
    noParamsWhen(3,4)

   /* 
    输出：
    true
    false
    false
    a=1
    false
    false
    false
    true
    true
    true
    true
    false
    false
    false
    false
    a>b*/
}

/**
 * 无参数when，多用于重大的语句判断
 */
fun noParamsWhen(x:Int,y:Int){
    when{
        x>y -> println("a<b")
        x<y -> println("a>b")
        else -> println("a=b")
    }
}

/**
 * 智能转换类型
 * Any类型：对其实际类型无限制，这样的类型在运行时用来检测
 */

fun isKotlinAny(any:Any) :Boolean{
    return  when(any){
        is String -> any.startsWith("Kotlin")
        else -> false
    }
}
/**
 * 智能转换类型 简化形式
 * Any类型：对其实际类型无限制，这样的类型在运行时用来检测
 */
fun isKotlinAnySuo(any:Any) :Boolean=  when(any){
        is String -> any.startsWith("Kotlin")
        else -> false
}

/**
 * 数据函数Math.abs(x)作为判断条件
 */
fun isPositive(x: Int):Boolean{
    return  when(x){
        Math.abs(x) -> true
        else -> false
    }
}
/**
 * 数据函数Math.abs(x)作为判断条件
 * 简化形式
 */
fun isPositiveSuo(x: Int) = when(x){
        Math.abs(x) -> true
        else -> false
    }

/**
 * in 判断值 处于某个区间的范围内作为判断条件
 */
fun singleNumber(x: Int):Boolean{
    return  when(x){
        in -9..9 -> true
        else -> false
    }
}

/**
 *  in 判断值 处于某个区间的范围内作为判断条件
 * 简化形式
 */
fun singleNumberSuo(x: Int) = when(x){
    in -9..9 -> true
    else -> false
}
/**
 * 集合形式 作为判断条件
 */
fun listNumber(x: Int):Boolean{
    return  when(x){
        in arrayOf(1,2,3,4,5,6) -> true
        else -> false
    }
}

/**
 * 集合形式 作为判断条件
 * 简化形式
 */
fun listNumberSuo(x: Int) = when(x){
    in arrayOf(1,2,3,4,5,6) -> true
    else -> false
}



/*
 *Kotlin 中 if-else ,try-catch控制流本身就是表达式
 * 这种变化可以直接把值赋值给变量，从函数返回值
 * 或者直接把控制流作为函数的参数
 */
fun if_elseAsExpression() {

    val a = 5
    val b = 3

    val isToday = if (a > b) true else false
    println(isToday)
}

fun try_catchAsExpression() {

    val readError = try {

        readFile(Paths.get("D:", "/user/bin/ruby.md"))
        true
    } catch (e: IOException) {
        false
    }
    println(readError)
}

/**
 * when 是Java语句中switch语句的清理升级版
 * 他可以对一个值细致化的判断
 * 但要求把所有情况列举完毕
 */
fun whenExpression(x: Int) {
    checkNUmber(1)
    val isZereo = when (x) {
        Int.MAX_VALUE ->true
        Int.MIN_VALUE ->false
        else ->false
    }
    println(isZereo)
}

/**
 * when 语句直接赋值给函数
 */
fun whenFunAsExpressionisZereo(x: Int)=  when (x) {
    Int.MAX_VALUE ->true
    Int.MIN_VALUE ->false
    else ->false
}

/**
 * when作为表达式直接返回给函数
 * 整个语句被赋予函数本省
 */
fun  whenAsReturnExpression(x:Int) :Boolean{

    return  when(x){
        Int.MAX_VALUE ->true
        Int.MIN_VALUE ->false
        else ->false
    }
}

/**
 * 函数：when赋值给变量，然后返回给函数
 */
fun whenFunAsExpression(x: Int): Boolean {
    val isZereo = when (x) {
        Int.MAX_VALUE ->true
        Int.MIN_VALUE ->false
        else ->false
    }

    return  isZereo
}

/**
 * When语句实例
 * when语句的最后一个分支是else 是所有情况的例外处理
 * 这样就可以吧x的情况进行例举和处理
 */
fun checkNUmber(x: Int) {
    when (x) {
        0 -> println("a=0")
        1 -> println("a=1")
        else -> println("a!=1 || a!=0")
    }
}

/**
 * kotlin文件读取
 */
fun readFile(path: Path): Unit {

    val input = Files.newInputStream(path)
    var byte = input.read()
    while (byte != -1) {
//        println(byte)
        byte = input.read()

    }

}