Kotlin基础学习第3章—内置类型

最新推荐文章于 2021-12-24 13:55:49 发布

王睿丶

最新推荐文章于 2021-12-24 13:55:49 发布

阅读量391

点赞数 1

分类专栏： Kotlin 文章标签： android 移动开发 kotlin android studio

本文链接：https://blog.csdn.net/qq_27494201/article/details/106422869

版权

Kotlin 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

文章目录

一丶基本类型

声明变量
声明变量（类型自动推导）
易混淆的 Long 类型标记
Kotlin 的数值转换
Kotlin 的字符串

声明变量
在这里插入图片描述
声明变量（类型自动推导）

易混淆的 Long 类型标记

Kotlin 的数值转换

Kotlin 的字符串

总结

在这里插入图片描述

二丶数组

区别
数组的创建
数组的长度
数组的读写
数组的遍历写法一
数组的遍历写法二
数组的包含关系

区别：
在这里插入图片描述
数组的创建：

数组的长度

数组的读写：

数组的遍历写法一：

数组的遍历写法二：

数组的包含关系：

package com.wangrui.kotlin

fun main(){

    // 方式一：创建一个可变长度的整型数组
    val c0 = intArrayOf(1,2,3,4,5)
    // 方式二：创建整型数组并且按照每个下标（0~4）依次+1 赋值给数组 c1
    val c1 = IntArray(5){it + 1}
    // contentToString() — 将内容转换成字符串格式
    println(c1.contentToString());

    val c0 = intArrayOf(1,2,3,4,5);
    // 创建整型数组并且按照每个下标（0~4）依次(坐标+1)*3 赋值给数组c1
    val c1 = IntArray(5){(it + 1)*3}

    println(c0.contentToString());
    println(c1.contentToString());

    val a = IntArray(5)
    // 得到集合长度
    println(a.size)

    val d = arrayOf("Hello","World")
    d[1] = "Kotlin"
    println("${d[0]},${d[1]}")

    val e = floatArrayOf(1f,2f,3f,4f,5f)
    // in—遍历
    for (a in e){
        println(a)
    }

    // array.foreach()    高阶函数遍历
    //遍历集合e，并将每次循环得到的每个值赋给a，然后打印a
    e.forEach { a -> println(a) }
}

在这里插入图片描述

三丶区间

区间的创建
开区间
倒序区间
区间的迭代
区间的包含关系
区间的应用写法一
区间的应用写法二

区间的创建
在这里插入图片描述
开区间

倒序区间

区间的迭代

区间的包含关系

区间的应用写法一：

区间的应用写法二：

package com.wangrui.kotlin

fun main(){
    // in—包含
        if (1f in e){
        println("包含")
    }

    if (20f !in e){
        println("不包含")
    }

    //区间（正序）
    val intRange = 1..10
    val charRange = 'a'..'z'
    val longRange = 1L..100L

    val floatRange = 1f..2f
    val doubRange = 1.0..2.0

    // joinToString() — 加入并转成字符串，join — 加入
    println(intRange.joinToString())
    // toString() — 转成字符串
    println(floatRange.toString())



    // 止步——step
    val intRangeWitStep = 1..10 step 2
    val charRangeWithStep = 'a'..'z' step 2
    val longRanWitStep = 1L..100L step 5

    println(longRanWitStep.joinToString())



    // 倒序区间
    val intRangeReverse = 10 downTo 1
    val charRangeReverse = 'z' downTo 'a'
    val longRangeReverse = 100L downTo 1L

    println(longRangeReverse.joinToString())



    val array = intArrayOf(1,3,5,7)
    //遍历方式1
    // until — 直到，所以是 0 到 数组.size
    for (i in (0 until array.size)){
        println(array[i])
    }

    //遍历方式2
    // indices — 索引，所以 array[i] = 对应元素
    for (i in array.indices){
        println(array[i])
    }

}

在这里插入图片描述

四丶集合框架

