val obj = SoftReference(Any())

val obj = WeakReference(Any())

val obj = PhantomReference(Any())

val leakCanaryVersion = "2.9.1"

dependencies {
    ...
    debugImplementation("com.squareup.leakcanary:leakcanary-android:$leakCanaryVersion")
    ...
}

@DelicateCoroutinesApi
class MainActivity : ComponentActivity() {

    // 匿名内部类隐式持有activity引用
    private val handler: Handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            Log.d(TAG, "handleMessage: handler msg: ${msg.what}")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            val context = LocalContext.current

            AVPlayerTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    Column(
                        modifier = Modifier.fillMaxSize(),
                        horizontalAlignment = Alignment.CenterHorizontally,
                        verticalArrangement = Arrangement.SpaceEvenly
                    ) {
                        Button(
                            onClick = {
                                GlobalScope.launch(Dispatchers.IO) {
                                    while (true) {
                                        handler.sendEmptyMessage(1)
                                        delay(1000)
                                    }
                                }
                                Toast.makeText(context, "start job.", Toast.LENGTH_SHORT).show()
                            },
                        ) {
                            Text(text = "start job")
                        }
                        Button(
                            onClick = {
                                startActivity(Intent(context, SecondActivity::class.java))
                                finish()
                            }
                        ) {
                            Text(text = "start activity")
                        }
                    }
                }
            }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "onDestroy: called")
    }

    companion object {
        private const val TAG = "MainActivity"
    }
}

...
refWatcher = LeakCanary.install(this);
...

internal class MainProcessAppWatcherInstaller : ContentProvider() {

  override fun onCreate(): Boolean {
    val application = context!!.applicationContext as Application
    AppWatcher.manualInstall(application)
    return true
  }

  // 增删改查的零实现
  override fun query(
    uri: Uri,
    projectionArg: Array<String>?,
    selection: String?,
    selectionArgs: Array<String>?,
    sortOrder: String?
  ): Cursor? = null

  override fun getType(uri: Uri): String? = null

  override fun insert(uri: Uri, contentValues: ContentValues?): Uri? = null

  override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0

  override fun update(
    uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?
  ): Int = 0
}

@JvmOverloads
  fun manualInstall(
    application: Application,
    retainedDelayMillis: Long = TimeUnit.SECONDS.toMillis(5),
    watchersToInstall: List<InstallableWatcher> = appDefaultWatchers(application)
  ) {
    // 检查是否在主线程中
    checkMainThread()

    // 如果已经安装过了则抛异常
    if (isInstalled) {
      throw IllegalStateException(
        "AppWatcher already installed, see exception cause for prior install call", installCause
      )
    }

    // 检查输入参数 retainedDelayMillis 的合法性
    check(retainedDelayMillis >= 0) {
      "retainedDelayMillis $retainedDelayMillis must be at least 0 ms"
    }
    this.retainedDelayMillis = retainedDelayMillis

    // debug时开启日志
    if (application.isDebuggableBuild) {
      LogcatSharkLog.install()
    }

    // Requires AppWatcher.objectWatcher to be set
    LeakCanaryDelegate.loadLeakCanary(application)

    // 为传入待注册的 InstallableWatcher 一一调用注册
    watchersToInstall.forEach {
      it.install()
    }
    
    // Only install after we're fully done with init.
    installCause = RuntimeException("manualInstall() first called here")
  }

fun appDefaultWatchers(
  application: Application,
  reachabilityWatcher: ReachabilityWatcher = objectWatcher
): List<InstallableWatcher> {
  return listOf(
    ActivityWatcher(application, reachabilityWatcher),
    FragmentAndViewModelWatcher(application, reachabilityWatcher),
    RootViewWatcher(reachabilityWatcher),
    ServiceWatcher(reachabilityWatcher)
  )
}

/**
 * Expects activities to become weakly reachable soon after they receive the [Activity.onDestroy]
 * callback.
 */
