val number = 42
println(number.toString()) // 直接调用 Int 类型的方法

int number = 42;
System.out.println(Integer.toString(number)); // 需要使用包装类的静态方法

class Person(val name: String, val age: Int)val person = Person("John", 30) // person 是对 Person 对象的引用

val number = 42 // 编译器自动推断为 Int 类型
val text = "Hello, Kotlin!" // 编译器自动推断为 String 类型
val isDone = false // 编译器自动推断为 Boolean 类型

fun add(a: Int, b: Int) = a + b // 返回值类型自动推断为 Int

val number: Int = 42 // 显式指定 Int 类型
val text: String = "Hello, Kotlin!" // 显式指定 String 类型
val isDone: Boolean = false // 显式指定 Boolean 类型

val number: Int // 声明变量但不初始化
number = 42 // 后续初始化

val number: Long = 42 // 显式指定 Long 类型，即使值可以被推断为 Int

val result: Map<String, List<Int>> = computeResult() // 显式类型使代码更易读

var text: String = "Hello" // 非可空类型，不能赋值为 null
text = null // 编译错误：Null can not be a value of a non-null type String

var text: String? = "Hello" // 可空类型，可以赋值为 null
text = null // 合法

val length: Int? = text?.length // 如果 text 为 null，返回 null，否则返回 length

val nullableInt: Int? = null // 编译为 java.lang.Integer
val nonNullInt: Int = 42 // 编译为 int

val number = 42
println(number.toString()) // 直接调用 Int 类型的方法
println(number.inc())      // 调用递增方法

val byteValue: Byte = 127 // 合法，在 Byte 范围内
// val byteValue: Byte = 128 // 编译错误，超出 Byte 范围

val shortValue: Short = 32767 // 合法，在 Short 范围内
// val shortValue: Short = 32768 // 编译错误，超出 Short 范围

val intValue = 42 // 自动推断为 Int 类型

val longValue: Long = 9223372036854775807L // 合法，Long 最大值
val anotherLong = 1234567890123L // 自动推断为 Long 类型

// Kotlin 代码
fun add(a: Int, b: Int): Int {return a + b
}

// 等效的 Java 代码
public static int add(int a, int b) {return a + b;
}

// Kotlin 代码
val list: List<Int> = listOf(1, 2, 3)

// 等效的 Java 代码
List<Integer> list = Arrays.asList(Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3));

val a = 10
val b = 3
println(a + b) // 输出: 13
println(a - b) // 输出: 7
println(a * b) // 输出: 30
println(a / b) // 输出: 3（整数除法截断结果）
println(a % b) // 输出: 1

val x = 0b1010 // 二进制表示 10
val y = 0b1100 // 二进制表示 12println(x and y)  // 按位与: 0b1000 (8)
println(x or y)   // 按位或: 0b1110 (14)
println(x xor y)  // 按位异或: 0b0110 (6)
println(x.inv())  // 按位取反: -11 (二进制补码表示)
println(x shl 2)  // 左移: 0b101000 (40)
println(x shr 1)  // 右移: 0b0101 (5)
println(x ushr 1) // 无符号右移: 0b0101 (5)

val a = 10
val b = 20println(a > b)  // 输出: false
println(a < b)  // 输出: true
println(a >= b) // 输出: false
println(a <= b) // 输出: true
println(a == b) // 输出: false
println(a != b) // 输出: true

val number = -42
println(number.toString())     // 输出: "-42"
println(number.absoluteValue)  // 输出: 42
println(number.inc())          // 输出: -41
println(number.dec())          // 输出: -43

val floatValue: Float = 3.14f // 显式指定为 Float 类型
// val floatValue: Float = 3.14 // 编译错误，3.14 默认是 Double 类型

val doubleValue = 3.14 // 自动推断为 Double 类型
val anotherDouble: Double = 1.234567890123456789 // 高精度值

// Kotlin 代码
fun processFloat(value: Float): Double {return value.toDouble()
}

// 等效的 Java 代码
public static double processFloat(float value) {return (double) value;
}

// Kotlin 代码
val list: List<Float> = listOf(1.0f, 2.0f, 3.0f)

// 等效的 Java 代码
List<Float> list = Arrays.asList(Float.valueOf(1.0f), Float.valueOf(2.0f), Float.valueOf(3.0f));

val a = 3.14
val b = 2.71println(a + b) // 输出: 5.85
println(a - b) // 输出: 0.43
println(a * b) // 输出: 8.5094
println(a / b) // 输出: 1.1586715867158672

val result = 0.1 + 0.2
println(result) // 输出: 0.30000000000000004，而不是精确的 0.3

fun equals(a: Double, b: Double, epsilon: Double = 1e-10): Boolean {return Math.abs(a - b) < epsilon
}val a = 0.1 + 0.2
val b = 0.3
println(equals(a, b)) // 输出: true

val number = -3.14
println(number.absoluteValue) // 输出: 3.14
println(number.roundToInt())  // 输出: -3（四舍五入为整数）
println(number.floorToInt())  // 输出: -4（向下取整）
println(number.ceilToInt())   // 输出: -3（向上取整）

val a: Int = 1000
val b: Byte = a.toByte() // 显式转换，可能会导致数据丢失
println(b) // 输出: -24（1000 超出了 Byte 的范围，发生溢出）val c: Double = a.toDouble() // 转换为 Double 类型，不会丢失精度
println(c) // 输出: 1000.0val d: Float = 3.14f
val e: Int = d.toInt() // 转换为 Int 类型，小数部分被截断
println(e) // 输出: 3

val longValue: Long = 9223372036854775807L
val intValue: Int = longValue.toInt() // 数据溢出，结果为 -1val doubleValue: Double = 1.234567890123456789
val floatValue: Float = doubleValue.toFloat() // 精度损失，Float 只能表示约 7 位有效数字val floatValue2: Float = 3.99f
val intValue2: Int = floatValue2.toInt() // 小数部分被截断，结果为 3

