笔记：kotlin 学习第二天

作者: s酸菜 | 来源:发表于2018-07-11 10:47 被阅读0次

kotlin - for循环和foreach循环

fun main(args: Array<String>) {
    val str  = "abcd"
    /*---------------------------- for循环 ----------------------------*/
//    for (a in str) {
////        println(a)
////    }
////    for ((index,c) in str.withIndex()) {
////        println("index=$index c=$c")
////    }

    /*---------------------------- foreach ----------------------------*/
//    str.forEach {
//        println(it)
//    }
    str.forEachIndexed { index, c ->
        println("index=$index c=$c")
    }
}

kotlin - continue和break：continue和break只能用在for循环里不能用在foreach里面

fun main(args: Array<String>) {
    val str = "abcde"
//    for (c in str) {
//        //打印c 跳出循环
//        if(c=='c'){
//            continue
//        }
//        println(c)
//    }

    /*---------------------------- 高级for循环 ----------------------------*/
//    str.forEach {
//        return
//    }
}

kotlin - 标签处返回：@tag break@tag

fun main(args: Array<String>) {
    val str1 = "abc"
    val str2 = "123"
    //abc和123所有的组合
    tag@for (c1 in str1) {
        tag3@for (c2 in str2) {
            // b 2  后面的元素不需要再打印了
            println("$c1 $c2")
            if(c1=='b'&&c2=='2'){
                break@tag3
//                continue
//                return
            }
        }
    }

    println("最终执行的代码")
}

kotlin - while和do while循环

fun main(args: Array<String>) {
    //1到100
    var a= 101
//    while (a<=100){
//        println(a)
//        a++
//    }
    /*---------------------------- do while ----------------------------*/
    do {
        println(a)
        a++
    }while (a<=100)
}

kotlin - 区间定义：range rangeTo LongRange IntRange

fun main(args: Array<String>) {
    /*---------------------------- 定义1到100 ----------------------------*/
    val range1 = 1..100
    1 until 100 //[1,100)
    val range2 = IntRange(1,100)
    val range3 = 1.rangeTo(100)
    /*---------------------------- 长整形区间 ----------------------------*/
    val range4 = 1L..100L
    val range5 = LongRange(1L,100L)
    val range6 = 1L.rangeTo(100L)
    /*---------------------------- 字符区间 ----------------------------*/
    val range7 = 'a'..'z'
    val range8 = CharRange('a','z')
    val range9 = 'a'.rangeTo('z')

//    val range10 = '张'..'李'
}

kotlin - 区间遍历：i in range (index,i) in range.withIndex()

fun main(args: Array<String>) {
    val range = 1..100
    /*---------------------------- for ----------------------------*/
//    for (i in range) {
//        println(i)
//    }
//    for ((index,i) in range.withIndex()) {
//        println("index=$index i=$i")
//    }
    /*---------------------------- foreach ----------------------------*/
//    range.forEach {
//        println(it)
//    }
    range.forEachIndexed { index, i ->
        println("index=$index i=$i")
    }
}

kotlin - 反向区间和区间的反转：downTo reversed()

fun main(args: Array<String>) {
    /*---------------------------- 反向区间 ----------------------------*/
    //定义100到1的区间
    val range = 100 downTo 1
//    range.forEach {
//        println(it)
//    }
    /*---------------------------- 区间反转 ----------------------------*/
    val range1 = 1..100
    val range2 = range1.reversed()
//    range2.forEach {
//        println(it)
//    }
    for (i in range2 step 5) {
        println(i)
    }
}

kotlin - 数组的定义：ArrayOf IntArray Any

/**
 * Description:Any 类似 Object
 * 8中基本数据类型的数组可以通过Array创建或者通过自己的数据类型Array创建
 * 字符串数组只能通过Array创建
 */
