基础语法与类型

val name: String = "Kotlin"
name = "Java"  // ❌ 编译错误：Val cannot be reassigned
 
val age = 18   // 类型推断（Type Inference）：编译器自动推断为 Int

val list = mutableListOf(1, 2, 3)
list.add(4)        // ✅ 可以修改对象内容
list = mutableListOf()  // ❌ 不能重新赋值

┌─────────────────────────────────────────────┐
│  val list ──────────► MutableList [1,2,3,4] │
│     ↑                        ↑              │
│   引用锁定                 内容可变           │
│  (reference locked)    (content mutable)    │
└─────────────────────────────────────────────┘

var count = 0
count = 10     // ✅ 可以重新赋值
count = "Hi"   // ❌ 类型不能改变（Type mismatch）

class UserService {
    lateinit var repository: UserRepository  // 稍后初始化
    
    fun setup() {
        repository = UserRepository()  // 实际初始化
    }
    
    fun loadUser() {
        if (::repository.isInitialized) {   // 检查是否已初始化
            repository.findAll()
        }
    }
}

// 必须是类属性，不能是局部变量
lateinit val x: String      // ❌ 必须是 var，lateinit val 不合法
lateinit var count: Int     // ❌ 不能是基本类型，不能用于 Int、Boolean 等
lateinit var name: String?  // ❌ 不能是可空类型，不能是 String?

// 必须在 top-level 或 object 中声明
const val MAX_SIZE = 100
const val API_URL = "https://api.example.com"
 
object Config {
    const val TIMEOUT = 30_000  // ✅ object 内可以
}
 
class MyClass {
    const val X = 10  // ❌ 普通类内部不行
    
    companion object {
        const val Y = 20  // ✅ companion object 可以
    }
}

┌────────────────────────────────────────────────────────────┐
│                    const val                               │
│  ┌──────────┐    编译时      ┌──────────────────────┐       │
│  │ const=100│ ──────────►   │ 使用处直接替换为 100   │       │
│  └──────────┘   inline      └──────────────────────┘       │
├────────────────────────────────────────────────────────────┤
│                      val                                   │
│  ┌──────────┐    运行时      ┌──────────────────────┐       │
│  │ val=计算值│ ──────────►   │ 读取变量引用          │       │
│  └──────────┘   reference   └──────────────────────┘       │
└────────────────────────────────────────────────────────────┘

val a: Int = 42        // 编译为 JVM 的 int
val b: Int? = 42       // 编译为 JVM 的 Integer（装箱）
val c: Double = 3.14   // 编译为 JVM 的 double

val str: String = "Hello"           // 字符串
val list: List<Int> = listOf(1,2)   // 集合
val user: User = User("Tom")        // 自定义类
val func: (Int) -> Int = { it * 2 } // 函数类型（Function Type）

                        ┌─────────┐
                        │   Any   │  ← 所有非空类型的根
                        └────┬────┘
                             │
         ┌───────────────────┼───────────────────┐
         │                   │                   │
    ┌────┴────┐        ┌─────┴─────┐       ┌─────┴─────┐
    │  String │        │    Int    │       │   User    │
    └─────────┘        └───────────┘       └───────────┘
    
                        ┌─────────┐
                        │  Any?   │  ← 所有类型的根（含可空）
                        └────┬────┘
                             │
         ┌───────────────────┼───────────────────┐
         │                   │                   │
    ┌────┴────┐        ┌─────┴─────┐       ┌─────┴─────┐
    │ String? │        │   Int?    │       │  Any/其他  │
    └─────────┘        └───────────┘       └───────────┘
 
                        ┌─────────┐
                        │ Nothing │  ← 所有类型的子类型（底部类型）
                        └─────────┘

val anything: Any = "Hello"  // String 是 Any 的子类
val number: Any = 42         // Int 也是 Any 的子类
 
fun printAny(obj: Any) {
    println(obj.toString())  // Any 有 toString()、hashCode()、equals()
}

val maybeNull: Any? = null   // ✅ 可以是 null
val alsoOk: Any? = "Hello"   // ✅ 也可以是非空值
 
fun process(input: Any?) {
    // 必须做空检查才能调用方法
    input?.toString()
}

val s: String = "Hi"
val sn: String? = s    // ✅ String 可以赋给 String?
val s2: String = sn    // ❌ String? 不能直接赋给 String

fun printHello(): Unit {   // 可省略 ": Unit"
    println("Hello")
}
 
val result: Unit = printHello()  // 可以接收
println(result)  // 输出: kotlin.Unit

fun fail(msg: String): Nothing {
    throw IllegalArgumentException(msg)  // 永远抛异常
}
 
fun infiniteLoop(): Nothing {
    while (true) { }  // 永远不结束
}

val x: String = fail("Error")  // ✅ Nothing 兼容 String
val y: Int = fail("Error")     // ✅ Nothing 兼容 Int