val a: Int = 10
val b: Long = 20L
// val result: Int = a + b // 编译错误：类型不匹配
val result: Long = a.toLong() + b // 显式转换 a 为 Long 类型
println(result) // 输出: 30

val a: Int = 5
val b: Double = 2.5
val result: Double = a.toDouble() + b // 显式转换 a 为 Double 类型
println(result) // 输出: 7.5

val nan = Double.NaN
val positiveInfinity = Double.POSITIVE_INFINITY
val negativeInfinity = Double.NEGATIVE_INFINITYprintln(0.0 / 0.0 == nan) // 输出: false，NaN 与任何值（包括自身）比较都不相等
println(nan.isNaN())      // 输出: true，使用 isNaN() 方法检查是否为 NaNprintln(1.0 / 0.0 == positiveInfinity) // 输出: true
println(-1.0 / 0.0 == negativeInfinity) // 输出: true

val a = 0b1010 // 二进制表示 10
val b = 0b1100 // 二进制表示 12println(a shl 2)  // 左移 2 位: 0b101000 (40)
println(a shr 1)  // 右移 1 位: 0b0101 (5)
println(a ushr 1) // 无符号右移 1 位: 0b0101 (5)println(a and b)  // 按位与: 0b1000 (8)
println(a or b)   // 按位或: 0b1110 (14)
println(a xor b)  // 按位异或: 0b0110 (6)
println(a.inv())  // 按位取反: -11 (二进制补码表示)

fun equals(a: Double, b: Double, epsilon: Double = 1e-10): Boolean {return Math.abs(a - b) < epsilon
}val a = 0.1 + 0.2
val b = 0.3
println(a == b)         // 输出: false
println(equals(a, b))   // 输出: true

val nan = Double.NaN
val positiveInfinity = Double.POSITIVE_INFINITY
val negativeInfinity = Double.NEGATIVE_INFINITYprintln(nan == nan) // 输出: false
println(nan.isNaN()) // 输出: trueprintln(positiveInfinity > 1000.0) // 输出: true
println(negativeInfinity < -1000.0) // 输出: true

/*** Represents a 32-bit signed integer.* On the JVM, non-nullable values of this type are represented as values of the primitive type `int`.*/
@file:kotlin.jvm.JvmName("KotlinInt")
@file:kotlin.jvm.JvmMultifileClasspackage kotlin@kotlin.internal.InlineOnly
public actual inline class Int internal constructor() {// 基本属性public actual val isZero: Boolean get() = this == 0public actual val isPositive: Boolean get() = this > 0public actual val isNegative: Boolean get() = this < 0// 绝对值public actual val absoluteValue: Int get() = if (this < 0) -this else this// 位宽public actual val bitLength: Int get() = when (this) {0 -> 0else -> 32 - this.countLeadingZeroBits()}// 基本运算public actual operator fun plus(other: Int): Int = this + otherpublic actual operator fun minus(other: Int): Int = this - otherpublic actual operator fun times(other: Int): Int = this * otherpublic actual operator fun div(other: Int): Int = this / otherpublic actual operator fun rem(other: Int): Int = this % other// 递增递减public actual operator fun inc(): Int = this + 1public actual operator fun dec(): Int = this - 1// 位运算public actual infix fun shl(bits: Int): Int = this shl bitspublic actual infix fun shr(bits: Int): Int = this shr bitspublic actual infix fun ushr(bits: Int): Int = this ushr bitspublic actual infix fun and(other: Int): Int = this and otherpublic actual infix fun or(other: Int): Int = this or otherpublic actual infix fun xor(other: Int): Int = this xor otherpublic actual fun inv(): Int = this.inv()// 转换方法public actual fun toByte(): Byte = this.toByte()public actual fun toShort(): Short = this.toShort()public actual fun toInt(): Int = thispublic actual fun toLong(): Long = this.toLong()public actual fun toFloat(): Float = this.toFloat()public actual fun toDouble(): Double = this.toDouble()public actual fun toChar(): Char = this.toChar()// 其他实用方法public actual fun compareTo(other: Int): Int = this.compareTo(other)public actual fun rangeTo(other: Int): IntRange = IntRange(this, other)public actual fun countLeadingZeroBits(): Int = java.lang.Integer.numberOfLeadingZeros(this)public actual fun countTrailingZeroBits(): Int = java.lang.Integer.numberOfTrailingZeros(this)public actual fun numberOfSetBits(): Int = java.lang.Integer.bitCount(this)public actual fun rotateLeft(bits: Int): Int = java.lang.Integer.rotateLeft(this, bits)public actual fun rotateRight(bits: Int): Int = java.lang.Integer.rotateRight(this, bits)public actual fun reverseBits(): Int = java.lang.Integer.reverse(this)public actual fun reverseBytes(): Int = java.lang.Integer.reverseBytes(this)
}