class ActivityWatcher(
  private val application: Application,
  private val reachabilityWatcher: ReachabilityWatcher
) : InstallableWatcher {

  private val lifecycleCallbacks =
    object : Application.ActivityLifecycleCallbacks by noOpDelegate() {
      override fun onActivityDestroyed(activity: Activity) {
        reachabilityWatcher.expectWeaklyReachable(
          activity, "${activity::class.java.name} received Activity#onDestroy() callback"
        )
      }
    }

  override fun install() {
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
  }

  override fun uninstall() {
    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks)
  }
}

import java.lang.ref.ReferenceQueue
import java.lang.ref.WeakReference

fun main() {
  val rq = ReferenceQueue<Pair<String, Int>?>()
  // var pair: Pair<String, Int>? = "kotlin" to 233  // 仿 LeakCanary 使用键值对  此处为强引用
  val weakReference = WeakReference(pair, rq)  // 创建弱引用并关联引用队列

  println(rq.poll())

  pair = null  // 清除对键值对的强引用
  System.gc()  // 手动gc一把
  Thread.sleep(1000)  // 开始gc后阻塞retainedTimeMills时间，等待pair被回收

  println(rq.poll())
}

// AppWatcher.kt
val objectWatcher = ObjectWatcher(
    clock = { SystemClock.uptimeMillis() },
    checkRetainedExecutor = {
      check(isInstalled) {
        "AppWatcher not installed"
      }
      mainHandler.postDelayed(it, retainedDelayMillis)
    },  // 通过 Executor 实现延迟探测
    isEnabled = { true }
  )
...

fun appDefaultWatchers(
  application: Application,
  reachabilityWatcher: ReachabilityWatcher = objectWatcher
): List<InstallableWatcher> {
  return listOf(
    ActivityWatcher(application, reachabilityWatcher),
    ...
    )
  }

// ObjectWatcher.kt
class ObjectWatcher constructor(
  private val clock: Clock,
  private val checkRetainedExecutor: Executor,
  private val isEnabled: () -> Boolean = { true }
) : ReachabilityWatcher {

  private val watchedObjects = mutableMapOf<String, KeyedWeakReference>()  // 以键值对形式保存传入的观察对象弱引用。当对象弱可达时会被移出map
  private val queue = ReferenceQueue<Any>()  // 维护了一个上文提到的引用队列
  ...
  @Synchronized override fun expectWeaklyReachable(
    watchedObject: Any,  // 调用方法时传入观察对象，如 Activity
    description: String
  ) {
    if (!isEnabled()) {
      return
    }
    // 由于我们判别内存泄漏的依据是看引用队列是否返回null，故先在引用队列中将弱可达的引用清除。
    removeWeaklyReachableObjects()  
    val key = UUID.randomUUID()
      .toString()
    val watchUptimeMillis = clock.uptimeMillis()
    val reference =
      KeyedWeakReference(
        watchedObject, 
        key, 
        description,
        watchUptimeMillis, 
        queue
      )  // 构造弱引用，关联引用队列

    watchedObjects[key] = reference  // 每个传入的观察对象都会存入这个map
    checkRetainedExecutor.execute {
      moveToRetained(key)  // 工作线程中延迟retainedDelayMillis再执行。
    }
  }
  ...
  // 这个函数被反复调用
  private fun removeWeaklyReachableObjects() {
    var ref: KeyedWeakReference?
    do {
      ref = queue.poll() as KeyedWeakReference?
      if (ref != null) {
        // 返回值不为null，说明当前这个被观察的对象未发生内存泄漏，故将其从map中移除
        watchedObjects.remove(ref.key)
      }
    } while (ref != null) // 清空队列
  }
  ...
  @Synchronized private fun moveToRetained(key: String) {
    removeWeaklyReachableObjects()
    val retainedRef = watchedObjects[key]
    if (retainedRef != null) {
      // 由于弱可达（未内存泄漏）的观察对象都已经过removeWeaklyReachableObjects()从watchedObjects
      // 移除，故对于当前观察对象，若其在watchedObjects中仍存在，则证明其发生了内存泄漏。
      retainedRef.retainedUptimeMillis = clock.uptimeMillis()  // 标记该对象内存泄漏了
      onObjectRetainedListeners.forEach { it.onObjectRetained() }  // 调用发生内存泄漏时的回调
    }
  }
}