val name = input ?: throw IllegalArgumentException()  
// throw 返回 Nothing，而 Nothing 是 String 的子类型，所以类型检查通过

                         ┌──────────────┐
                         │     Any?     │   Nullable 根
                         └──────┬───────┘
                                │
            ┌───────────────────┴───────────────────┐
            │                                       │
     ┌──────┴──────┐                         ┌──────┴──────┐
     │     Any     │                         │   其他 T?    │
     │ (非空类型根) │                         │  (可空类型)  │
     └──────┬──────┘                         └─────────────┘
            │
   ┌────────┼────────┬────────────┐
   │        │        │            │
┌──┴──┐ ┌───┴──┐ ┌───┴──┐  ┌──────┴──────┐
│String││ Int  │ │ Unit │  │ 其他非空类型  │
└─────┘ └──────┘ └──────┘  └─────────────┘
   │        │        │            │
   └────────┴────────┴────────────┘
                    │
             ┌──────┴──────┐
             │   Nothing   │   底部类型（所有类型的子类型）
             └─────────────┘

val byte: Byte = 127
val short: Short = 32767
val int: Int = 2_147_483_647
val long: Long = 9_223_372_036_854_775_807L  // 注意 L 后缀

val a = 100       // 默认推断为 Int
val b = 3_000_000_000  // 超出 Int 范围，自动推断为 Long
val c = 100L      // 显式声明为 Long（使用 L 后缀）

┌──────────────────────────────────────────────────────────┐
│              整数字面量的类型推断流程                      │
├──────────────────────────────────────────────────────────┤
│                                                          │
│   字面量 ──► 有 L 后缀？ ──► 是 ──► Long                  │
│                │                                         │
│               否                                         │
│                ▼                                         │
│         值在 Int 范围内？ ──► 是 ──► Int                  │
│                │                                         │
│               否                                         │
│                ▼                                         │
│              Long                                        │
│                                                          │
└──────────────────────────────────────────────────────────┘

val pi: Double = 3.141592653589793 // Double 64bits 15-16 位有效数字 | 科学计算/财务（需配合 BigDecimal）
val e: Float = 2.718281f   // 注意 f/F 后缀 Float 32bits 6-7 位有效数字 | 图形/游戏/内存敏感
 
val defaultDouble = 3.14   // 默认推断为 Double
val explicitFloat = 3.14f  // 必须加 f 才是 Float

val oneMillion = 1_000_000           // 一百万
val creditCard = 1234_5678_9012_3456L
val hexBytes = 0xFF_EC_DE_5E
val binaryMask = 0b1111_0000_1010
val socialSecurity = 999_99_9999

val decimal = 255
val hex = 0xFF           // 十六进制 255 十六进制（Hexadecimal） 0x/0X 0x7F（127）
val binary = 0b1111_1111 // 二进制 255 二进制（Binary） 0b/0B 0b0111_1111（127）
 
println(decimal == hex)   // true
println(hex == binary)    // true

┌─────────────────────────────────────────────────────────────┐
│                    Kotlin 数值在 JVM 上的存储                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   val a: Int = 100                                          │
│   ┌─────────┐                                               │
│   │  int    │ ◄── JVM primitive（栈上直接存储）              │
│   └─────────┘                                               │
│                                                             │
│   val b: Int? = 100                                         │
│   ┌─────────┐     ┌─────────────┐                           │
│   │   ref   │────►│  Integer    │ ◄── 装箱对象（堆上）        │
│   └─────────┘     └─────────────┘                           │
│                                                             │
│   val list: List<Int> = listOf(1, 2, 3)                     │
│   ┌─────────┐     ┌───────────────────────┐                 │
│   │   ref   │────►│ [Integer, Integer...] │ ◄── 泛型需装箱   │
│   └─────────┘     └───────────────────────┘                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val a: Int = 1000
val b: Int = 1000
println(a == b)   // true（值相等）
 
val boxedA: Int? = a
val boxedB: Int? = a
println(boxedA == boxedB)   // true（值相等，使用 equals）
println(boxedA === boxedB)  // false ⚠️ 可能不同对象（引用相等）

val a: Int = 128
val b: Int? = 128
val c: Int? = 128
println(b === c)

val byte: Byte = 1
val int: Int = byte      // ❌ 编译错误！Type mismatch
val int2: Int = byte.toInt()  // ✅ 必须显式转换

val number = 42
 
number.toByte()    // → Byte
number.toShort()   // → Short  
number.toInt()     // → Int
number.toLong()    // → Long
number.toFloat()   // → Float
number.toDouble()  // → Double
number.toChar()    // → Char（对应 Unicode 码点）

val long: Long = 100L
val int: Int = long.toInt()      // Long → Int
 
val double: Double = 3.99
val int2: Int = double.toInt()   // 3（截断，不是四舍五入！）
 
val int3: Int = 65
val char: Char = int3.toChar()   // 'A'（ASCII 65）