/*** Represents a 64-bit floating-point number.* On the JVM, non-nullable values of this type are represented as values of the primitive type `double`.*/
@file:kotlin.jvm.JvmName("KotlinDouble")
@file:kotlin.jvm.JvmMultifileClasspackage kotlin@kotlin.internal.InlineOnly
public actual inline class Double internal constructor() {// 特殊值public actual companion object {public actual val POSITIVE_INFINITY: Double = java.lang.Double.POSITIVE_INFINITYpublic actual val NEGATIVE_INFINITY: Double = java.lang.Double.NEGATIVE_INFINITYpublic actual val NaN: Double = java.lang.Double.NaNpublic actual val MAX_VALUE: Double = java.lang.Double.MAX_VALUEpublic actual val MIN_VALUE: Double = java.lang.Double.MIN_VALUEpublic actual val MIN_POSITIVE_VALUE: Double = java.lang.Double.MIN_NORMAL}// 基本属性public actual val isNaN: Boolean get() = this != thispublic actual val isInfinite: Boolean get() = this == POSITIVE_INFINITY || this == NEGATIVE_INFINITYpublic actual val isFinite: Boolean get() = !isNaN && !isInfinitepublic actual val isZero: Boolean get() = this == 0.0public actual val isPositive: Boolean get() = this > 0.0public actual val isNegative: Boolean get() = this < 0.0// 绝对值public actual val absoluteValue: Double get() = if (this < 0.0) -this else this// 基本运算public actual operator fun plus(other: Double): Double = this + otherpublic actual operator fun minus(other: Double): Double = this - otherpublic actual operator fun times(other: Double): Double = this * otherpublic actual operator fun div(other: Double): Double = this / otherpublic actual operator fun rem(other: Double): Double = this % other// 递增递减public actual operator fun inc(): Double = this + 1.0public actual operator fun dec(): Double = this - 1.0// 转换方法public actual fun toByte(): Byte = this.toByte()public actual fun toShort(): Short = this.toShort()public actual fun toInt(): Int = this.toInt()public actual fun toLong(): Long = this.toLong()public actual fun toFloat(): Float = this.toFloat()public actual fun toDouble(): Double = thispublic actual fun toChar(): Char = this.toChar()// 其他实用方法public actual fun compareTo(other: Double): Int = this.compareTo(other)public actual fun rangeTo(other: Double): ClosedFloatingPointRange<Double> = ClosedFloatingPointRange(this, other)public actual fun roundToInt(): Int = kotlin.math.roundToInt(this)public actual fun floorToInt(): Int = kotlin.math.floorToInt(this)public actual fun ceilToInt(): Int = kotlin.math.ceilToInt(this)public actual fun toIntExact(): Int = kotlin.math.toIntExact(this)public actual fun toLongExact(): Long = kotlin.math.toLongExact(this)
}

/*** Converts this value to a [Double].*/
@kotlin.internal.InlineOnly
public actual inline fun Int.toDouble(): Double = this.toDouble()

/*** Converts this [Double] value to an [Int].** This method truncates the fractional part of the value if it is not an integer.* If this value is outside the range of [Int], the result is undefined.*/
@kotlin.internal.InlineOnly
public actual inline fun Double.toInt(): Int = this.toInt()

/*** Converts this value to an [Int], checking for overflow.** @throws IllegalArgumentException if this value is outside the range of [Int].*/
public fun Double.toIntExact(): Int {if (this < Int.MIN_VALUE.toDouble() || this > Int.MAX_VALUE.toDouble()) {throw IllegalArgumentException("Value $this is out of range of Int")}val intValue = toInt()if (intValue.toDouble() != this) {throw IllegalArgumentException("Value $this cannot be represented exactly as an Int")}return intValue
}

// Kotlin 代码
fun isPositive(number: Int): Boolean {return number > 0
}

// 等效的 Java 代码
public static boolean isPositive(int number) {return number > 0;
}

// Kotlin 代码
val list: List<Boolean> = listOf(true, false, true)

// 等效的 Java 代码
List<Boolean> list = Arrays.asList(Boolean.valueOf(true), Boolean.valueOf(false), Boolean.valueOf(true));

val a = true
val b = false// 逻辑非
println(!a) // 输出: false
println(!b) // 输出: true// 逻辑与
println(a && b) // 输出: false
println(a && true) // 输出: true
println(b && false) // 输出: false// 逻辑或
println(a || b) // 输出: true
println(a || true) // 输出: true
println(b || false) // 输出: false// 短路求值
val result = a || (b && someFunction()) // 如果 a 为 true，则不会执行 someFunction()

fun Boolean.isFalse(): Boolean = !this// 使用示例
val flag = false
println(flag.isFalse()) // 输出: true

fun <T> Boolean.thenOrElse(thenValue: T, elseValue: T): T =if (this) thenValue else elseValue// 使用示例
val result = (5 > 3).thenOrElse("Greater", "Less")
println(result) // 输出: "Greater"

val number = 10
val result = if (number > 0) {"Positive"
} else if (number < 0) {"Negative"
} else {"Zero"
}println(result) // 输出: "Positive"

val number = 10
val result = when {number > 0 -> "Positive"number < 0 -> "Negative"else -> "Zero"
}println(result) // 输出: "Positive"

var count = 0
while (count < 5) {println(count)count++
}
// 输出: 0 1 2 3 4

var count = 0
do {println(count)count++
} while (count < 5)
// 输出: 0 1 2 3 4

/*** Represents a boolean value.* On the JVM, non-nullable values of this type are represented as values of the primitive type `boolean`.*/
@file:kotlin.jvm.JvmName("KotlinBoolean")
@file:kotlin.jvm.JvmMultifileClasspackage kotlin@kotlin.internal.InlineOnly
public actual inline class Boolean internal constructor() {// 基本运算public actual operator fun not(): Boolean = !thispublic actual infix fun and(other: Boolean): Boolean = this && otherpublic actual infix fun or(other: Boolean): Boolean = this || otherpublic actual infix fun xor(other: Boolean): Boolean = this xor other// 比较运算public actual fun compareTo(other: Boolean): Int = if (this == other) 0 else if (this) 1 else -1// 转换方法public actual fun toString(): String = if (this) "true" else "false"
}

/*** Returns this value if it satisfies the given [predicate], otherwise returns `null`.*/
@kotlin.internal.InlineOnly
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? =if (predicate(this)) this else null/*** Returns this value if it _does not_ satisfy the given [predicate], otherwise returns `null`.*/
@kotlin.internal.InlineOnly
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? =if (!predicate(this)) this else null

/*** Performs the given [action] on this value, then returns this value.*/
@kotlin.internal.InlineOnly
public inline fun <T> T.also(action: (T) -> Unit): T {action(this)return this
}

// Kotlin 代码
fun printChar(c: Char) {println(c)
}

// 等效的 Java 代码
public static void printChar(char c) {System.out.println(c);
}

// Kotlin 代码
val list: List<Char> = listOf('a', 'b', 'c')

// 等效的 Java 代码
List<Character> list = Arrays.asList(Character.valueOf('a'), Character.valueOf('b'), Character.valueOf('c'));