fun main(args: Array<String>) {
    /*---------------------------- 定义数组并赋值 ----------------------------*/
    //张三  李四  王五
    val arr = arrayOf("张三","李四","王五")
    //10 20 30
    val arr1 = arrayOf(10,20,30)
    //a b c
    val arr2 = arrayOf('a','b','c')
    //"张三"  10  'a'
    val arr3 = arrayOf("张三",10,'a')
    /*---------------------------- 8中基本数组类型数组 ----------------------------*/
    //保存年纪信息
    val arr4 = IntArray(10)//new int[10]
    val arr5 = IntArray(10){//把数组里面每一个元素都初始化为30
        30
    }

//    BooleanArray
//    ByteArray
//    ShortArray
//    CharArray
//    FloatArray
//    DoubleArray
//    LongArray
//    StringArray//不能用
}

kotlin - 数组的遍历

    fun main(args: Array<String>) {

    val arr = arrayOf(1, 1, 3, 45, 6, 7)

    /*---------------------------- for ----------------------------*/

    for (i in arr) {
        println(i)
    }

    /*---------------------------- foreach ----------------------------*/

    arr.forEach {
        println(it)
    }
    
}

kotlin - 数组元素的修改：arr[2] = 6 arr.set(2,6)

fun main(args: Array<String>) {
    val array = arrayOf(1,2,3,4,5)
    //把3修改成9
    array[2] = 6

    array.set(2,9)

    array.forEach {
        println(it)
    }
}

kotlin - 数组元素角标的查找：indexOf()以及重载方法

fun main(args: Array<String>) {
    val array = arrayOf("张三","李四","张四","王五","张三","赵六")
    //查找第一个”张三”角标
    //返回第一对应的元素角标  如果没有找到返回-1
    val index1 = array.indexOf("张三")
    println(index1)
    //查找最后一个”张三”角标
    //找不到 返回-1
    val index2 = array.lastIndexOf("张三")
    println(index2)

    /*---------------------------- 高阶函数实现 ----------------------------*/
    //查找第一个姓”张”的人的角标
//    val index3 = array.indexOfFirst {
//        it.startsWith("张")
//    }
//    println(index3)
    //查找最后一个姓”张”的人的角标
    val index4 = array.indexOfLast { it.startsWith("张") }
    println(index4)

    val index5 = array.indexOfFirst { it=="张三" }
    println(index5)
}

kotlin - when表达式：->

fun main(args: Array<String>) {
    //7岁 开始上小学
    //12岁 开始上中学
    //15岁 开始上高中
    //18岁  开始上大学
    val age = 6
    //小功能
    val result = todo(age)
    println(result)
}

/**
 * 判断当前年纪做什么事情
 */
fun todo(age:Int):String{
    when(age){
        7-> return "开始上小学"

        12->{
            return "开始上中学"
        }
        15->{
            return "开始上高中"
        }
        18->{
            return "开始上大学"
        }
        else->{
            return "开始上社会大学"
        }
    }
}

kotlin - when表达式加强：in 1..6

/**
 * kotlin里面的when表达式原理:
 * 简单的when表达式通过switch语句实现
 * 复杂的when表达式通过if else来实现
 */
fun main(args: Array<String>) {
    //7岁 开始上小学
    //12岁 开始上中学
    //15岁 开始上高中
    //18岁  开始上大学
    val age = 20
    //小功能
    val result = todo1(age)
    println(result)
}

/**
 * 判断当前年纪做什么事情
 */
fun todo1(age:Int):String{
    when(age){
//        1-> return "没有上小学"
//        2-> return "没有上小学"
//        3-> return "没有上小学"
//        4-> return "没有上小学"
//        5-> return "没有上小学"
//        6-> return "没有上小学"

//        1,2,3,4,5,6-> return "没有上小学"
//        is Int->return "传递的是Int类型"//java判断类型  instanceof

        //在区间里面
        in 1..6-> return "没有上小学"

        7-> return "开始上小学"
        in 8..11->return "在上小学"

        12->{
            return "开始上中学"
        }
        13,14->return "正在上中学"
        15->{
            return "开始上高中"
        }
        16,17->return "正在上高中"
        18->{
            return "开始上大学"
        }
        in 19..22->return "正在上大学"
        else->{
            return "开始上社会大学"
        }
    }
}

kotlin - when表达式不带参数

