第 27 章 从 Java 到 Kotlin

				
"1".toInt()			
				
				

				
fun main() {
    val builder = StringBuilder()
    builder.append("你好")
           .append("，")
           .append("世界")
           .append("！")
    
    val message = builder.toString()
    println(message) // 输出：你好，世界！
}				
				
				

				
// 语法：字符串.split(Regex)
val str = "a,b;c d"
val parts = str.split(Regex("[,;\\s]")) // 用逗号、分号或空格拆分
println(parts) // 输出：[a, b, c, d]

// 按多个字符拆分（如逗号、分号、空格）
val text = "apple,banana;orange grape"
// 正则含义：匹配逗号、分号或空格
val regex = Regex("[,;\\s]") 
val fruits = text.split(regex)
// 结果：[apple, banana, orange, grape]	

// 按数字拆分
val str = "abc123def456ghi"
// 正则含义：匹配一个或多个数字
val parts = str.split(Regex("\\d+")) 
// 结果：[abc, def, ghi]			

// 按单词边界拆分
val sentence = "Hello!World?Kotlin"
// 正则含义：匹配非字母字符（作为分隔符）
val words = sentence.split(Regex("[^a-zA-Z]")) 
// 结果：[Hello, World, Kotlin]

// 限制拆分次数
val str = "a,b,c,d"
// 最多拆分成2部分（第二个参数为 limit）
val parts = str.split(Regex(","), 2) 
// 结果：[a, b,c,d]


// 保留空字符串（默认会过滤）
val str = "a,,b,,c"
// 加上 -1 表示不限制拆分次数，且保留空字符串
val parts = str.split(Regex(","), -1) 
// 结果：[a, , b, , c]
				
				

				
        val PATTERN: MutableList<String> = object : ArrayList<String>() {
            init {
                add(".*(?:发言|说话)人(\\d+).*")
                add(".*(?:发言|说话)人(一|二|三|四|五|六|七|八|九|十).*")
                add(".*(?:发言|说话)人(一|二|三|四|五|六|七|八|九|十).*")
                //            add("(.*)的观点.*");
            }
        }
				
				

				
val arrayList = ArrayList<String>()
arrayList.add("Java")
arrayList.add("Kotlin")
arrayList.add("Python")
println("ArrayList: $arrayList")				
				
				

				
listOf("debug", "dev").contains(BuildConfig.BUILD_TYPE)			
				
				

				
val contact =
            mapOf(
                "BG7NYT" to "177",
                "BG7NEG" to "172",
                "BG7JWV" to "179",
                "BI7XYS" to "190",
                "BD7KBF" to "4612194"
            )

contact.values.toTypedArray()
				
				

				
   // 创建可变列表集合
    var mutableList = mutableListOf("Tom", "Jerry")
    // 添加元素
    mutableList.add("Jack")
    // 删除元素
    mutableList.remove("Tom")
    println(mutableList)

    // 将 可变列表集合 转为 只读列表集合
    val list: List<String> = mutableList.toList()
    // 将 只读列表集合 转为 可变列表集合
    val mutable: MutableList<String> = list.toMutableList()				
				
				

筛选并删除元素

				
fun main() {
    // 创建可变列表集合
    val mutableList = mutableListOf("Tom", "Jerry")
    // 通过 Lambda 表达式筛选要操作的元素
    // 删除包含 字母 T 的元素
    mutableList.removeIf {
        it.contains("T")
    }
    println(mutableList)
}

				
				

				
var content = meetingDao.findByTaskId(meetingData.taskId).forEach { (id, taskId, time, speaker, sentence) ->
                Log.d(TAG, sentence)
            }				
				
				

				
var content = meetingDao.findByTaskId("5b4a5bd92da847d292ed74ae696a7ca1").map({ "${it.time} 发言人${it.speaker} ${it.sentence}" }).joinToString(separator = "\n")
Log.d(TAG, content)				
				
				

				
        val digit: MutableMap<String?, String?> = object : HashMap<String?, String?>() {
            init {
                put("一", "1")
                put("二", "2")
                put("三", "3")
                put("四", "4")
                put("五", "5")
                put("六", "6")
                put("七", "7")
                put("八", "8")
                put("九", "9")
                put("十", "10")
                put("零", "0")
            }
        }				
				
				

				
// 方式1：显式指定泛型类型
val emptyMutableMap: MutableMap<String, Int> = mutableMapOf()

// 方式2：使用 HashMap 构造函数（Java 兼容方式）
val emptyHashMap = HashMap<String, Int>()

// 可变空 Map 的使用示例
fun main() {
    // 向可变空 Map 中添加元素
    emptyMutableMap["one"] = 1
    emptyMutableMap["two"] = 2
    
    emptyHashMap["three"] = 3
    
    println(emptyMutableMap) // 输出：{one=1, two=2}
    println(emptyHashMap)    // 输出：{three=3}
}
				
				
				

				
 mapOf("content" to "hello world")
				
				

				
fun main() {
    // 创建并初始化可变 Map
    val mutableMap = mutableMapOf(
        "name" to "Alice",
        "age" to 25,
        "city" to "Beijing"
    )

    // 1. 添加键值对（若键已存在则覆盖）
    mutableMap["gender"] = "Female" // 用 [] 运算符
    mutableMap.put("job", "Engineer") // 用 put() 方法
    println("添加后: $mutableMap")

    // 2. 修改值
    mutableMap["age"] = 26 // 直接赋值覆盖
    mutableMap.replace("city", "Shanghai") // 用 replace() 方法
    println("修改后: $mutableMap")

    // 3. 删除键值对
    mutableMap.remove("job") // 按键删除
    println("删除后: $mutableMap")

    // 4. 清空 Map
    // mutableMap.clear()

    // 5. 检查是否包含键/值
    val hasName = mutableMap.containsKey("name")
    val hasAge30 = mutableMap.containsValue(30)
    println("包含 name 键: $hasName，包含 30 值: $hasAge30")

    // 6. 遍历 Map
    println("\n遍历键值对：")
    for ((key, value) in mutableMap) {
        println("$key: $value")
    }

    // 7. 转换为不可变 Map
    val immutableMap: Map<String, Any> = mutableMap.toMap()
}
				
				
				

				
 val originalMap = mapOf("a" to 1, "b" to 2, "c" to 2)

// 反转键值对（注意：如果值有重复，会导致键冲突，后面的键会覆盖前面的）
val reversedMap = originalMap.associateBy({ it.value }, { it.key })

println(reversedMap) // 输出: {1=a, 2=c}（值2对应的原键"b"被覆盖）
				
				

				
ConcurrentHashMap<String, String> speakers = new ConcurrentHashMap<>();
        speakers.put("1", "发言人一");
        speakers.put("2", "市场部小周");
        speakers.put("4", "陈先生");
        speakers.put("5", "齐天大圣");
        speakers.put("6", "一品轩小飞");
        speakers.put("7", "年年富");
        speakers.put("8", "李总");		
val invertedMap: Map<String, String> = speakers.entries.associateBy({ it.value as String }, { it.key as String })				
				
				

				
val isSuccess = true

// 对布尔值使用 let
val result = isSuccess.let { success ->
    // success 等价于 isSuccess（it 也可以）
    if (success) {
        "操作成功"
    } else {
        "操作失败"
    }
}

println(result)  // 输出：操作成功				
				
				

处理 null

				
val flag: Boolean? = null
flag?.let {  // 安全调用，flag 为 null 时不执行
    println("flag is $it")
}