val tab = '\t'
val newline = '\n'
val quote = '\''
val backslash = '\\'
val dollar = '\$'// Unicode 字符
val euro = '\u20AC'
val heart = '\u2665'println("Tab: $tab, Newline: $newline, Quote: $quote, Backslash: $backslash, Euro: $euro, Heart: $heart")

val c: Char = 'A'
val code: Int = c.code // 获取字符的 Unicode 码点，'A' 的码点是 65println(code) // 输出: 65// 从数值转换为字符
val charFromInt: Char = 65.toChar()
println(charFromInt) // 输出: 'A'// 字符运算
val nextChar: Char = 'A' + 1
println(nextChar) // 输出: 'B'// 字符比较
println('A' < 'B') // 输出: true

val c: Char = 'A'// 判断字符类型
println(c.isLetter()) // 输出: true
println(c.isDigit())  // 输出: false
println(c.isUpperCase()) // 输出: true
println(c.isLowerCase()) // 输出: false
println(c.isWhitespace()) // 输出: false// 字符转换
println(c.toLowerCase()) // 输出: 'a'
println(c.toUpperCase()) // 输出: 'A'（已经是大写）// 数字字符的处理
val digit: Char = '5'
println(digit.isDigit()) // 输出: true
println(digit.digitToInt()) // 输出: 5

fun Char.isVowel(): Boolean =this.toLowerCase() in setOf('a', 'e', 'i', 'o', 'u')// 使用示例
val c: Char = 'A'
println(c.isVowel()) // 输出: true