fun main(args: Array<String>) {
    //7岁 开始上小学
    //12岁 开始上中学
    //15岁 开始上高中
    //18岁  开始上大学
    val age = 20
    //小功能
    val result = todo1(age)
    println(result)
}

/**
 * 判断当前年纪做什么事情
 */
fun todo1(age:Int):String{
    when{
        age==7->{
            return "开始上小学"
        }
        age==12->{
            return "开始上小学"
        }
        age==15->{
            return "开始上小学"
        }
        age==18->{
            return "开始上小学"
        }
        age in 1..100->{
            return ""
        }
        else->{
            return "开始上小学"
        }
    }
}

kotlin - when表达式：

fun main(args: Array<String>) {
    //7岁 开始上小学
    //12岁 开始上中学
    //15岁 开始上高中
    //18岁  开始上大学
    val age = 6
    //小功能
    val result = todo(age)
    println(result)

}

/**
 * 判断当前年纪做什么事情
 */
fun todo(age:Int):String{
    return when(age){
        7-> {
            println("找到了分支")
            10
             "开始上小学"
        }

        12->{
             "开始上中学"
        }
        15->{
             "开始上高中"
        }
        18->{
             "开始上大学"
        }
        else->{
             "开始上社会大学"
        }
    }
}

kotlin - 函数表达式：=

fun main(args: Array<String>) {
    var a = 10
    var b = 20
    //a+b
    println(add(a, b))
}
//函数体只有一行
//fun add(a:Int,b:Int):Int{
//    return a+b
//}
//函数体只有一行代码  可以省略{} 省略return 用=连接
//fun add(a:Int,b:Int):Int =  a+b
//返回值类型也不用写
fun add(a:Int,b:Int) =  a+b

fun sayHello(){
    println("hello")
    println("hello world")
}

kotlin - 函数表达式补充：函数变量 匿名函数

fun main(args: Array<String>) {
    var a = 10
    var b = 20
    //a+b
//    println(add(a, b))
    /*---------------------------- 函数引用:: ----------------------------*/
    //对象变量
    //函数变量
//    val padd= ::add//::获取add函数的引用
    //类似C语言函数指针
    //通过padd调用函数
//    println(padd(10, 20))
//    println(padd?.invoke(20, 30))//可以处理函数变量为空的情况下调用
    /*---------------------------- 函数变量 ----------------------------*/
    val padd:(Int,Int)->Int = {a,b->a+b}//匿名函数
    println(padd(10, 20))
}
//函数体只有一行
//顶层函数
//fun add(a:Int,b:Int):Int{
//    return a+b
//}

kotlin - 默认参数和具名参数：method= "GET"

fun main(args: Array<String>) {
//    sendRequest("http://www.baidu.com","GET")
//    sendRequest("http://www.baidu.com")
    sendRequest(method = "GET",path = "http://www.baidu.com")//具名参数 参数位置可以变化
}
fun sendRequest(path:String,method:String="GET"){//GET POST 默认参数
    println("请求路径=${path},method=${method}")
}

kotlin - 可变参数：vararg

fun main(args: Array<String>) {
    var a = 10
    var b = 20
    var c = 30
    //a+b+c
    val result = add(a, b,c,10,20,30,40,50)
    println(result)
}

/**
 * 只要是Int数据类型  无论你传递多少个我都能求他们的和  可变参数
 */
fun add(vararg a:Int):Int{//数组
   //a是什么类型?
   //智能类型推断
//    val newa = a
    var result = 0//和
    a.forEach {
        result += it
    }
    return result
}

kotlin - 异常：编译时异常 运行时异常

fun main(args: Array<String>) {
    var a = 10
    var b = 0

    //异常处理
    try {
        a / b
    } catch (e: ArithmeticException) {
        println("捕获到异常")
    }finally {
        println("最终要执行的代码")
    }


    /*---------------------------- koltin编译时异常 ----------------------------*/
    //kotlin不检查编译时异常
    //kotlin认为大部分的编译时异常都是没有必要的
    val file = File("a.txt")
    val bfr = BufferedReader(FileReader(file))
//    ArithmeticException
}

kotlin - 递归