┌─────────────────────────────────────────────────────────────┐
│                    类型转换方向与风险                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Byte → Short → Int → Long → Float → Double                │
│         ────────────────────────────────►                   │
│              扩展转换（Widening）安全                         │
│                                                             │
│   Double → Float → Long → Int → Short → Byte                │
│         ────────────────────────────────►                   │
│              收缩转换（Narrowing）可能丢失精度                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val big: Long = 10_000_000_000L
val small: Int = big.toInt()
println(small)  // 1410065408 ⚠️ 溢出！不是原值
 
val precise: Double = 3.999999999999
val less: Float = precise.toFloat()
println(less)   // 4.0 ⚠️ 精度丢失

fun processAny(obj: Any) {
    if (obj is String) {
        // 在这个分支中，obj 自动转换为 String
        println(obj.length)      // ✅ 直接调用 String 的方法
        println(obj.uppercase()) // ✅ 无需手动转换
    }
    
    if (obj !is String) return
    
    // 到这里，编译器知道 obj 一定是 String
    println(obj.length)  // ✅ 智能转换生效
}

┌─────────────────────────────────────────────────────────────┐
│                       智能转换工作原理                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   fun demo(x: Any) {                                        │
│       │                                                     │
│       ▼                                                     │
│   ┌──────────────┐                                          │
│   │ x is String? │                                          │
│   └──────┬───────┘                                          │
│          │                                                  │
│     ┌────┴────┐                                             │
│     ▼         ▼                                             │
│   [YES]     [NO]                                            │
│     │         │                                             │
│     ▼         ▼                                             │
│  x: String  x: Any    ← 编译器自动推断分支内的类型            │
│     │         │                                             │
│  x.length   ❌ x.length                                     │
│     ✅                                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

fun describe(obj: Any): String = when (obj) {
    is Int    -> "Integer: ${obj * 2}"     // obj 是 Int
    is String -> "String of length ${obj.length}"  // obj 是 String
    is List<*> -> "List with ${obj.size} elements" // obj 是 List
    else      -> "Unknown"
}

class Example {
    var mutableProp: Any = "Hello"
    
    fun test() {
        if (mutableProp is String) {
            // ❌ 智能转换不可用！
            // mutableProp.length  
            // 因为 var 可能在检查后被其他线程修改
        }
    }
}

val obj: Any = "Hello"
 
// 不安全转换（Unsafe Cast）
val str1: String = obj as String   // ✅ 成功
val int1: Int = obj as Int         // ❌ ClassCastException!
 
// 安全转换（Safe Cast）
val str2: String? = obj as? String // ✅ 返回 "Hello"
val int2: Int? = obj as? Int       // ✅ 返回 null（不会崩溃）

fun process(input: Any) {
    // 方式1：is + 智能转换（推荐）
    if (input is String) {
        println(input.length)
    }
    
    // 方式2：as 强制转换（可能崩溃）
    val str = input as String  // 危险！
    
    // 方式3：as? 安全转换 + 空处理
    val strSafe = input as? String
    println(strSafe?.length ?: "Not a String")
}

┌─────────────────────────────────────────────────────────────┐
│                    类型转换方式对比                           │
├──────────────┬──────────────┬───────────────────────────────┤
│    方式       │    语法      │          结果                  │
├──────────────┼──────────────┼───────────────────────────────┤
│  智能转换     │  is + 分支   │  自动转换，最安全               │
│  强制转换     │  as         │  失败抛 ClassCastException     │
│  安全转换     │  as?        │  失败返回 null                 │
└──────────────┴──────────────┴───────────────────────────────┘

val byte: Byte = 1
val int: Int = 2
val result = byte + int   // result 类型是 Int（自动提升）
 
val long: Long = 10L
val sum = int + long      // sum 类型是 Long
 
val float: Float = 1.5f
val double: Double = 2.5
val total = float + double // total 类型是 Double

val a: Long = 100
val b: Int = a

fun test(obj: Any) {
    val result = obj as? Int ?: -1
    println(result)
}
test("Hello")

val letter: Char = 'A'
val digit: Char = '9'
val chinese: Char = '中'
val emoji: Char = '😀'  // ⚠️ 部分 emoji 超出 Char 范围

// Java 中可以这样（隐式转换）
// char c = 65;  ✅ Java OK
 
// Kotlin 中不行
val c: Char = 65       // ❌ 编译错误：Type mismatch
val c2: Char = 65.toChar()  // ✅ 必须显式转换

val ch = 'A'
 
// 字符与数字转换
ch.code          // 65（获取 Unicode 码点）
ch.digitToInt()  // 用于数字字符 '0'-'9'
 
// 字符运算（Character arithmetic）
ch + 1           // 'B'（Char + Int = Char）
ch - 'A'         // 0（Char - Char = Int）
'Z' - 'A'        // 25
 
// 判断方法
ch.isLetter()      // true
ch.isDigit()       // false
ch.isUpperCase()   // true
ch.lowercaseChar() // 'a'

val tab = '\t'
val newline = '\n'
val heart = '\u2665'  // ♥

var str = "Hello"
str = "World"      // ✅ 变量指向新字符串（变量可变）
str[0] = 'X'       // ❌ 不能修改字符串内容（对象不可变）

┌─────────────────────────────────────────────────────────────┐
│                  String 不可变性图解                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   var str = "Hello"                                         │
│                                                             │
│   ┌─────┐         ┌─────────────────┐                       │
│   │ str │ ──────► │ "Hello"         │  String 对象          │
│   └─────┘         └─────────────────┘                       │
│                                                             │
│   str = "World"   // 重新赋值                                │
│                                                             │
│   ┌─────┐         ┌─────────────────┐                       │
│   │ str │ ──────► │ "World"         │  新的 String 对象     │
│   └─────┘         └─────────────────┘                       │
│                   ┌─────────────────┐                       │
│                   │ "Hello"         │  旧对象等待 GC        │
│                   └─────────────────┘                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val s1 = "Hello"
val s2 = "World"
 
// 方式1：+ 操作符
val s3 = s1 + " " + s2  // "Hello World"
 
// 方式2：字符串模板（推荐，稍后详解）
val s4 = "$s1 $s2"
 
// 方式3：StringBuilder（大量拼接时高效）
val sb = StringBuilder()
sb.append(s1).append(" ").append(s2)
val s5 = sb.toString()

val str = "Kotlin"
 
str[0]           // 'K'（通过索引访问）
str.first()      // 'K'
str.last()       // 'n'
str.length       // 6
 
// 遍历字符串
for (ch in str) {
    println(ch)
}

val name = "Kotlin"
val version = 1.9
 
// 简单变量引用
val msg1 = "Language: $name"           // "Language: Kotlin"
 
// 复杂表达式用 ${}
val msg2 = "Length: ${name.length}"    // "Length: 6"
val msg3 = "Next version: ${version + 0.1}"  // "Next version: 2.0"
 
// 对象属性
data class User(val name: String, val age: Int)
val user = User("Alice", 25)
val msg4 = "User: ${user.name}, Age: ${user.age}"

val price = 100
 
"$price"           // ✅ "100"
"$price dollars"   // ✅ "100 dollars"
"$pricedollars"    // ❌ 找不到变量 pricedollars
"${price}dollars"  // ✅ "100dollars"
 
// 表达式必须用大括号
"Total: ${price * 1.1}"       // ✅
"Array: ${listOf(1,2,3)}"     // ✅
"Condition: ${if (price > 50) "expensive" else "cheap"}"  // ✅

val amount = 50
println("Price: \$amount")     // 输出: Price: $amount（转义）
println("Price: ${'$'}$amount") // 输出: Price: $50（模板中嵌入 $）

// 普通字符串（需要转义）
val escaped = "Line 1\nLine 2\n\tIndented"
 
// 原始字符串（所见即所得）
val raw = """
    Line 1
    Line 2
        Indented
"""

// 默认会保留前导空格，通常不是我们想要的
val ugly = """
    Hello
    World
"""
println(ugly)
// 输出:
//
//     Hello
//     World
//
 
// 使用 trimIndent() 去除公共缩进
val clean = """
    Hello
    World
""".trimIndent()
println(clean)
// 输出:
// Hello
// World
 
// 使用 trimMargin() 自定义边界符
val custom = """
    |First line
    |Second line
    |  Indented line
""".trimMargin()  // 默认边界符是 |
println(custom)
// 输出:
// First line
// Second line
//   Indented line
 
// 可以指定其他边界符
val other = """
    #Line 1
    #Line 2
""".trimMargin("#")

┌─────────────────────────────────────────────────────────────┐
│                   trimMargin 工作原理                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   原始字符串:                  处理后:                       │
│   ┌──────────────────┐        ┌──────────────────┐         │
│   │    |Hello        │        │Hello             │         │
│   │    |  World      │  ───►  │  World           │         │
│   │    |Kotlin       │        │Kotlin            │         │
│   └──────────────────┘        └──────────────────┘         │
│         ↑                                                   │
│    删除 | 及之前的空格                                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// SQL 查询
val sql = """
    SELECT * 
    FROM users 
    WHERE age > 18 
    ORDER BY name
""".trimIndent()
 
// JSON 数据
val json = """
    {
        "name": "Alice",
        "age": 25
    }
""".trimIndent()
 
// 正则表达式（不需要双重转义）
val regex = """\d{3}-\d{4}""".toRegex()  // 普通字符串需要 "\\d{3}-\\d{4}"
 
// HTML 模板
val html = """
    <!DOCTYPE html>
    <html>
        <body>
            <h1>$title</h1>
            <p>${content}</p>
        </body>
    </html>
""".trimIndent()

val x = 10
val y = 20
println("Sum: ${x + y}, Product: $x * $y")

val isKotlinFun: Boolean = true
val isJavaObsolete: Boolean = false
 
// 类型推断
val learning = true  // 自动推断为 Boolean

val b: Boolean? = null
 
// 可空布尔值在条件判断中需要显式处理
if (b == true) {
    println("b is true")
} else {
    println("b is false or null")
}
 
// 常见模式
b ?: false  // 如果 b 为 null，返回 false
b == true   // 安全比较，null 也会返回 false

val a = true
val b = false
 
a && b   // false（AND）
a || b   // true（OR）
!a       // false（NOT）
!b       // true
 
// 复合表达式
(a && !b) || (!a && b)  // true（异或的实现）

┌─────────────────────────────────────────────────┐
│            逻辑运算真值表                         │
├───────┬───────┬─────────┬──────────┬────────────┤
│   A   │   B   │  A && B │  A || B  │    !A      │
├───────┼───────┼─────────┼──────────┼────────────┤
│ true  │ true  │  true   │   true   │   false    │
│ true  │ false │  false  │   true   │   false    │
│ false │ true  │  false  │   true   │   true     │
│ false │ false │  false  │   false  │   true     │
└───────┴───────┴─────────┴──────────┴────────────┘

val a = true
val b = false
 
a and b   // false（等价于 a && b，但不短路）
a or b    // true（等价于 a || b，但不短路）
a xor b   // true（异或，无 && || 对应符号）

fun checkFirst(): Boolean {
    println("Checking first...")
    return true
}
 
fun checkSecond(): Boolean {
    println("Checking second...")
    return false
}
 
// && 短路：第一个为 false 时，不执行第二个
false && checkSecond()  // 不会打印 "Checking second..."
 
// || 短路：第一个为 true 时，不执行第二个
true || checkSecond()   // 不会打印 "Checking second..."

┌─────────────────────────────────────────────────────────────┐
│                    && 短路求值                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│    A && B                                                   │
│      │                                                      │
│      ▼                                                      │
│  ┌────────┐                                                 │
│  │ 求值 A │                                                 │
│  └────┬───┘                                                 │
│       │                                                     │
│   ┌───┴───┐                                                 │
│   ▼       ▼                                                 │
│ false   true                                                │
│   │       │                                                 │
│   ▼       ▼                                                 │
│ 返回    ┌────────┐                                          │
│ false   │ 求值 B │                                          │
│         └────┬───┘                                          │
│              │                                              │
│              ▼                                              │
│           返回 B                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
 
 

┌─────────────────────────────────────────────────────────────┐
│                    || 短路求值                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│    A || B                                                   │
│      │                                                      │
│      ▼                                                      │
│  ┌────────┐                                                 │
│  └────┬───┘                                                 │
│       │                                                     │
│   ┌───┴───┐                                                 │
│   ▼       ▼                                                 │
│ true   false                                                │
│   │       │                                                 │
│   ▼       ▼                                                 │
│ 返回    ┌────────┐                                          │
│ true    │ 求值 B │                                          │
│         └────┬───┘                                          │
│              │                                              │
│              ▼                                              │
│           返回 B                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 1. 空安全检查
val list: List<String>? = null
if (list != null && list.isNotEmpty()) {  // 安全：list 为 null 时不会调用 isNotEmpty()
    println(list.first())
}
 
// 2. 避免除零错误
val divisor = 0
if (divisor != 0 && 100 / divisor > 10) {  // 安全：divisor 为 0 时不会执行除法
    println("Greater than 10")
}
 
// 3. 默认值模式
fun getUser(): User? = null
val user = getUser()
val name = user?.name ?: "Anonymous"  // 类似的短路逻辑
 
// 4. 条件初始化
val expensive = false
val result = expensive && computeExpensiveValue()  // expensive 为 false 时不计算

var counter = 0
 
fun increment(): Boolean {
    counter++
    return true
}
 
// 短路操作符
true || increment()   // counter = 0（未执行 increment）
false && increment()  // counter = 0（未执行 increment）
 
// 非短路操作符
true or increment()   // counter = 1（执行了 increment）
false and increment() // counter = 2（执行了 increment）

val isLoggedIn = true
val isAdmin = false
 
// if 表达式
val status = if (isLoggedIn) "Welcome" else "Please login"
 
// when 表达式
val access = when {
    isAdmin -> "Full access"
    isLoggedIn -> "Limited access"
    else -> "No access"
}
 
// 直接在条件中使用（推荐简洁写法）
if (isLoggedIn) { /* ... */ }        // ✅ 好
if (isLoggedIn == true) { /* ... */ } // ⚠️ 冗余（除非是 Boolean?）

var x = 0
val result = false && (++x > 0)
println("x = $x, result = $result")

val flag: Boolean? = null

if (flag == true) { ... }    // 检查是否为 true
if (flag != false) { ... }   // 检查是否非 false（null 也通过）
if (flag ?: false) { ... }   // null 时当作 false

// 直接指定元素
val numbers = arrayOf(1, 2, 3, 4, 5)
val strings = arrayOf("a", "b", "c")
val mixed = arrayOf(1, "two", 3.0)  // Array<Any>（混合类型）

// Array(size) { 初始化表达式 }
val squares = Array(5) { i -> i * i }
// 结果: [0, 1, 4, 9, 16]
 
val zeros = Array(10) { 0 }
// 结果: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
val indexed = Array(5) { "Item $it" }
// 结果: ["Item 0", "Item 1", "Item 2", "Item 3", "Item 4"]

┌─────────────────────────────────────────────────────────────┐
│              Array(5) { i -> i * i } 执行过程                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   索引 i:    0      1      2      3      4                   │
│            ↓      ↓      ↓      ↓      ↓                    │
│   i * i:   0      1      4      9      16                   │
│            ↓      ↓      ↓      ↓      ↓                    │
│         ┌─────┬─────┬─────┬─────┬─────┐                     │
│  结果:  │  0  │  1  │  4  │  9  │ 16  │                     │
│         └─────┴─────┴─────┴─────┴─────┘                     │
│           [0]   [1]   [2]   [3]   [4]                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val nullableArray: Array<String?> = arrayOfNulls(5)
// 结果: [null, null, null, null, null]
 
nullableArray[0] = "First"
// 结果: ["First", null, null, null, null]

val empty: Array<Int> = emptyArray()
println(empty.size)  // 0

// 基本类型数组 - 无装箱，性能更好
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)
val doubleArray: DoubleArray = doubleArrayOf(1.0, 2.0, 3.0)
val boolArray: BooleanArray = booleanArrayOf(true, false, true)
 
