基础语法

添码座原创大约 6 分钟

变量和常量

// 只能用val定义常量
const val COUNT = 1

fun main() {
    // var定义的变量值可修改
    var num1 = 1
    println(num1)
    num1 = 2
    println(num1)

    // val定义只读变量，用val声明的其实就是常量
    val num2 = 3
    println(num2)
    // num2 = 4

    println(COUNT)
}

基本类型

Kotlin的基本数值类型包括Byte、Short、Int、Long、Float、Double等（Char是一个独立的数据类型）。

类型	位宽	最小值	最大值
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648（-2³¹）	2,147,483,647（2³¹ - 1）
Long	64	-9,223,372,036,854,775,808（-2⁶³）	9,223,372,036,854,775,807（2⁶³ - 1）
Float	32
Double	64

fun main() {
    // 默认是Int类型
    val a = 100
    println(a)

    // 超过Int则为Long类型
    val b = 8000000000
    println(b)

    // 数字后面显式加L表明为Long类型
    val c = 20L
    println(c)

    // 显式声明类型
    val d: Byte = 1
    println(d)

    // 默认是Double类型
    val e = 3.1415928888
    println(e)

    // 尾部加f或F显式表示这是一个Float类型的浮点数
    val f = 3.141593f
    println(f)

    // 自动推断为Char类型
    val g = '1'
    println(g)

    // 自动推断为Boolean类型
    val h = false
    println(h)

    // 自动推断为字符串类型
    val i = "1234567890"
    println(i)

    // 字符串模板
    val j = 1379
    println("The Result is $j")

    // 花括号${}可以用于任意表达式
    val k = "9527"
    println("9527 length is ${k.length}")

    // 字符串与转义字符串
    val l = "${'$'}9.99"
    val m = "\$9.99"
    println(l)
    println(m)

    // Kotlin同样支持三引号字符串，但只支持双引号，不支持单引号
    val n1 = """
        Hello Kotlin
    """
    val n2 = """
        Hello Kotlin
    """.trimIndent()
    // 也支持+操作符连接字符串
    println("n1 = " + n1)
    println("n2 = " + n2)

    // Kotlin通过toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()和toChar()来实现数字类型的强制转换
    val o = 100
    println(o.toString())
    println(o.toByte())
    println(o.toShort())
    println(o.toLong())
    println(o.toFloat())
    println(o.toDouble())

    // 二进制
    val p = 0b1101
    // 打印结果是十进制
    println(p)
    // 十六进制
    val q = 0xeda5f
    println(q)

    // ==和===的区别：==比较内容，===比较地址
    val str1 = "123"
    val str2 = "123"
    val str3 = java.lang.String("123")
    // 下面四个都是true
    println(str1 == str2)
    println(str1.equals(str3))
    println(str1 === str2)
    println(str1 == str3.toString())
    // false
    println(str1 === str3.toString())
}

数组类型

@OptIn(ExperimentalUnsignedTypes::class)
fun main() {
    // 使用arrayOf()创建并初始化数组元素
    val arrs1 = arrayOf(1, 2, 3, 4, 5)
    println(arrs1[1])

    // 使用arrayOfNulls()创建：创建一个指定大小的、所有元素都为null的数组
    val arrs2 = arrayOfNulls<String>(10)
    arrs2[0] = "hello"
    arrs2[1] = "kotlin"
    // hello kotlin
    println(arrs2[0] + " " + arrs2[1])
    // null
    println(arrs2[2])

    // 动态创建数组
    val arrs3 = Array(10) { i -> i * i }
    println(arrs3[0])
    println(arrs3[9])

    // 原生数据类型的数组
    val arrs4 = intArrayOf(1, 2, 3, 4, 5)
    println(arrs4[1])
    println("arrs4[1] + arrs4[3] = ${arrs4[1]} + ${arrs4[3]}")
    println("arrs4[1] + arrs4[3] = ${arrs4[1] + arrs4[3]}")
    // 大小为2，值为[9527, 9527]的整型数组，如果不给初始值，整数类型的默认值为0
    val arrs5 = IntArray(2) { 9527 }
    println(arrs5[1])
    // java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
    println(arrs5[2])

    val arrs6 = byteArrayOf(1, 2, 3, 4, 5)
    val arrs7 = ushortArrayOf(1u, 2u, 3u, 4u, 5u)
    val arrs8 = floatArrayOf(1f, 2f, 3f, 4f, 5f)
    val arrs9 = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
    val arrs10 = longArrayOf(1L, 2L, 3L, 4L, 5L)
    val arrs11 = charArrayOf('a', 'b', 'c', 'd', 'e')
    val arrs12 = booleanArrayOf(true, false, true, false, true)
}

集合类型