// HeapDumpTrigger.kt 对应实例InternalLeakCanary.heapDumpTrigger
private fun checkRetainedObjects() {
  ...

  // 统计可能发生了内存泄漏的被观察对象的个数。返回的正是 watchedObjects.count
  var retainedReferenceCount = objectWatcher.retainedObjectCount

  // 由于没有被回收的原因可能是延迟等待时间不够长， GC 尚未来得及回收，故这里再进行一次 GC
  if (retainedReferenceCount > 0) {
    gcTrigger.runGc()
    retainedReferenceCount = objectWatcher.retainedObjectCount
  }

  if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return

  val now = SystemClock.uptimeMillis()
  val elapsedSinceLastDumpMillis = now - lastHeapDumpUptimeMillis
  // 为避免频繁dump操作，节省资源，两次 dump 之间时间间隔少于阈值则直接返回
  if (elapsedSinceLastDumpMillis < WAIT_BETWEEN_HEAP_DUMPS_MILLIS) {
    onRetainInstanceListener.onEvent(DumpHappenedRecently)
    showRetainedCountNotification(
      objectCount = retainedReferenceCount,
      contentText = application.getString(R.string.leak_canary_notification_retained_dump_wait)
    )
    scheduleRetainedObjectCheck(
      delayMillis = WAIT_BETWEEN_HEAP_DUMPS_MILLIS - elapsedSinceLastDumpMillis
    )
    return
  }

  dismissRetainedCountNotification()
  val visibility = if (applicationVisible) "visible" else "not visible"
  // 执行 dump 操作
  dumpHeap(
    retainedReferenceCount = retainedReferenceCount,
    retry = true,
    reason = "$retainedReferenceCount retained objects, app is $visibility"
  )
}

private fun dumpHeap(
  retainedReferenceCount: Int,
  retry: Boolean,
  reason: String
) {
  // 指定 dump 路径 新建文件
  val directoryProvider =
    InternalLeakCanary.createLeakDirectoryProvider(InternalLeakCanary.application)
  val heapDumpFile = directoryProvider.newHeapDumpFile()

  val durationMillis: Long
  if (currentEventUniqueId == null) {
    currentEventUniqueId = UUID.randomUUID().toString()
  }
  try {
    InternalLeakCanary.sendEvent(DumpingHeap(currentEventUniqueId!!))

    if (heapDumpFile == null) {
      throw RuntimeException("Could not create heap dump file")
    }
    saveResourceIdNamesToMemory()
    val heapDumpUptimeMillis = SystemClock.uptimeMillis()
    KeyedWeakReference.heapDumpUptimeMillis = heapDumpUptimeMillis
    durationMillis = measureDurationMillis {
      // 关键：执行dump hprof到指定文件
      configProvider().heapDumper.dumpHeap(heapDumpFile)

    }
    if (heapDumpFile.length() == 0L) {
      throw RuntimeException("Dumped heap file is 0 byte length")
    }
    lastDisplayedRetainedObjectCount = 0
    lastHeapDumpUptimeMillis = SystemClock.uptimeMillis()
    objectWatcher.clearObjectsWatchedBefore(heapDumpUptimeMillis)
    currentEventUniqueId = UUID.randomUUID().toString()

    // 关键：开启 workManager 进行堆分析
    InternalLeakCanary.sendEvent(HeapDump(currentEventUniqueId!!, heapDumpFile, durationMillis, reason))

  } catch (throwable: Throwable) {
    // dump 失败了，重试，再不行就显示通知提示失败
    InternalLeakCanary.sendEvent(HeapDumpFailed(currentEventUniqueId!!, throwable, retry))

    if (retry) {
      scheduleRetainedObjectCheck(
        delayMillis = WAIT_AFTER_DUMP_FAILED_MILLIS
      )
    }
    showRetainedCountNotification(
      objectCount = retainedReferenceCount,
      contentText = application.getString(
        R.string.leak_canary_notification_retained_dump_failed
      )
    )
    return
  }
}