fun Char.toMorseCode(): String =when (this.toLowerCase()) {'a' -> ".-"'b' -> "-..."'c' -> "-.-."'d' -> "-.."'e' -> "."// 其他字符的 Morse 码...else -> ""}// 使用示例
val c: Char = 'S'
println(c.toMorseCode()) // 输出: "..."

val str = "Hello"
val firstChar = str[0] // 获取第一个字符 'H'
println(firstChar) // 输出: 'H'// 遍历字符串中的所有字符
for (c in str) {println(c)
}
// 输出: H e l l o// 使用字符操作处理字符串
val upperCaseStr = str.map { it.toUpperCase() }.joinToString("")
println(upperCaseStr) // 输出: "HELLO"

/*** Represents a character.* On the JVM, non-nullable values of this type are represented as values of the primitive type `char`.*/
@file:kotlin.jvm.JvmName("KotlinChar")
@file:kotlin.jvm.JvmMultifileClasspackage kotlin@kotlin.internal.InlineOnly
public actual inline class Char internal constructor() {// 属性public actual val code: Int get() = this.code// 基本运算public actual operator fun plus(other: Int): Char = (this.code + other).toChar()// 比较运算public actual operator fun compareTo(other: Char): Int = this.code - other.code// 字符判断public actual fun isLetter(): Boolean = java.lang.Character.isLetter(this)public actual fun isDigit(): Boolean = java.lang.Character.isDigit(this)public actual fun isLetterOrDigit(): Boolean = java.lang.Character.isLetterOrDigit(this)public actual fun isWhitespace(): Boolean = java.lang.Character.isWhitespace(this)public actual fun isUpperCase(): Boolean = java.lang.Character.isUpperCase(this)public actual fun isLowerCase(): Boolean = java.lang.Character.isLowerCase(this)// 字符转换public actual fun toUpperCase(): Char = java.lang.Character.toUpperCase(this)public actual fun toLowerCase(): Char = java.lang.Character.toLowerCase(this)public actual fun digitToInt(): Int = java.lang.Character.digit(this, 10)// 其他方法public actual fun toString(): String = java.lang.Character.toString(this)
}

/*** Returns the Unicode code point at the given [index] in this character sequence.*/
public fun CharSequence.codePointAt(index: Int): Int {val c1 = this[index]if (c1.isHighSurrogate()) {if (index + 1 < length) {val c2 = this[index + 1]if (c2.isLowSurrogate()) {return Character.toCodePoint(c1, c2)}}}return c1.code
}

/*** Returns the number of leading zero bits in the binary representation of this [Char] value.*/
public actual fun Char.countLeadingZeroBits(): Int = code.countLeadingZeroBits() - 16

// 双引号字符串
val singleLine = "Hello, Kotlin!"// 三引号字符串（多行）
val multiLine = """This is a multi-line string.It can contain "quotes" and 'apostrophes' without escaping.Even newlines are preserved.
"""// 字符串模板
val name = "Alice"
val greeting = "Hello, $name!" // 简单变量替换
val price = 9.99
val message = "The price is ${price * 2} dollars." // 表达式替换

// Kotlin 代码
val str1 = "Hello"
val str2 = "Hello"
println(str1 === str2) // 输出: true，两个引用指向同一个字符串实例

// 等效的 Java 代码
String str1 = "Hello";
String str2 = "Hello";
System.out.println(str1 == str2); // 输出: true

val str = "Hello"
println(str.length) // 输出: 5
println(str[0])     // 输出: 'H'
println(str.last()) // 输出: 'o'

val name = "Alice"
val age = 30// 使用 + 连接
val message1 = "My name is " + name + " and I am " + age + " years old."// 使用字符串模板
val message2 = "My name is $name and I am $age years old."// 复杂表达式
val message3 = "The sum of 2 + 3 is ${2 + 3}."println(message1) // 输出: "My name is Alice and I am 30 years old."
println(message2) // 输出: "My name is Alice and I am 30 years old."
println(message3) // 输出: "The sum of 2 + 3 is 5."

val str1 = "Hello"
val str2 = "Hello"
val str3 = StringBuilder("He").append("llo").toString()println(str1 == str2)  // 输出: true，结构相同
println(str1 === str2) // 输出: true，引用相同（字符串常量池）
println(str1 == str3)  // 输出: true，结构相同
println(str1 === str3) // 输出: false，引用不同

val str = "Hello, Kotlin!"// 搜索
println(str.contains("Kotlin")) // 输出: true
println(str.startsWith("Hello")) // 输出: true
println(str.endsWith("!")) // 输出: true
println(str.indexOf("Kotlin")) // 输出: 7// 替换
println(str.replace("Kotlin", "Java")) // 输出: "Hello, Java!"
println(str.replaceFirst("l", "L")) // 输出: "HeLlo, Kotlin!"

val str = "Hello,World,Kotlin"// 分割
val parts = str.split(",")
println(parts) // 输出: [Hello, World, Kotlin]// 连接
val joined = parts.joinToString("-")
println(joined) // 输出: "Hello-World-Kotlin"

val str = "Hello, Kotlin!"println(str.toUpperCase()) // 输出: "HELLO, KOTLIN!"
println(str.toLowerCase()) // 输出: "hello, kotlin!"

fun String.reverse(): String = this.reversed()// 使用示例
val str = "Hello"
println(str.reverse()) // 输出: "olleH"

fun String.isPalindrome(): Boolean = this == this.reversed()// 使用示例
val palindrome = "radar"
println(palindrome.isPalindrome()) // 输出: true

val text = "Hello 123 World 456"
val regex = Regex("\\d+") // 匹配一个或多个数字// 查找所有匹配
val matches = regex.findAll(text)
for (match in matches) {println(match.value) // 输出: 123, 456
}// 替换匹配
val replaced = regex.replace(text, "###")
println(replaced) // 输出: "Hello ### World ###"

import java.io.File// 读取文件内容为字符串
val content = File("example.txt").readText()
println(content)// 将字符串写入文件
val text = "Hello, Kotlin!"
File("output.txt").writeText(text)

// 字符串长度属性
public val String.length: Intget() = this.length()// 索引访问操作符
public operator fun String.get(index: Int): Char =if (index >= 0 && index < length)get(index)elsethrow IndexOutOfBoundsException("Index: $index, Size: $length")// 字符串反转
public fun String.reversed(): String {if (length <= 1) return thisreturn StringBuilder(this).reverse().toString()
}// 字符串模板处理
@kotlin.internal.InlineOnly
public inline operator fun String.invoke(): String = this

/*** Splits this string around matches of the given [delimiters].*/
public fun String.split(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): List<String> {if (delimiters.isEmpty()) {return listOf(this)}return splitToSequence(*delimiters, ignoreCase = ignoreCase, limit = limit).toList()
}

/*** Concatenates the elements of this collection into a string, separated by the given [separator],* and optionally prefixed by the [prefix] and suffixed by the [suffix].*/
public fun <T> Iterable<T>.joinToString(separator: CharSequence = ", ",prefix: CharSequence = "",suffix: CharSequence = "",limit: Int = -1,truncated: CharSequence = "...",transform: ((T) -> CharSequence)? = null
): String {return joinTo(StringBuilder(), separator, prefix, suffix, limit, truncated, transform).toString()
}

// 创建指定大小的数组，元素初始化为默认值
val array1: Array<Int> = Array(5) { 0 } // [0, 0, 0, 0, 0]// 使用 arrayOf 创建数组
val array2 = arrayOf(1, 2, 3, 4, 5) // [1, 2, 3, 4, 5]// 使用 arrayOfNulls 创建可空元素的数组
val array3: Array<String?> = arrayOfNulls(3) // [null, null, null]// 使用工厂函数创建数组
val array4 = Array(5) { i -> i * 2 } // [0, 2, 4, 6, 8]

// Kotlin 代码
val intArray: IntArray = intArrayOf(1, 2, 3)
val boxedArray: Array<Int> = arrayOf(1, 2, 3)

// 等效的 Java 代码
int[] intArray = new int[]{1, 2, 3};
Integer[] boxedArray = new Integer[]{1, 2, 3};

val array = arrayOf(1, 2, 3, 4, 5)// 元素访问
println(array[0]) // 输出: 1
array[0] = 10     // 修改元素
println(array[0]) // 输出: 10// 遍历数组
for (element in array) {println(element)
}// 使用索引遍历
for (i in array.indices) {println("Index $i: ${array[i]}")
}// 使用 withIndex 遍历
for ((index, value) in array.withIndex()) {println("Index $index: $value")
}

// 创建不可变列表
val immutableList: List<Int> = listOf(1, 2, 3)// 创建可变列表
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
mutableList.add(4) // 添加元素
mutableList.removeAt(0) // 删除元素

val list = mutableListOf(1, 2, 3, 4, 5)// 元素访问
println(list[0]) // 输出: 1
println(list.first()) // 输出: 1
println(list.last()) // 输出: 5// 添加元素
list.add(6) // [1, 2, 3, 4, 5, 6]
list.addAll(listOf(7, 8)) // [1, 2, 3, 4, 5, 6, 7, 8]// 删除元素
list.remove(3) // [1, 2, 4, 5, 6, 7, 8]
list.removeAt(0) // [2, 4, 5, 6, 7, 8]// 查找元素
println(list.contains(5)) // 输出: true
println(list.indexOf(6)) // 输出: 3

// 创建不可变集合
val immutableSet: Set<Int> = setOf(1, 2, 3)// 创建可变集合
val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)
mutableSet.add(4) // 添加元素
mutableSet.remove(2) // 删除元素

val set = mutableSetOf(1, 2, 3, 4, 5)// 添加元素
set.add(6) // [1, 2, 3, 4, 5, 6]
set.add(3) // 重复元素，不会添加，仍然是 [1, 2, 3, 4, 5, 6]// 删除元素
set.remove(4) // [1, 2, 3, 5, 6]// 查找元素
println(set.contains(5)) // 输出: true// 集合操作
val anotherSet = setOf(4, 5, 6, 7, 8)
println(set union anotherSet) // 并集: [1, 2, 3, 5, 6, 4, 7, 8]
println(set intersect anotherSet) // 交集: [5, 6]
println(set subtract anotherSet) // 差集: [1, 2, 3]

// 创建不可变映射
val immutableMap: Map<String, Int> = mapOf("one" to 1, "two" to 2, "three" to 3)// 创建可变映射
val mutableMap: MutableMap<String, Int> = mutableMapOf("one" to 1, "two" to 2)
mutableMap["three"] = 3 // 添加键值对
mutableMap.remove("two") // 删除键值对