// 构造函数方式
val sizes = IntArray(5)               // [0, 0, 0, 0, 0]（默认值为 0）
val evens = IntArray(5) { it * 2 }    // [0, 2, 4, 6, 8]

┌─────────────────────────────────────────────────────────────┐
│              Array<Int> vs IntArray 内存布局                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Array<Int>（装箱数组 / Boxed Array）                       │
│   ┌─────────────────────────────────────────────┐           │
│   │ ref │ ref │ ref │ ref │ ref │               │           │
│   └──┬────┬────┬────┬────┬──────────────────────┘           │
│      ↓    ↓    ↓    ↓    ↓                                  │
│   ┌────┐┌────┐┌────┐┌────┐┌────┐  ← Integer 对象（堆上）     │
│   │ 1  ││ 2  ││ 3  ││ 4  ││ 5  │                            │
│   └────┘└────┘└────┘└────┘└────┘                            │
│                                                             │
│   IntArray（原始数组 / Primitive Array）                     │
│   ┌─────────────────────────────────────────────┐           │
│   │  1  │  2  │  3  │  4  │  5  │               │  ← 直接值 │
│   └─────────────────────────────────────────────┘           │
│                                                             │
│   内存占用: IntArray << Array<Int>                           │
│   访问速度: IntArray >> Array<Int>                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val arr = arrayOf("A", "B", "C", "D", "E")
 