fun main(args: Array<String>) {
    //阶乘  5阶乘  5*4*3*2*1  5*4的阶乘 1的阶乘 1 n的阶乘   n*(n-1)的阶乘
    //求n的阶乘
//    val result = fact(5)
//    println(result)

    val result = fibonacci(8)
    println(result)
}

/**
 * 求n的阶乘
 */
fun fact(n:Int):Int{
        if(n==1){
            return 1
        }else{
            return n* fact(n-1)
        }
}

//斐波那契数列  1 1 2 3 5 8 13 21 34 55
//第四斐波那契数列=第三个斐波那契数列+第二个斐波那契数列
//第n个   第n-2个  + 第n-1个
/**
 * 求第n个斐波那契数列
 */
fun fibonacci(n:Int):Int{
    if(n==1||n==2){
        return 1
    }else{
        return fibonacci(n-2)+ fibonacci(n-1)
    }
}

kotlin - 递归和迭代的对比

/**
 * 常见的需求:通过迭代和递归都可以解决 复杂的问题用递归更容易实现
 * 递归和迭代有什么优缺点呢?
 * StackOverflowError 递归如果递归的层级比较深容易栈内存溢出
 * 递归:优点:逻辑比较简单  容易实现  缺点:容易栈内存溢出(内存开销比较大)
 * 迭代:优点:内存开销小 缺点:抽象出数学模型
 */
fun main(args: Array<String>) {
    //求1到n的数据和  1到10  55  1到100 5050
//    val result = sum1(100000)
//    println(result)
    val result = sum2(100000)
    println(result)
}
//求1到n的和  1到10  1到9的和+10   1到n的和  1到n-1的和 + n
fun sum2(n:Int):Int{
    if(n==1){
        return 1
    }else{
        return n+ sum2(n-1)
    }
}
/**
 * 求1到n的和  通过迭代的方式求和
 */
fun sum1(n: Int): Int {//kotlin里面参数是固定  不能修改
    var result = 0
    var copyN = n
    while (copyN > 0) {
        result += copyN
        copyN--
    }
    return result
}

kotlin - 尾递归优化：tailrec

/**
 * 只有尾递归才能优化
 * 第一步:需要将递归转换为尾递归
 * 第二步:加上tailrec
 *
 * 尾递归优化的原理:将递归转换为迭代
 */
fun main(args: Array<String>) {
    val result = sum2(100000)
    println(result)
}

//fun sum2(n:Int):Int{
//    if(n==1){
//        return 1
//    }else{
//        return n+ sum2(n-1)//调用自身之后做了其他操作
//    }
//}


//尾递归
//
tailrec fun sum2(n:Int,result:Int=0):Int{
    if(n==1){
        return result+1
    }else{
        return sum2(n-1,result+n)//调用自身之后做了其他操作
    }
}

kotlin - 面向对象

fun main(args: Array<String>) {
    val girl = Girl()
    println(girl.name)
    println(girl.age)
    girl.greeting()

    val rect = Rect()
    println(rect.long)
    println(rect.width)
}
//矩形
class Rect{
    //静态属性
    var long:Int = 100
    var width:Int = 100
}
//妹子
class Girl{
    //静态属性
    var name:String = "李四"
    var age:Int = 20
    //动态行为
    fun greeting(){
        println("hello  你好")
    }
}

kotlin - 运算符重载

/**
 * kotlin里面每一个运算符对应的都是一个方法 运算符相当于是方法的简写
 * 第一步:找到对应的函数
 * 第二步:函数前加上operator
 */
fun main(args: Array<String>) {
    var a = 10
    var b = 20
    a.plus(b)

    val girl1 = Girl()
    val girl2 = Girl()
    girl2.name = "王五"
    val newGirl = girl1 + girl2
    println(newGirl)

//    println(newGirl.age)
}
class Girl{
    //定义对应的运算符函数
//    operator fun plus(girl:Girl):Girl{
//        return this
//    }
//    operator fun plus(age:Int):Girl{
//        this.age += age
//        return this
//    }
    operator fun plus(girl:Girl):Int{
        return this.age+girl.age
    }
    var name:String = "张三"
    var age:Int = 20
}

笔记：kotlin 学习第二天

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读