val map = mutableMapOf("apple" to 1, "banana" to 2, "cherry" to 3)// 添加键值对
map["date"] = 4 // [apple=1, banana=2, cherry=3, date=4]// 获取值
println(map["apple"]) // 输出: 1
println(map.getOrDefault("elderberry", 0)) // 输出: 0// 删除键值对
map.remove("banana") // [apple=1, cherry=3, date=4]// 遍历映射
for ((key, value) in map) {println("$key: $value")
}// 检查键是否存在
println(map.containsKey("apple")) // 输出: true// 检查值是否存在
println(map.containsValue(3)) // 输出: true

val list = listOf(1, 2, 3, 4, 5, 6)// filter：保留满足条件的元素
val evenNumbers = list.filter { it % 2 == 0 } // [2, 4, 6]// filterNot：保留不满足

val list = listOf(1, 2, 3, 4, 5, 6)// filter：保留满足条件的元素
val evenNumbers = list.filter { it % 2 == 0 } // [2, 4, 6]// filterNot：保留不满足条件的元素
val oddNumbers = list.filterNot { it % 2 == 0 } // [1, 3, 5]// filterNotNull：过滤掉 null 元素
val nullableList: List<Int?> = listOf(1, null, 3, null, 5)
val nonNullList = nullableList.filterNotNull() // [1, 3, 5]

val list = listOf(1, 2, 3, 4, 5)// map：对每个元素应用转换函数
val squared = list.map { it * it } // [1, 4, 9, 16, 25]// mapIndexed：对每个元素应用转换函数，同时提供索引
val indexedMap = list.mapIndexed { index, value -> index * value } // [0, 2, 6, 12, 20]// flatMap：先对每个元素应用转换函数，然后将结果展平为一个集合
val nestedList = listOf(listOf(1, 2), listOf(3, 4), listOf(5))
val flattened = nestedList.flatMap { it } // [1, 2, 3, 4, 5]// associate：将集合元素转换为键值对
val map = list.associate { it to it.toString() } // {1=1, 2=2, 3=3, 4=4, 5=5}

val list = listOf("apple", "banana", "cherry", "date", "elderberry")// groupBy：根据指定条件分组
val groupsByLength = list.groupBy { it.length } 
// {5=[apple, cherry, date], 6=[banana], 10=[elderberry]}// partition：将集合分为两个列表，满足条件的和不满足条件的
val (startsWithA, others) = list.partition { it.startsWith("a") } 
// startsWithA: [apple], others: [banana, cherry, date, elderberry]

val list = listOf(5, 2, 4, 1, 3)// sorted：升序排序
val sortedAsc = list.sorted() // [1, 2, 3, 4, 5]// sortedDescending：降序排序
val sortedDesc = list.sortedDescending() // [5, 4, 3, 2, 1]// sortedBy：根据指定属性排序
val words = listOf("banana", "apple", "cherry")
val sortedByLength = words.sortedBy { it.length } // [apple, banana, cherry]// sortedWith：使用自定义比较器排序
val sortedByLastChar = words.sortedWith(compareBy { it.last() }) // [banana, apple, cherry]

val list = listOf(1, 2, 3, 4, 5)// sum：求和
val sum = list.sum() // 15// sumBy：根据指定函数计算总和
val sumOfSquares = list.sumBy { it * it } // 55// reduce：累积计算
val product = list.reduce { acc, element -> acc * element } // 120// fold：带初始值的累积计算
val sumWithInitial = list.fold(10) { acc, element -> acc + element } // 25// count：统计元素数量
val count = list.count() // 5// any：检查是否有元素满足条件
val hasEven = list.any { it % 2 == 0 } // true// all：检查所有元素是否满足条件
val allPositive = list.all { it > 0 } // true// none：检查是否没有元素满足条件
val noneNegative = list.none { it < 0 } // true// find：查找第一个满足条件的元素
val firstEven = list.find { it % 2 == 0 } // 2// max/min：查找最大/最小元素
val max = list.max() // 5
val min = list.min() // 1

/*** 所有非空集合的根接口。*/
public interface Collection<out E> : Iterable<E> {public val size: Intpublic fun isEmpty(): Booleanpublic fun contains(element: @UnsafeVariance E): Booleanpublic operator fun iterator(): Iterator<E>public fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}/*** 有序集合接口。*/
public interface List<out E> : Collection<E> {public operator fun get(index: Int): Epublic fun indexOf(element: @UnsafeVariance E): Intpublic fun lastIndexOf(element: @UnsafeVariance E): Intpublic fun listIterator(): ListIterator<E>public fun listIterator(index: Int): ListIterator<E>public fun subList(fromIndex: Int, toIndex: Int): List<E>
}/*** 可变集合接口。*/
public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {public fun add(element: E): Booleanpublic fun remove(element: E): Booleanpublic fun addAll(elements: Collection<E>): Booleanpublic fun removeAll(elements: Collection<E>): Booleanpublic fun retainAll(elements: Collection<E>): Booleanpublic fun clear(): Unit
}/*** 可变列表接口。*/
public interface MutableList<E> : List<E>, MutableCollection<E>, RandomAccess {public operator fun set(index: Int, element: E): Epublic fun add(index: Int, element: E): Unitpublic fun addAll(index: Int, elements: Collection<E>): Booleanpublic fun removeAt(index: Int): Epublic fun listIterator(): MutableListIterator<E>public fun listIterator(index: Int): MutableListIterator<E>public fun subList(fromIndex: Int, toIndex: Int): MutableList<E>
}