// 读取元素（Accessing elements）
arr[0]          // "A"（索引访问）
arr.get(0)      // "A"（方法访问，等价于 arr[0]）
arr.first()     // "A"（第一个元素）
arr.last()      // "E"（最后一个元素）
arr.getOrNull(10)  // null（越界时返回 null，不抛异常）
arr.getOrElse(10) { "Default" }  // "Default"
 
// 修改元素（Modifying elements）
arr[0] = "Z"         // 直接赋值
arr.set(1, "Y")      // 方法方式（等价于 arr[1] = "Y"）
 
// 数组属性
arr.size           // 5
arr.indices        // 0..4（索引范围）
arr.lastIndex      // 4（最后一个索引）

val numbers = intArrayOf(3, 1, 4, 1, 5, 9, 2, 6)
 
// 遍历（Iteration）
for (num in numbers) { println(num) }
for ((index, value) in numbers.withIndex()) {
    println("$index: $value")
}
numbers.forEach { println(it) }
numbers.forEachIndexed { i, v -> println("$i: $v") }
 
// 搜索（Searching）
numbers.contains(5)      // true
5 in numbers             // true（等价写法）
numbers.indexOf(1)       // 1（第一次出现的位置）
numbers.lastIndexOf(1)   // 3（最后一次出现的位置）
 