// HeapDumpTrigger.kt
durationMillis = measureDurationMillis {
  configProvider().heapDumper.dumpHeap(heapDumpFile)
}

// LeakCanary.kt
val heapDumper: HeapDumper = AndroidDebugHeapDumper,

// AndroidDebugHeapDumper.kt
object AndroidDebugHeapDumper : HeapDumper {
  override fun dumpHeap(heapDumpFile: File) {
    Debug.dumpHprofData(heapDumpFile.absolutePath)
  }
}

// HeapDumpTrigger.kt
InternalLeakCanary.sendEvent(
  HeapDump(
    currentEventUniqueId!!, 
    heapDumpFile, 
    durationMillis, 
    reason
  )
)

// EventListener.kt
fun interface EventListener {

  // 同属于Event，但需要各自不同的参数，故使用sealed class
  sealed class Event(
    val uniqueId: String
  ) : Serializable {

    class DumpingHeap(uniqueId: String) : Event(uniqueId)

    // 这里可见以上代码中的HeapDump就是一种 Event
    class HeapDump(
      uniqueId: String,
      val file: File,
      val durationMillis: Long,
      val reason: String
    ) : Event(uniqueId)

    class HeapDumpFailed(
      uniqueId: String,
      val exception: Throwable,
      val willRetryLater: Boolean
    ) : Event(uniqueId)

    class HeapAnalysisProgress(
      uniqueId: String,
      val step: Step,
      val progressPercent: Double
    ) : Event(uniqueId)

    ...
  }

  fun onEvent(event: Event)
}

// InternalLeakCanary.kt
fun sendEvent(event: Event) {
  for(listener in LeakCanary.config.eventListeners) {
    listener.onEvent(event)
  }
}

// LeakCanary.kt
val eventListeners: List<EventListener> = listOf(
  LogcatEventListener,  // 负责在接收到对应事件时打印日志
  ToastEventListener,  // 负责在接收到对应事件时弹出Toast
  LazyForwardingEventListener { // 负责在接收到对应事件时弹出通知
    if (InternalLeakCanary.formFactor == TV) TvEventListener else NotificationEventListener
  },
  // 关键： 创建工作线程，对堆快照文件进行分析。之前版本中使用的是 Service
  when {
      RemoteWorkManagerHeapAnalyzer.remoteLeakCanaryServiceInClasspath ->
        RemoteWorkManagerHeapAnalyzer
      WorkManagerHeapAnalyzer.validWorkManagerInClasspath -> WorkManagerHeapAnalyzer
      else -> BackgroundThreadHeapAnalyzer
  }
),

// WorkManagerHeapAnalyzer.kt
object WorkManagerHeapAnalyzer : EventListener {

  // 只有当我们的app导入了相关依赖后才能确定有workManager可以用，并且对其版本也有要求，
  // 故这里只能通过反射动态加载workManager类，供后续使用
  internal val validWorkManagerInClasspath by lazy {
    try {
      Class.forName("androidx.work.WorkManager")
      val dataBuilderClass = Class.forName("androidx.work.Data\$Builder")
      dataBuilderClass.declaredMethods.any { it.name == "putByteArray" }.apply {
        if (!this) {
          SharkLog.d { "Could not find androidx.work.Data\$Builder.putByteArray, WorkManager should be at least 2.1.0." }
        }
      }
    } catch (ignored: Throwable) {
      false
    }
  }

  ...