/*** ArrayList 实现*/
@Suppress("NON_PUBLIC_PRIMARY_CONSTRUCTOR_OF_INLINE_CLASS")
@kotlin.internal.InlineOnly
public inline fun <T> ArrayList(capacity: Int): ArrayList<T> = ArrayList(capacity)public actual open class ArrayList<E> : MutableList<E>, RandomAccess {private var array: Array<Any?>private var size: Intpublic actual constructor(initialCapacity: Int) {array = if (initialCapacity == 0) EmptyArray.Any else java.lang.reflect.Array.newInstance(Any::class.java, initialCapacity) as Array<Any?>size = 0}// 实现 MutableList 接口的方法...
}/*** HashSet 实现*/
public actual open class HashSet<E> : MutableSet<E>, Set<E> by set {private val set: LinkedHashMap<E, Any?>public actual constructor() {set = LinkedHashMap()}public actual constructor(initialCapacity: Int) {set = LinkedHashMap(initialCapacity)}// 实现 MutableSet 接口的方法...
}/*** HashMap 实现*/
public actual open class HashMap<K, V> : MutableMap<K, V>, Map<K, V> by map {private val map: LinkedHashMap<K, V>public actual constructor(initialCapacity: Int) {map = LinkedHashMap(initialCapacity)}// 实现 MutableMap 接口的方法...
}

/*** filter 扩展函数*/
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {return filterTo(ArrayList<T>(), predicate)
}public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {for (element in this) if (predicate(element)) destination.add(element)return destination
}/*** map 扩展函数*/
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {for (item in this)destination.add(transform(item))return destination
}/*** reduce 扩展函数*/
public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S {val iterator = this.iterator()if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")var accumulator: S = iterator.next()while (iterator.hasNext()) {accumulator = operation(accumulator, iterator.next())}return accumulator
}

// 泛型类示例
class Box<T>(private val value: T) {fun getValue(): T = value
}// 使用泛型类
val intBox = Box(10) // 类型参数自动推断为 Int
val stringBox = Box("Hello") // 类型参数自动推断为 String// 泛型函数示例
fun <T> listOf(vararg elements: T): List<T> {// 实现细节
}// 使用泛型函数
val numbers = listOf(1, 2, 3) // 类型参数自动推断为 Int
val strings = listOf("a", "b", "c") // 类型参数自动推断为 String

// 上界约束示例
fun <T : Number> sum(list: List<T>): Double {var sum = 0.0for (element in list) {sum += element.toDouble()}return sum
}// 多个约束示例
class Processor<T> where T : Comparable<T>, T : Serializable {// 类的实现
}// 泛型函数的多个约束
fun <T> process(value: T) where T : CharSequence, T : Appendable {// 函数的实现
}

// 协变示例（out）
interface Producer<out T> {fun produce(): T
}// 逆变示例（in）
interface Consumer<in T> {fun consume(item: T)
}// 不变示例（默认）
class MutableBox<T>(var value: T) {// 可变的属性，不能使用型变
}

// 实化类型参数示例
inline fun <reified T> isA(value: Any): Boolean = value is T// 使用实化类型参数
println(isA<String>("Hello")) // 输出: true
println(isA<Int>("Hello"))    // 输出: false// 实化类型参数在集合过滤中的应用
inline fun <reified T> List<*>.filterIsInstance(): List<T> {val destination = mutableListOf<T>()for (element in this) {if (element is T) {destination.add(element)}}return destination
}

// 协变投影示例
fun copy(from: Array<out Any>, to: Array<Any>) {assert(from.size == to.size)for (i in from.indices) {to[i] = from[i]}
}// 使用协变投影
val ints: Array<Int> = arrayOf(1, 2, 3)
val anyArray: Array<Any> = arrayOf(1, "a", true)
copy(ints, anyArray) // 合法，因为 Array<Int> 是 Array<out Any> 的子类型// 逆变投影示例
fun fill(dest: Array<in String>, value: String) {for (i in dest.indices) {dest[i] = value}
}// 使用逆变投影
val objects: Array<Any> = arrayOf(1, "a", true)
fill(objects, "test") // 合法，因为 Array<Any> 是 Array<in String> 的子类型

// 星投影示例
val list: List<*> = listOf(1, "a", true) // 等价于 List<out Any?>// 星投影在函数中的应用
fun printList(list: List<*>) {for (item in list) {println(item)}
}// 使用星投影
printList(listOf(1, 2, 3))
printList(listOf("a", "b", "c"))

// 密封类示例
sealed class Result<out T> {data class Success<out T>(val data: T) : Result<T>()data class Error(val message: String) : Result<Nothing>()object Loading : Result<Nothing>()
}// 使用密封类的 when 表达式
fun handleResult(result: Result<Int>) {when (result) {is Result.Success -> println("Success: ${result.data}")is Result.Error -> println("Error: ${result.message}")is Result.Loading -> println("Loading...")}
}

// 枚举类示例
enum class Color {RED, GREEN, BLUE
}// 带属性的枚举类
enum class Color(val rgb: Int) {RED(0xFF0000),GREEN(0x00FF00),BLUE(0x0000FF)
}// 枚举类中的方法
enum class DayOfWeek {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;fun isWeekend(): Boolean = this in setOf(SATURDAY, SUNDAY)
}

// 简单类型别名
typealias Name = String
typealias Age = Int// 使用类型别名
fun greet(name: Name, age: Age) {println("Hello, $name! You are $age years old.")
}// 集合类型别名
typealias UserList = List<User>
typealias UserMap = Map<Int, User>// 函数类型别名
typealias ClickListener = (View) -> Unit
typealias TransformFunction = (Int) -> String// 泛型类型别名
typealias Result<T> = Either<String, T>// 使用函数类型别名
class Button {private var listener: ClickListener? = nullfun setOnClickListener(listener: ClickListener) {this.listener = listener}fun performClick() {listener?.invoke(this)}
}

// 非可空类型
var name: String = "John"
// name = null // 编译错误：Null can not be a value of a non-null type String// 可空类型
var nullableName: String? = "John"
nullableName = null // 合法// 可空类型的属性访问
val length: Int? = nullableName?.length // 安全调用操作符
val safeLength: Int = nullableName?.length ?: 0 // Elvis 操作符
val nonNullLength: Int = nullableName!!.length // 非空断言，可能抛出 NPE