fun main() {
    // 不可变集合list
    var list = listOf(1, 2, 3, 4, 5)
    // 遍历
    for (item in list) {
        print("${item}, ")
    }
    println()
    println(list)
    // 使用高阶函数
    list.forEach { item -> print("${item}, ") }
    println()
    // 添加元素
    list = list + 6
    println(list)
    // 删除元素
    val withoutFive = list - 5
    println(withoutFive)
    // 虽然可以用var来声明不可变集合，也可以给它添加或删除元素，但却不能改变其元素的值

    // 可变集合mutableListOf
    val mutableList = mutableListOf(1, 2, 3, 4, 5)
    // 添加元素
    mutableList.add(6)
    println(mutableList)
    // 删除元素
    mutableList.remove(5)
    println(mutableList)
    // 修改元素
    mutableList[0] = 11
    println(mutableList)

    println()
    // 不可变集合set
    var set = setOf(1, 2, 3, 4, 5, 5)
    // 添加元素
    val newSet = set + 6
    set = set + 9
    println(set)
    // 删除元素
    set = set - 3
    println(set)
    // 交集
    val intersection = set.intersect(setOf(3, 4, 5, 6))
    println(intersection)
    // 并集
    val union = set + setOf(3, 4, 5, 6)
    println(union)

    println()
    // 可变集合set
    val mutableSet = mutableSetOf(6, 7, 8, 9, 10)
    // 添加元素
    mutableSet.add(11)
    println(mutableSet)
    // 删除元素
    mutableSet.remove(10)
    println(mutableSet)

    println()
    // map
    val map = mapOf(1 to "one", 2 to "two", 3 to "three")
    // 获取值
    val value = map[2]
    println(value)
    println(map.keys)
    println(map.values)
    // 遍历键值对
    for ((key, value) in map) {
        print("$key = $value, ")
    }
    println()
    // 添加键值对
    val newMap = map + (4 to "four")
    println(newMap)
    // 删除键
    val withoutTwo = map - 2
    println(withoutTwo)

    println()
    val numbers = listOf(4, 2, 1, 5, 3)
    // 过滤
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println(evenNumbers)
    // 转换
    val doubled = numbers.map { it * 2 }
    println(doubled)
    // 聚合
    val sum = numbers.reduce { acc, i -> acc + i }
    println(sum)
    val product = numbers.fold(1) { acc, i -> acc * i }
    println(product)
    val max = numbers.maxOrNull()
    println(max)
    val min = numbers.minOrNull()
    println(min)
    // 排序
    val sorted = numbers.sorted()
    println(sorted)
    val sortedDescending = numbers.sortedDescending()
    println(sortedDescending)
}

元组类型

fun main() {
    // 二元元组
    val two: Pair<String, Int> = Pair("李星云", 18)
    println(two)
    // 三元元组自动类型推断：Triple<Double, String, Boolean>
    val three = Triple(22.3, "王林", true)
    println("三元元祖：${three.first}、${three.second}、${three.third}")

    val (name, age) = Pair("萧炎", 21)
    println("name: $name, age: $age")
}

枚举类型

enum class Language {
    KOTLIN, JAVA, JAVASCRIPT, PYTHON, GO
}

enum class PrimaryColor(val hex: Long, param: Any) {
    Red(0xFFFF0000), Green(0xFF00FF00), Blue(0xFF0000FF);

    // 主、次构造方法
    constructor(hex: Long): this(0x00000000, 1)
}

fun main() {
    val language = Language.KOTLIN
    when (language) {
        Language.KOTLIN -> println("这是用来开发Android的语言")
        Language.JAVA -> println("这是用来开发企业应用的语言")
        Language.JAVASCRIPT -> println("这是用来写前端的语言")
        Language.PYTHON -> println("这是用来做数据分析的语言")
        Language.GO -> println("这是用来做通信系统的语言")
    }

    val color = PrimaryColor.Blue
    when (color) {
        PrimaryColor.Red -> println("红色")
        PrimaryColor.Green -> println("绿色")
        PrimaryColor.Blue -> println("蓝色")
    }
}

特殊类型

Any类在Kotlin中的作用等同于Object在Java中的作用，或Object在Python中的作用，它是Kotlin继承结构的根。
Unit相当于Java中的void关键字。
Nonthing相当于java.lang.Void类，作为泛型参数传递。

// 这个类隐式地继承自Any
class Test {
}

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun main() {
    // Any相关
    val myObject1 = Test()
    val myObject2 = Test()
    // 下面的三个方法都来自于Any
    println(myObject1.toString())
    println(myObject1 == myObject2)
    println(myObject1.hashCode())

    // 安全转换
    val obj: Any = "Kotlin"
    val str = obj as String
    println(str)

    // 为Any定义扩展函数
    fun Any.describe(): String {
        return "this is Any, not 9527"
    }
    val num: Any = 9527
    println(num.describe())

    /**
     * Unit
     * fun test() {
     *     println("test return void")
     * }
     * 等同于
     * fun test(): Unit {
     *     println("test return void")
     * }
     */
    val result = println("Hello Kotlin")
    // 打印结果：kotlin.Unit
    println(result)

    // Nonthing
    val name = "hello" ?: fail("lixingyun")
    println(name)
}

运算符

Kotlin有如下几种运算符。

单目运算符：++、--、+=、-=、*=、/=、%=。

fun main() {
    var num = 1
    // 运算符
    // ++num可以在println()中执行
    println(++num)
    println(--num)
    // num++不能放在println()中执行，如果用println(num++)将不会执行
    num++
    println(num)
    // 同println(num++)
    num--
    println(num)
    num += 1
    // 2
    println(num)
    num -= 1
    // 1
    println(num)
    num *= 3
    // 3
    println(num)
    num %= 2
    // 1
    println(num)
    num *= 3
    num /= 2
    // 1
    println(num)
}

比较运算符：===、!==、==、!=、>、>=、<、<=。
算术运算符：-、+、*、/、%。
逻辑运算符：&&、||、!。
特殊运算符：?（安全调用运算符）、!!（非空断言运算符）。

fun main() {
    val name1: String? = null
    if (name1 === null) {
        println("name1 is null")
    }
    // 抛出NullPointerException
    println(name1!!.length)
}

其他运算符：-（负号运算符）、+（字符串连接运算符）、.（分量运算符）、[]（下标运算符）。

感谢支持

更多内容，请移步《超级个体》。