  override fun onEvent(event: Event) {
    if (event is HeapDump) {
      // HeapAnalyzerWorker继承自Worker
      val heapAnalysisRequest = OneTimeWorkRequest.Builder(HeapAnalyzerWorker::class.java).apply {
        setInputData(event.asWorkerInputData())
        addExpeditedFlag()
      }.build()
      SharkLog.d { "Enqueuing heap analysis for ${event.file} on WorkManager remote worker" }
      val application = InternalLeakCanary.application
      // 获取workManager实例并执行worker
      WorkManager.getInstance(application).enqueue(heapAnalysisRequest)
    }
  }
}

// HeapAnalyzerWorker.kt
internal class HeapAnalyzerWorker(appContext: Context, workerParams: WorkerParameters) :
  Worker(appContext, workerParams) {
  override fun doWork(): Result {
    // 关键：调用runAnalysisBlocking进行分析
    val doneEvent =
      AndroidDebugHeapAnalyzer.runAnalysisBlocking(inputData.asEvent()) { event ->
        InternalLeakCanary.sendEvent(event)
      }
    InternalLeakCanary.sendEvent(doneEvent)
    return Result.success()
  }

  ...
}

// AndroidDebugHeapAnalyzer.kt
fun runAnalysisBlocking(
    heapDumped: HeapDump,
    isCanceled: () -> Boolean = { false },
    progressEventListener: (HeapAnalysisProgress) -> Unit
  ): HeapAnalysisDone<*> {
  val progressListener = OnAnalysisProgressListener { step ->
    val percent = (step.ordinal * 1.0) / OnAnalysisProgressListener.Step.values().size
    progressEventListener(HeapAnalysisProgress(heapDumped.uniqueId, step, percent))
  }

  val heapDumpFile = heapDumped.file
  val heapDumpDurationMillis = heapDumped.durationMillis
  val heapDumpReason = heapDumped.reason

  val heapAnalysis = if (heapDumpFile.exists()) {
    // 使用Shark API 进行堆分析
    analyzeHeap(heapDumpFile, progressListener, isCanceled)
  } else {
    missingFileFailure(heapDumpFile)
  }

  ...省略一大段代码
}

private fun analyzeHeap(
    heapDumpFile: File,
    progressListener: OnAnalysisProgressListener,
    isCanceled: () -> Boolean
  ): HeapAnalysis {
    val config = LeakCanary.config
    val heapAnalyzer = HeapAnalyzer(progressListener)
    val proguardMappingReader = try {
      ProguardMappingReader(application.assets.open(PROGUARD_MAPPING_FILE_NAME))
    } catch (e: IOException) {
      null
    }

    progressListener.onAnalysisProgress(PARSING_HEAP_DUMP)

    val sourceProvider =
      ConstantMemoryMetricsDualSourceProvider(ThrowingCancelableFileSourceProvider(heapDumpFile) {
        if (isCanceled()) {
          throw RuntimeException("Analysis canceled")
        }
      })

    // Shark API openHeapGraph将解析指定hprof文件并返回一个描述其结构的图(graph)
    val closeableGraph = try {
      sourceProvider.openHeapGraph(proguardMapping = proguardMappingReader?.readProguardMapping())
    } catch (throwable: Throwable) {
      return HeapAnalysisFailure(
        heapDumpFile = heapDumpFile,
        createdAtTimeMillis = System.currentTimeMillis(),
        analysisDurationMillis = 0,
        exception = HeapAnalysisException(throwable)
      )
    }
    return closeableGraph
      .use { graph ->
        // 向heapAnalyzer.analyze函数传入graph进行分析，结果包装为result
        val result = heapAnalyzer.analyze(
          heapDumpFile = heapDumpFile,
          graph = graph,
          leakingObjectFinder = config.leakingObjectFinder,
          referenceMatchers = config.referenceMatchers,
          computeRetainedHeapSize = config.computeRetainedHeapSize,
          objectInspectors = config.objectInspectors,
          metadataExtractor = config.metadataExtractor
        )
        if (result is HeapAnalysisSuccess) {
          val lruCacheStats = (graph as HprofHeapGraph).lruCacheStats()
          val randomAccessStats =
            "RandomAccess[" +
              "bytes=${sourceProvider.randomAccessByteReads}," +
              "reads=${sourceProvider.randomAccessReadCount}," +
              "travel=${sourceProvider.randomAccessByteTravel}," +
              "range=${sourceProvider.byteTravelRange}," +
              "size=${heapDumpFile.length()}" +
              "]"
          val stats = "$lruCacheStats $randomAccessStats"
          result.copy(metadata = result.metadata + ("Stats" to stats))
        } else result
      }
  }