// 转换（Transformation）
numbers.sorted()              // 返回新的排序列表 [1, 1, 2, 3, 4, 5, 6, 9]
numbers.sortedDescending()    // 降序
numbers.reversed()            // 反转
numbers.distinct()            // 去重 [3, 1, 4, 5, 9, 2, 6]
 
// 聚合（Aggregation）
numbers.sum()       // 31
numbers.average()   // 3.875
numbers.max()       // 9
numbers.min()       // 1
numbers.count()     // 8
 
// 过滤（Filtering）
numbers.filter { it > 3 }  // [4, 5, 9, 6]
 
// 映射（Mapping）
numbers.map { it * 2 }     // [6, 2, 8, 2, 10, 18, 4, 12]

// 二维数组（2D Array）
val matrix: Array<IntArray> = arrayOf(
    intArrayOf(1, 2, 3),
    intArrayOf(4, 5, 6),
    intArrayOf(7, 8, 9)
)
 
// 访问元素
matrix[0][0]  // 1（第一行第一列）
matrix[1][2]  // 6（第二行第三列）
matrix[2][1]  // 8（第三行第二列）
 
// 遍历二维数组
for (row in matrix) {
    for (cell in row) {
        print("$cell ")
    }
    println()
}

┌─────────────────────────────────────────────────────────────┐
│                    二维数组内存结构                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   matrix: Array<IntArray>                                   │
│                                                             │
│   ┌───────────────────┐                                     │
│   │ matrix[0] ────────┼───► [1, 2, 3]                       │
│   ├───────────────────┤                                     │
│   │ matrix[1] ────────┼───► [4, 5, 6]                       │
│   ├───────────────────┤                                     │
│   │ matrix[2] ────────┼───► [7, 8, 9]                       │
│   └───────────────────┘                                     │
│                                                             │
│   逻辑视图:                                                  │
│        col 0   col 1   col 2                                │
│   row 0 [ 1  ,   2   ,   3  ]                               │
│   row 1 [ 4  ,   5   ,   6  ]                               │
│   row 2 [ 7  ,   8   ,   9  ]                               │
│                                                             │
│   matrix[row][col] 访问                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 创建 3x4 的矩阵，所有元素初始化为 0
val rows = 3
val cols = 4
val grid = Array(rows) { IntArray(cols) }
 