// 安全调用操作符（?.）
val nullableName: String? = null
val length: Int? = nullableName?.length // 如果 nullableName 为 null，返回 null，否则返回 length// Elvis 操作符（?:）
val safeLength: Int = nullableName?.length ?: 0 // 如果 nullableName 为 null，返回 0，否则返回 length// 非空断言（!!）
val nonNullLength: Int = nullableName!!.length // 如果 nullableName 为 null，抛出 NullPointerException// 安全转换（as?）
val obj: Any = "Hello"
val str: String? = obj as? String // 如果 obj 不是 String 类型，返回 null

val list: List<String?> = listOf("a", null, "c")// filterNotNull：过滤掉 null 元素
val nonNullList: List<String> = list.filterNotNull() // ["a", "c"]// mapNotNull：映射并过滤掉 null 结果
val lengths: List<Int> = list.mapNotNull { it?.length } // [1, 1]

// Java 代码
public class JavaClass {public String getNullableString() {return Math.random() > 0.5 ? "value" : null;}
}// Kotlin 代码
val javaObject = JavaClass()
val nullableString: String? = javaObject.nullableString // 平台类型，需要手动处理 null
val length = nullableString?.length ?: 0 // 安全处理 null

// Java 代码
public class JavaUtils {public static String formatName(String name) {if (name == null || name.isEmpty()) {return null;}return name.toUpperCase();}
}// Kotlin 代码
val name: String? = JavaUtils.formatName("John")
val displayName: String = name ?: "Unknown" // 安全处理 null

// Java 代码
public class JavaArrayUtils {public static int sum(int[] array) {int sum = 0;for (int value : array) {sum += value;}return sum;}
}// Kotlin 代码
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)
val result = JavaArrayUtils.sum(intArray) // 直接传递 IntArray 给 int[] 参数

// Java 代码
public class JavaListUtils {public static <T> void copy(List<? extends T> source, List<? super T> destination) {for (T item : source) {destination.add(item);}}
}// Kotlin 代码
val source: List<Int> = listOf(1, 2, 3)
val destination: MutableList<Any> = mutableListOf()
JavaListUtils.copy(source, destination) // 等价于 Java 的 <? extends T> 和 <? super T>

// Kotlin 代码
class KotlinClass {var nonNullProperty: String = "value" // 非可空属性var nullableProperty: String? = null  // 可空属性fun nonNullMethod(): String {return "result"}fun nullableMethod(): String? {return null}
}

// Java 代码
KotlinClass kotlinObject = new KotlinClass();
String nonNullValue = kotlinObject.getNonNullProperty(); // 非空引用
String nullableValue = kotlinObject.getNullableProperty(); // 可能为 null 的引用
String result1 = kotlinObject.nonNullMethod(); // 非空引用
String result2 = kotlinObject.nullableMethod(); // 可能为 null 的引用

// Kotlin 代码
class KotlinCollectionExample {val immutableList: List<String> = listOf("a", "b", "c")val mutableList: MutableList<String> = mutableListOf("x", "y", "z")
}

// Java 代码
KotlinCollectionExample example = new KotlinCollectionExample();
java.util.List<String> immutable = example.getImmutableList(); // 只读集合
java.util.List<String> mutable = example.getMutableList(); // 可变集合
mutable.add("w"); // 合法
// immutable.add("d"); // 编译错误，Java 不知道这是只读集合，但调用会在运行时抛出 UnsupportedOperationException

// Kotlin 代码
class KotlinFunctionExample {fun process(input: Int, transformer: (Int) -> String): String {return transformer(input)}
}

// Java 代码
KotlinFunctionExample example = new KotlinFunctionExample();
String result = example.process(42, i -> "Result: " + i); // 使用 lambda 表达式

// Java 代码
public class JavaService {public String getValue() {return Math.random() > 0.5 ? "value" : null;}
}// Kotlin 代码
val service = JavaService()
val value: String? = service.value // 明确转换为可空类型
val length = value?.length ?: 0 // 安全处理 null// 或者使用非空断言
val nonNullValue: String = service.value!! // 明确转换为非可空类型，可能抛出 NPE
val length2 = nonNullValue.length // 无需空检查

// 安全处理平台类型的示例
fun safeProcess(input: String?) {val length = input?.length ?: 0println("Length: $length")
}// 不安全的处理方式（可能导致 NPE）
fun unsafeProcess(input: String) {println("Length: ${input.length}") // 如果 input 为 null，会抛出 NPE
}

// 数据类示例
data class User(val id: Int,val name: String,val age: Int,val email: String
)// 使用数据类
val user = User(1, "John Doe", 30, "john@example.com")
println(user) // 自动生成的 toString() 方法
val copy = user.copy(age = 31) // 自动生成的 copy() 方法

// 密封类示例
sealed class Result<out T> {data class Success<out T>(val data: T) : Result<T>()data class Error(val message: String) : Result<Nothing>()object Loading : Result<Nothing>()
}// 使用密封类的 when 表达式（无需 else 分支）
fun handleResult(result: Result<Int>) {when (result) {is Result.Success -> println("Success: ${result.data}")is Result.Error -> println("Error: ${result.message}")is Result.Loading -> println("Loading...")}
}

// 函数类型别名示例
typealias ClickListener = (View) -> Unit
typealias UserMap = Map<Int, User>// 使用类型别名
class Button {var onClick: ClickListener? = nullfun performClick() {onClick?.invoke(this)}
}

// 非可空属性
var name: String = "John" // 非可空，必须初始化// 可空属性
var email: String? = null // 可空，允许 null 值

val nullableName: String? = null
val length: Int? = nullableName?.length // 如果 nullableName 为 null，返回 null，否则返回 length

val nullableName: String? = null
val displayName: String = nullableName ?: "Unknown" // 如果 nullableName 为 null，使用 "Unknown"

val nullableName: String? = "John"
val nonNullName: String = nullableName!! // 确定 nullableName 不为 null 时使用

// 泛型函数示例
fun <T> findMax(list: List<T>): T? where T : Comparable<T> {if (list.isEmpty()) return nullvar