interface HeapGraph {
  val identifierByteSize: Int

  val context: GraphContext

  val objectCount: Int

  val classCount: Int

  val instanceCount: Int

  val objectArrayCount: Int

  val primitiveArrayCount: Int

  val gcRoots: List<GcRoot>

  //所有对象的序列，包括类对象、实例对象、对象数组、原始类型数组
  val objects: Sequence<HeapObject>

  //类对象序列
  val classes: Sequence<HeapClass>

  //实例对象数组
  val instances: Sequence<HeapInstance>

  //对象数组序列
  val objectArrays: Sequence<HeapObjectArray>

  //原始类型数组序列
  val primitiveArrays: Sequence<HeapPrimitiveArray>

  @Throws(IllegalArgumentException::class)
  fun findObjectById(objectId: Long): HeapObject

  @Throws(IllegalArgumentException::class)
  fun findObjectByIndex(objectIndex: Int): HeapObject

  fun findObjectByIdOrNull(objectId: Long): HeapObject?

  // 关键
  fun findClassByName(className: String): HeapClass?

  fun objectExists(objectId: Long): Boolean

  fun findHeapDumpIndex(objectId: Long): Int

  fun findObjectByHeapDumpIndex(heapDumpIndex: Int): HeapObject
}

private fun State.findPathsFromGcRoots(): PathFindingResults {
  // 首先让 GCRoots 对象全部入队
  enqueueGcRoots()

  val shortestPathsToLeakingObjects = mutableListOf<ReferencePathNode>()
  visitingQueue@ while (queuesNotEmpty) {
    val node = poll() // 队列中对象依次出队

    // 如果是内存泄漏的对象，则记录下来，否则继续
    if (leakingObjectIds.contains(node.objectId)) {
      shortestPathsToLeakingObjects.add(node) // 存储发生了内存泄漏的对象，用于反推引用链

      // 判断已经找到的内存泄漏的对象个数，如果已经找完了则提前结束搜索
      if (shortestPathsToLeakingObjects.size == leakingObjectIds.size()) {
        if (computeRetainedHeapSize) {
          listener.onAnalysisProgress(FINDING_DOMINATORS)
        } else {
          break@visitingQueue
        }
      }
    }

    // 解析对象
    val heapObject = graph.findObjectById(node.objectId)
    objectReferenceReader.read(heapObject).forEach { reference ->
      // 解析邻居 邻居入队
      val newNode = ChildNode(
        objectId = reference.valueObjectId,
        parent = node,
        lazyDetailsResolver = reference.lazyDetailsResolver
      )
      enqueue(newNode, isLowPriority = reference.isLowPriority)
    }
  }

  // 路径解析通过反推链表完成，这里不再赘述
  return PathFindingResults(
    shortestPathsToLeakingObjects,
    if (visitTracker is Dominated) visitTracker.dominatorTree else null
  )
}

fun onRefresh() { ... }
fun onRetry() { ... }
fun onKeywordChange(value: String) { ... }
fun onItemClick(id: String) { ... }

import kotlin.concurrent.thread  
  
val name = ThreadLocal<String>()  
  
thread {  
    name.set("hello")  
    println("thread-1 name: ${name.get()}")  
}.join()  
  