// 创建并初始化
val board = Array(3) { row ->
    IntArray(3) { col -> row * 3 + col + 1 }
}
// 结果:
// [1, 2, 3]
// [4, 5, 6]
// [7, 8, 9]

// 每行长度可以不同
val jagged = arrayOf(
    intArrayOf(1),
    intArrayOf(2, 3),
    intArrayOf(4, 5, 6),
    intArrayOf(7, 8, 9, 10)
)
 
// 结构:
// [1]
// [2, 3]
// [4, 5, 6]
// [7, 8, 9, 10]

val array = arrayOf(1, 2, 3)
 
// 数组 → List
val list: List<Int> = array.toList()
val mutableList: MutableList<Int> = array.toMutableList()
 
// 数组 → Set
val set: Set<Int> = array.toSet()
 
// List → 数组
val backToArray: Array<Int> = list.toTypedArray()
val intArray: IntArray = list.toIntArray()  // 基本类型数组

val arr = Array(4) { it * it }
println(arr.contentToString())

var name: String = "Kotlin"
name = null  // ❌ 编译错误：Null cannot be a value of a non-null type String
 
var age: Int = 25
age = null   // ❌ 编译错误

var name: String? = "Kotlin"
name = null  // ✅ 可空类型可以赋值为 null
 
var age: Int? = 25
age = null   // ✅ OK

┌─────────────────────────────────────────────────────────────┐
│              非空类型 vs 可空类型                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   String (非空类型)                                          │
│   ┌─────────────────────────────────────────┐               │
│   │  "Hello"  │  "World"  │  ""  │  "..."   │               │
│   └─────────────────────────────────────────┘               │
│         所有合法字符串值（不包含 null）                        │
│                                                             │
│   String? (可空类型)                                         │
│   ┌─────────────────────────────────────────┬───────┐       │
│   │  "Hello"  │  "World"  │  ""  │  "..."   │ null  │       │
│   └─────────────────────────────────────────┴───────┘       │
│         所有合法字符串值 ＋ null                              │
│                                                             │
│   类型关系: String 是 String? 的子类型                        │
│            (String is a subtype of String?)                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val name: String? = "Kotlin"
 
// 直接调用会报错
name.length      // ❌ 编译错误：Only safe (?.) or non-null asserted (!!.) 
                 //    calls are allowed on a nullable receiver
 
// 必须处理可能为 null 的情况

val name: String? = getName()
 
if (name != null) {
    // 在这个分支中，name 被智能转换为 String（非空）
    println(name.length)  // ✅ 可以直接调用
}
 
// 另一种写法
if (name == null) {
    println("Name is null")
    return
}
println(name.length)  // ✅ 智能转换生效

val name: String? = null
 
// 如果 name 不为 null，调用 length；否则返回 null
val len: Int? = name?.length  // null
 
val name2: String? = "Kotlin"
val len2: Int? = name2?.length  // 6
 
// 链式安全调用
val city: String? = user?.address?.city

┌─────────────────────────────────────────────────────────────┐
│                    安全调用 ?. 工作流程                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│     name?.length                                            │
│          │                                                  │
│          ▼                                                  │
│  ┌────────────────┐                                         │
│  │ name == null?  │                                         │
│  └───────┬────────┘                                         │
│          │                                                  │
│     ┌────┴────┐                                             │
│     ▼         ▼                                             │
│   [YES]     [NO]                                            │
│     │         │                                             │
│     ▼         ▼                                             │
│   null    name.length                                       │
│     │         │                                             │
│     └────┬────┘                                             │
│          ▼                                                  │
│      结果: Int?                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val name: String? = null
 