简介
集合框架的接口类型对比
集合框架的创建【List】
集合框架的创建【Map】
集合实现类服用与类型别名
集合框架的读写
集合框架的修改
集合框架的读写2
集合框架的读写3
Pair
Triple
思考题

简介
在这里插入图片描述
集合框架的接口类型对比

集合框架的创建【List】

集合框架的创建【Map】

集合实现类服用与类型别名

集合框架的读写

集合框架的修改

集合框架的读写2

集合框架的读写3
在这里插入图片描述
Pair

Triple

思考题

package com.wangrui.kotlin

fun main(){
    //  创建List集合的方式一：不能添加元素或者删除元素
    val intList: List<Int> = listOf(1,2,3)
    //  创建List集合的方式二：可以添加元素或者删除元素
    val intList2: MutableList<Int> = mutableListOf(1,2,3)



    //  创建Map集合的方式一：不能添加元素或者删除元素
    //  Any等价于Java中的 Object
    //  to 可以理解为：Key to Value
    val map:Map<String,Any> = mapOf("name" to "benny","age" to 20)
    //  创建Map集合的方式二：可以添加元素或者删除元素
    val map2:Map<String,Any> = mutableMapOf("name" to "benny","age" to 20)



    val stringList:MutableList<String> = mutableListOf("98","99","100","num：1","num：2")
    //  对集合添加元素、删除元素
    for (i in 0..10){
    //      添加元素
//        stringList += "num：$i" // 等价于  stringList.add("num：$i")
    //结果为：[98, 99, 100, num：1, num：2, num：0, num：1, num：2, num：3, num：4, num：5, num：6, num：7, num：8, num：9, num：10]
    //      删除元素
        stringList -= "num：$i" // 等价于  stringList.remove("num：$i")
    //当上面代码注释后，结果为：[98, 99, 100]
    }

    println(stringList)




    //  Map集合赋值
    stringList[5] = "HelloWorld"    //等价于 stringList.set(5,"HelloWorld")
    val valueAt5 = stringList[5]    //  等价于 String valueAt5 = stringList.get(5)

    val map = HashMap<String,Int>()
    map["Hello"] = 10
    //  '[]' 内的值实际上就是Key
    println(map["Hello"])


    //  解构：val (x,y) = pair
    val pair = "Hello" to "Kotlin"
    val pair2 = Pair("Hello","Kotlin")
    val first = pair.first
    val second = pair.second
    println(first)
    println(second)


    //  解构：val (x,y,z) = triple
    val triple = Triple("x",2,3.0)
    val first = triple.first
    val second = triple.second
    val third = triple.third

    println(first)
    println(second)
    println(third)

    
    
    // 作业：
    // 一、集合该如何遍历
    val intNumber: List<Int> = listOf(1,2,3,4,5,6)
    intNumber.forEach{a -> println(a)}

    //二、集合的包含关系如何判断？
    val intNumber2: List<Int> = listOf(1,2,3,4,5,6)
    if (4 in intNumber2){
        println("4包含于集合intNumber2")
    }
    if (400 !in intNumber2){
        println("400不包含于集合intNumber2")
    }

    //三丶Scala 选择自己全新构建了一套集合框架，为什么 Kotlin没有？


}

在这里插入图片描述

五丶函数

函数的定义
函数的类型
函数的引用
变长参数【Java】与【Kotlin】版
多返回值
默认参数
默认参数 — 错误实例【X】
解决办法【√】— 通过：具名参数

1、函数的定义
在这里插入图片描述

2、函数的类型
在这里插入图片描述
3、函数的引用

4、变长参数
【Java】
在这里插入图片描述
【Kotlin】

多返回值

默认参数

默认参数 — 错误实例【X】

解决办法【√】— 通过：具名参数

package com.wangrui.kotlin.bennyhuo