thread {  
    name.set("world")  
    println("thread-2-name: ${name.get()}")  
}.join()

val intNum = 100          // 默认推断为 Int
val longNum = 100L        // L 后缀表示 Long
val floatNum = 3.14f      // f 后缀表示 Float
val doubleNum = 3.14      // 默认推断为 Double
val hexNum = 0xFF         // 十六进制
val binaryNum = 0b1010    // 二进制
val readable = 1_000_000  // 支持下划线分隔，提升可读性

val i: Int = 100
val l: Long = i.toLong()  // ✅ 正确
// val l: Long = i        // ❌ 编译错误

public abstract class Number {  
    public abstract fun toDouble(): Double  
    public abstract fun toFloat(): Float  
    public abstract fun toLong(): Long  
    public abstract fun toInt(): Int  
    public abstract fun toChar(): Char  // Deprecated
    public abstract fun toShort(): Short  
    public abstract fun toByte(): Byte  
}

val letter: Char = 'A'
val str = "Hello, Kotlin"
val multiLine = """
    这是多行字符串
    保留原始格式
""".trimIndent()

val char: Char = 'A'  
val i: Int = char.code // Code of a Char is the value it was constructed with, and the UTF-16 code unit corresponding to this Char.  
val l: Long = char.code.toLong()  
val c: Char = i.toChar() // significant 16 bits of this Int value.  
val d: Char = i.digitToChar() // decimal digit

val name = "World"
println("Hello, $name!")           // 简单变量
println("长度是 ${name.length}")    // 表达式

val isKotlinFun: Boolean = true

// 泛型数组
val arr = arrayOf(1, 2, 3)

// 原始类型数组（避免装箱开销）
val intArr = intArrayOf(1, 2, 3)

val x = 1        // 字面量语法，编译器直接处理
val y = Int(1)   // ❌ 编译错误！Int 没有公开构造函数

val a: Int = 1      // 底层: int
val b: Int? = 1     // 底层: Integer（才能存 null）

val list = listOf(1, 2, 3)  // List<Int> → List<Integer>
// 每个元素都被装箱了！

// 装箱数组
val boxed: Array<Int> = arrayOf(1, 2, 3)
// 底层: Integer[] {Integer.valueOf(1), Integer.valueOf(2), ...}

// 原始类型数组
val primitive: IntArray = intArrayOf(1, 2, 3)
// 底层: int[] {1, 2, 3}

// Kotlin：编译器帮你选择
val a: Int = 1    // 底层是 int
val b: Int? = 1   // 底层是 Integer（因为可空）

// 1. 尽量用非空类型
val x: Int = 1      // ✅ 底层是 int

// 2. 数值数组用原始类型版本
val arr = IntArray(1000)       // ✅ int[]
val arr = Array<Int>(1000){0}  // ❌ Integer[]

// 3. 性能敏感场景注意泛型集合的装箱开销

class Grid<T>(private val data: Array<Array<T>>) {
    operator fun get(x: Int, y: Int): T = data[x][y]
    operator fun set(x: Int, y: Int, v: T) { data[x][y] = v }
}

fun main() {
	val g = Grid(arrayOf(arrayOf(1, 2), arrayOf(3, 4)))
	println(g[1, 0]) // 等价于 g.get(1, 0)
	g[0, 1] = 9      // 等价于 g.set(0, 1, 9)
}

@kotlin.internal.InlineOnly  
public inline operator fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get(key: K): V? =  
    @Suppress("UNCHECKED_CAST") (this as Map<K, V>).get(key)  
  
/**  
 * Allows to use the index operator for storing values in a mutable map. */@kotlin.internal.InlineOnly  
public inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V): Unit {  
    put(key, value)  
}

val m = mapOf("a" to 1)
println(m["a"]) // 1
println(m["b"]) // null

val list = listOf(10, 20)
println(list[1]) // 20
println(list[2]) // 抛异常