// 如果 name 为 null，使用默认值
val displayName: String = name ?: "Anonymous"  // "Anonymous"
 
// 组合使用
val len: Int = name?.length ?: 0  // 0
 
// 可以在右侧抛出异常或 return
val nonNullName = name ?: throw IllegalArgumentException("Name required")
val nonNullName2 = name ?: return  // 提前返回

val name: String? = "Kotlin"
 
// 断言 name 不为 null，如果为 null 则抛出 NullPointerException
val len: Int = name!!.length  // 6
 
val nullName: String? = null
nullName!!.length  // 💥 抛出 NullPointerException

val nothing: String? = null
 
// null 本身的类型是 Nothing?
val n = null  // 类型推断为 Nothing?
 
// null 可以赋给任何可空类型
val a: Int? = null
val b: String? = null
val c: List<Int>? = null

val a: String? = null
val b: String? = null
 
a == null   // true（结构相等判断）
a === null  // true（引用相等判断）
a == b      // true（两个 null 相等）

// 非空类型可以赋给可空类型
val nonNull: String = "Hello"
val nullable: String? = nonNull  // ✅ OK
 
// 可空类型不能直接赋给非空类型
val nullable2: String? = "World"
val nonNull2: String = nullable2  // ❌ 编译错误
 
// 必须处理空值
val nonNull3: String = nullable2 ?: "Default"  // ✅ OK
val nonNull4: String = nullable2!!             // ✅ OK（危险）
 
if (nullable2 != null) {
    val nonNull5: String = nullable2           // ✅ 智能转换
}

val name: String? = "Kotlin"
 
// 只有当 name 不为 null 时才执行 let 块
name?.let {
    println("Name is $it")        // it 是非空的 String
    println("Length is ${it.length}")
}
 
// 等价于
if (name != null) {
    println("Name is $name")
    println("Length is ${name.length}")
}
 
// 实际应用：处理可空返回值
getUserOrNull()?.let { user ->
    sendEmail(user.email)
    logActivity(user.id)
}

// List<String> - 列表非空，元素也非空
val list1: List<String> = listOf("a", "b", "c")
 
// List<String?> - 列表非空，但元素可空
val list2: List<String?> = listOf("a", null, "c")
 
// List<String>? - 列表可空，元素非空
val list3: List<String>? = null
 
// List<String?>? - 列表可空，元素也可空
val list4: List<String?>? = listOf("a", null)

┌─────────────────────────────────────────────────────────────┐
│               集合空安全的四种组合                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   List<String>                                              │
│   ┌─────────────────────────────────────┐                   │
│   │  "a"  │  "b"  │  "c"  │  "d"        │  ← 所有元素非空  │
│   └─────────────────────────────────────┘                   │
│                                                             │
│   List<String?>                                             │
│   ┌─────────────────────────────────────┐                   │
│   │  "a"  │ null  │  "c"  │ null        │  ← 元素可为空    │
│   └─────────────────────────────────────┘                   │
│                                                             │
│   List<String>?                                             │
│   ┌─────────────────────────────────────┐                   │
│   │  "a"  │  "b"  │  "c"  │  "d"        │  或  null        │
│   └─────────────────────────────────────┘      ↑           │
│                                            整个列表可能为空  │
│                                                             │
│   List<String?>?                                            │
│   ┌─────────────────────────────────────┐                   │
│   │  "a"  │ null  │  "c"  │ null        │  或  null        │
│   └─────────────────────────────────────┘      ↑           │
│         ↑                                  整个列表可能为空  │
│      元素可为空                                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

val listWithNulls: List<String?> = listOf("a", null, "b", null, "c")
 
// filterNotNull() 返回 List<String>（非空列表）
val nonNullList: List<String> = listWithNulls.filterNotNull()
// 结果: ["a", "b", "c"]

// Java 代码
public class JavaClass {
    public String getName() { return null; }
}
 
// Kotlin 中使用
val name = javaClass.getName()  // 类型是 String!（平台类型）

// 方式1：假设可空，安全处理
val name: String? = javaClass.getName()
 
// 方式2：假设非空（如果为 null 会崩溃）
val name: String = javaClass.getName()
 
// 推荐：明确声明可空性
val name: String = javaClass.getName() ?: "Default"

val x: String? = null
val y: String = x?.length?.toString() ?: "unknown"
println(y)

val a: String? = "hello"
val b: String = a ?: ""

val a: String? = "hello"
val b: Int = a?.length

val a: String? = null
val b: Int = a?.length ?: 0

val a: String = "hello"
val b: String? = a

val a = 10
val b = 3
 
a + b   // 13
a - b   // 7
a * b   // 30
a / b   // 3（整数除法，向下取整）
a % b   // 1（余数）
 
// 浮点数除法
10.0 / 3.0  // 3.3333...
 
// 负数取模
-7 % 3   // -1（结果符号与被除数相同）
7 % -3   // 1