fun main(vararg args: String) {
//    println(args.contentToString())

    // 这时的x 为函数类型，具体为：(Foo, String, Long)->Any
    val x:(Foo, String, Long)->Any = Foo::bar
    val x0: Function3<Foo, String, Long, Any> = Foo::bar
    //三者等价
    // (Foo, String, Long)->Any = Foo.(String, Long)->Any = Function3<Foo, String, Long, Any>

//    val y: (Foo, String, Long) -> Any = x
    val y: Foo.(String,Long) -> Any = x
    val z: Function3<Foo, String, Long, Any> = x

    //调用yy函数，并传入x函数类型作为函数参数
    yy(y)

    //拿到 fun foo() { } 的引用
    val f: ()->Unit = ::foo
    //拿到 fun foo(p0: Int): String { return  "" } 的引用
    val g: (Int) ->String = ::foo
    /**
     * 拿到：
         class Foo {
            fun bar(p0: String, p1: Long): Any{
            println("one:$p0 Long:$p1")
            return ""
            }
          }
        的引用
     */
    val h: (Foo, String, Long)->Any
            = Foo::bar

    // 变长参数
    multiParameters(1, 2, 3, 4)

    //利用具名函数，将值准确传给 y: String
    defaultParameter(y = "Hello")

    //解构表达式
    val (a, b, c) = multiReturnValues() //实现 伪多返回值的场景
    val r = a + b
    val r1 = a + c

}

// p：是一个函数类型，这个函数其实就是 Foo::bar
fun yy(p: (Foo, String, Long) -> Any){
    p(Foo(), "Hello", 3L)   // Foo()指的是：类的引用，调用对应函数，并进行传参
}

class Foo {
    fun bar(p0: String, p1: Long): Any{
        println("one:$p0 Long:$p1")
        return ""
    }
}

fun foo() { }
fun foo(p0: Int): String { return  "" }

//利用具名函数，将值准确传给 y: String
fun defaultParameter(x: Int = 5, y: String, z: Long = 0L){

}

// 变长参数
fun multiParameters(vararg ints: Int){
    println(ints.contentToString())
}

// 伪多返回值
fun multiReturnValues(): Triple<Int, Long, Double> {
    return Triple(1, 3L, 4.0)
}

总结
在这里插入图片描述

六丶案例：四则计算器

package com.wangrui.kotlin

/*
    input: 3 * 4
 */

fun main(vararg args: String){
    if (args.size < 3){
        return showHelp()
    }

    //▲暂时不是很理解 to::plus
    val operators = mapOf(
        "+" to::plus,
        "-" to::minus,
        "*" to::times,
        "/" to::div
    )

    val op = args[1]
    val opFunc = operators[op]?:return showHelp()

    try {
        println("Input：${args.joinToString(" ")}")
        println("Output：${opFunc(args[0].toInt(),args[2].toInt())}")
    } catch (e: Exception) {
        println("Invalid Arguments.")
        showHelp()
    }
}

fun plus(arg0:Int,arg1:Int):Int{
    return arg0 + arg1
}

fun minus(arg0:Int,arg1:Int):Int{
    return arg0 - arg1
}

fun times(arg0:Int,arg1:Int):Int{
    return arg0 * arg1
}

fun div(arg0:Int,arg1:Int):Int{
    return arg0 / arg1
}

fun showHelp(){
    println("""
        
        Simple Calculator:
        Input: 3 * 4
        Output:12
    """.trimIndent())
}

七丶本章小结

在这里插入图片描述

王睿丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Kotlin基础学习第3章—内置类型

文章目录一丶基本类型二丶数组三丶区间四丶集合框架五丶函数六丶案例：四则计算器七丶本章小结一丶基本类型二丶数组package com.wangrui.kotlinfun main(){ 方式一：创建一个可变长度的整型数组 val c0 = intArrayOf(1,2,3,4,5) 方式二：创建整型数组并且按照每个下标（0~4）依次+1 赋值给数组 c1 val c1 = IntArray(5){it + 1} println(c1.contentToSt
复制链接

扫一扫