文件与IO

// 导入 Kotlin 对 Path 的扩展支持（必须导入，否则很多扩展函数不可用）
import kotlin.io.path.*
import java.nio.file.Path
 
fun main() {
    // 方式一：使用 Kotlin 提供的顶层函数 Path()，最简洁
    val p1: Path = Path("src/main/kotlin/App.kt")
 
    // 方式二：使用 Java 原生的 Paths.get()，效果完全一致
    val p2: Path = java.nio.file.Paths.get("src/main/kotlin/App.kt")
 
    // 两者指向同一个逻辑路径
    println(p1 == p2) // true
}

import kotlin.io.path.*
 
fun main() {
    val path = Path("/home/user/projects/demo/Main.kt")
 
    // fileName：路径的最后一个组成部分（文件名或目录名）
    println(path.fileName)       // Main.kt
 
    // parent：父路径，即去掉最后一个组成部分后的路径
    println(path.parent)         // /home/user/projects/demo
 
    // root：路径的根元素，Unix 下是 "/"，Windows 下可能是 "C:\"
    println(path.root)           // /
 
    // nameCount：路径中名称元素的数量（不含根）
    println(path.nameCount)      // 4  (home, user/projects/demo, Main.kt 拆开共4段)
 
    // 通过索引获取路径中的某一段
    println(path.getName(0))     // home
    println(path.getName(3))     // Main.kt
 
    // extension 是 Kotlin 扩展属性，获取文件扩展名
    println(path.extension)      // kt
 
    // nameWithoutExtension 也是 Kotlin 扩展属性
    println(path.nameWithoutExtension) // Main
}

import kotlin.io.path.*
 
fun main() {
    val absolute = Path("/home/user/projects/Main.kt")
    val relative = Path("src/Main.kt")
 
    // isAbsolute：判断路径是否为绝对路径
    println(absolute.isAbsolute)  // true
    println(relative.isAbsolute)  // false
 
    // toAbsolutePath()：将相对路径转换为绝对路径（基于当前工作目录）
    // 假设 CWD 是 /home/user/projects
    println(relative.toAbsolutePath())
    // 输出: /home/user/projects/src/Main.kt
 
    // 绝对路径调用 toAbsolutePath() 返回自身
    println(absolute.toAbsolutePath())
    // 输出: /home/user/projects/Main.kt
}

import kotlin.io.path.*
 
fun main() {
    val messy = Path("/home/user/./projects/../projects/demo/Main.kt")
 
    // normalize()：消除 "." 和 ".." 等冗余部分，纯字符串操作
    println(messy.normalize())
    // 输出: /home/user/projects/demo/Main.kt
 
    // toRealPath()：解析为真实的绝对路径（会访问文件系统，文件必须存在）
    // 如果文件不存在会抛出 NoSuchFileException
    // println(messy.toRealPath())
}

import kotlin.io.path.*
 
fun main() {
    val base = Path("/home/user/projects")
 
    // resolve()：将子路径附加到当前路径之后
    val full1 = base.resolve("demo/Main.kt")
    println(full1) // /home/user/projects/demo/Main.kt
 
    // Kotlin 重载的 / 操作符，效果与 resolve() 完全一致，但更直观
    val full2 = base / "demo" / "Main.kt"
    println(full2) // /home/user/projects/demo/Main.kt
 
    // 注意：如果传入的是绝对路径，resolve 会直接返回那个绝对路径（忽略 base）
    val abs = base.resolve("/etc/config.txt")
    println(abs) // /etc/config.txt  ← base 被忽略了！
}

import kotlin.io.path.*
 
fun main() {
    val file = Path("/home/user/projects/Main.kt")
 
    // resolveSibling()：在同级目录下定位另一个文件
    val sibling = file.resolveSibling("Test.kt")
    println(sibling) // /home/user/projects/Test.kt
 
    // 典型用途：给文件换个名字或换个扩展名
    val backup = file.resolveSibling("Main.kt.bak")
    println(backup) // /home/user/projects/Main.kt.bak
}

import kotlin.io.path.*
 
fun main() {
    val base = Path("/home/user/projects")
    val target = Path("/home/user/projects/demo/src/Main.kt")
 
    // relativize()：计算从 base 到 target 需要走的相对路径
    val rel = base.relativize(target)
    println(rel) // demo/src/Main.kt
 
    // 反过来也可以
    val back = target.relativize(base)
    println(back) // ../../..  （往上走三级）
 
    // 验证：base.resolve(rel) 应该等于 target
    println(base.resolve(rel).normalize() == target.normalize()) // true
}

import kotlin.io.path.*
import java.io.File
 
fun main() {
    val path = Path("/home/user/data.txt")
    val file = File("/home/user/data.txt")
 
    // Path → File
    val fileFromPath: File = path.toFile()
 
    // File → Path
    val pathFromFile: java.nio.file.Path = file.toPath()
 
    // 两者指向同一个位置
    println(pathFromFile == path) // true
}

import kotlin.io.path.*
 
fun main() {
    val path = Path("config.json")
 
    // readText() 将文件全部内容读入一个 String
    // 默认使用 UTF-8 编码，也可以显式指定
    val content: String = path.readText()
    println(content)
 
    // 指定编码（处理非 UTF-8 文件时需要）
    val gbkContent = path.readText(Charsets.ISO_8859_1)
}

// 伪代码，展示 readText 的内部逻辑
fun Path.readText(charset: Charset = Charsets.UTF_8): String {
    // reader() 也是 Kotlin 扩展函数，返回 BufferedReader
    return reader(charset).use { it.readText() }
    // use {} 确保读取完毕后自动关闭流（即使发生异常）
}

import kotlin.io.path.*
 
fun main() {
    val path = Path("users.csv")
 
    // readLines() 返回 List<String>，每个元素是一行
    val lines: List<String> = path.readLines()
 
    // 跳过表头，处理数据行
    lines.drop(1).forEach { line ->
        // 按逗号分割每一行
        val fields = line.split(",")
        println("Name: ${fields[0]}, Age: ${fields[1]}")
    }
 
    // 也可以直接获取行数
    println("Total lines: ${lines.size}")
}

// 这两种写法效果相似，但 readLines() 更高效
val way1 = path.readText().split("\n")    // 先读全部文本，再手动分割（多一次拷贝）
val way2 = path.readLines()               // 直接按行读取，内部用 BufferedReader

import kotlin.io.path.*
 
fun main() {
    val imagePath = Path("logo.png")
 
    // readBytes() 返回 ByteArray，即原始字节数组
    val bytes: ByteArray = imagePath.readBytes()
 
    // 查看文件大小（字节数）
    println("File size: ${bytes.size} bytes")
 
    // 检查 PNG 文件头魔数（PNG 文件以 0x89504E47 开头）
    if (bytes.size >= 4 &&
        bytes[0] == 0x89.toByte() &&
        bytes[1] == 0x50.toByte() && // 'P'
        bytes[2] == 0x4E.toByte() && // 'N'
        bytes[3] == 0x47.toByte()    // 'G'
    ) {
        println("Valid PNG file!")
    }
 
    // 也可以用于文件复制的底层实现
    val copyPath = Path("logo_copy.png")
    copyPath.writeBytes(bytes) // writeBytes 是对应的写入函数
}

import kotlin.io.path.*
 
fun main() {
    val logPath = Path("server.log")
 
    // forEachLine 逐行读取，每读一行就执行 lambda
    // 读完后自动关闭文件流
    logPath.forEachLine { line ->
        // 只打印包含 ERROR 的行
        if ("ERROR" in line) {
            println(line)
        }
    }
 
    // 指定编码
    logPath.forEachLine(Charsets.UTF_8) { line ->
        println(line)
    }
}

import kotlin.io.path.*
 
// 假设 app.properties 内容如下：
// # Database Config
// db.host=localhost
// db.port=5432
// db.name=myapp
 
fun loadConfig(configPath: String): Map<String, String> {
    // 使用 readLines 读取所有行
    return Path(configPath)
        .readLines()
        // 过滤掉空行和注释行（以 # 开头）
        .filter { it.isNotBlank() && !it.trimStart().startsWith("#") }
        // 按第一个 "=" 分割为 key-value 对
        .associate { line ->
            val (key, value) = line.split("=", limit = 2) // limit=2 防止 value 中含有 "="
            key.trim() to value.trim()
        }
}
 
fun main() {
    val config = loadConfig("app.properties")
    // 类型安全地访问配置
    val host = config["db.host"] ?: "localhost"
    val port = config["db.port"]?.toIntOrNull() ?: 5432
    println("Connecting to $host:$port")
}

import kotlin.io.path.*
import java.nio.file.NoSuchFileException
import java.nio.file.AccessDeniedException
import java.io.IOException
 
fun safeRead(filePath: String): String? {
    return try {
        Path(filePath).readText()
    } catch (e: NoSuchFileException) {
        // 文件不存在
        println("File not found: ${e.file}")
        null
    } catch (e: AccessDeniedException) {
        // 没有读取权限
        println("Permission denied: ${e.file}")
        null
    } catch (e: IOException) {
        // 其他 IO 错误（磁盘故障、编码错误等）
        println("IO error: ${e.message}")
        null
    }
}

import kotlin.io.path.*
 
fun main() {
    val path = Path("data.txt")
 
    // 前置检查（不能替代异常处理，但能提供更好的错误信息）
    if (!path.exists()) {
        println("Error: File does not exist at ${path.toAbsolutePath()}")
        return
    }
    if (!path.isReadable()) {
        println("Error: No read permission for $path")
        return
    }
 
    // 正式读取
    val content = path.readText()
    println("Read ${content.length} characters")
}

import kotlin.io.path.*
 
fun main() {
    val base = Path("/data/projects")
    val sub = Path("src/main")
    val full = base / sub.toString() / "App.kt"
    val rel = base.relativize(full)
    println(rel)
}

import java.io.File
 
fun main() {
    // 创建一个 File 对象，指向当前目录下的 output.txt
    val file = File("output.txt")
 
    // writeText 会：
    // 1. 如果文件不存在 → 自动创建
    // 2. 如果文件已存在 → 清空原有内容
    // 3. 将字符串以指定编码（默认 UTF-8）写入
    file.writeText("Hello, Kotlin IO!")
 
    // 验证写入结果
    println(file.readText()) // 输出: Hello, Kotlin IO!
}

// stdlib 源码简化版
public fun File.writeText(
    text: String,            // 要写入的完整文本
    charset: Charset = Charsets.UTF_8  // 字符编码，默认 UTF-8
): Unit {
    // 内部实际调用的是 writeBytes
    writeBytes(text.toByteArray(charset))
}

import java.io.File
 
fun main() {
    val file = File("gbk_output.txt")
 
    // 某些遗留系统要求 GBK 编码
    file.writeText("你好，Kotlin！", charset = Charsets.ISO_8859_1)
 
    // 读取时也必须用相同编码，否则乱码
    val content = file.readText(charset = Charsets.ISO_8859_1)
    println(content)
}

import java.io.File
 
fun main() {
    val file = File("binary.dat")
 
    // 构造一段字节数据
    val data: ByteArray = byteArrayOf(
        0x48, 0x65, 0x6C, 0x6C, 0x6F  // 对应 ASCII "Hello"
    )
 
    // 直接写入原始字节，不涉及任何编码转换
    file.writeBytes(data)
 
    // 读回验证
    val readBack = file.readBytes()
    println(readBack.contentEquals(data)) // 输出: true
    println(String(readBack))            // 输出: Hello
}

// stdlib 源码简化版
public fun File.writeBytes(array: ByteArray): Unit {
    // 打开一个 FileOutputStream（覆盖模式）
    // 写入全部字节
    // 关闭流
    FileOutputStream(this).use { it.write(array) }
}

import java.io.File
 
fun main() {
    val source = File("photo.jpg")
    val dest = File("photo_backup.jpg")
 
    // 读取全部字节 → 写入新文件，两行完成复制
    // 注意：仅适合小文件，大文件应使用流式复制
    dest.writeBytes(source.readBytes())
}

import java.io.File
import java.time.LocalDateTime
 
fun main() {
    val logFile = File("app.log")
 
    // 模拟多次日志写入
    repeat(3) { index ->
        // appendText 每次调用都在文件末尾追加
        // 不会清除已有内容
        logFile.appendText(
            "[${LocalDateTime.now()}] Event #$index occurred\n"
        )
    }
 
    // 读取完整日志
    println(logFile.readText())
    // 输出类似：
    // [2025-01-15T10:30:01] Event #0 occurred
    // [2025-01-15T10:30:01] Event #1 occurred
    // [2025-01-15T10:30:01] Event #2 occurred
}

// writeText 内部 → FileOutputStream(file)          → 覆盖模式
// appendText 内部 → FileOutputStream(file, true)    → 追加模式（append = true）
 
// appendText 源码简化
public fun File.appendText(
    text: String,
    charset: Charset = Charsets.UTF_8
): Unit {
    // 第二个参数 true 表示 append 模式
    appendBytes(text.toByteArray(charset))
}
 
public fun File.appendBytes(array: ByteArray): Unit {
    FileOutputStream(this, true).use { it.write(array) }
    //                    ^^^^ 关键：追加模式
}

import java.io.File
 
fun main() {
    val file = File("buffered_output.txt")
 
    // bufferedWriter() 返回 BufferedWriter
    // use {} 确保写入完成后自动 flush + close
    file.bufferedWriter().use { writer ->
        // 写入第一行
        writer.write("第一行内容")
        // newLine() 写入平台相关的换行符
        // Windows: \r\n, Unix/Mac: \n
        writer.newLine()
 
        // 写入第二行
        writer.write("第二行内容")
        writer.newLine()
 
        // 也可以用 appendLine 风格（BufferedWriter 实现了 Appendable）
        writer.append("第三行内容")
        writer.newLine()
    }
    // use 块结束时自动调用 close()，close() 内部会先 flush()
 
    println(file.readText())
}

import java.io.File
 
fun main() {
    val file = File("large_output.txt")
 
    // 指定 32KB 缓冲区，适合大量写入场景
    file.bufferedWriter(bufferSize = 32 * 1024).use { writer ->
        // 模拟写入 10 万行数据
        repeat(100_000) { i ->
            writer.write("Line $i: This is some generated content")
            writer.newLine()
        }
    }
 
    println("写入完成，文件大小: ${file.length()} bytes")
}

import java.io.File
import kotlin.system.measureTimeMillis
 
fun main() {
    val lines = 10_000
 
    // 方式一：循环调用 appendText（每次都开关文件）
    val file1 = File("slow.txt")
    val time1 = measureTimeMillis {
        repeat(lines) { i ->
            file1.appendText("Line $i\n") // 每次: open → write → close
        }
    }
 
    // 方式二：bufferedWriter 一次性写入
    val file2 = File("fast.txt")
    val time2 = measureTimeMillis {
        file2.bufferedWriter().use { writer ->
            repeat(lines) { i ->
                writer.write("Line $i")   // 写入缓冲区
                writer.newLine()
            }
        } // 一次: open → 多次缓冲写入 → flush → close
    }
 
    println("appendText 循环: ${time1}ms")  // 通常数百到数千毫秒
    println("bufferedWriter:  ${time2}ms")  // 通常几十毫秒
    // 性能差距可达 10~100 倍
 
    // 清理
    file1.delete()
    file2.delete()
}

import java.io.File
 
fun main() {
    val file = File("report.txt")
 
    file.printWriter().use { out ->
        // println 自动追加换行
        out.println("=== 销售报告 ===")
        out.println()
 
        // printf 支持格式化字符串（与 Java 的 String.format 一致）
        val items = listOf(
            Triple("Widget A", 150, 29.99),
            Triple("Widget B", 89, 49.50),
            Triple("Widget C", 312, 12.75)
        )
 
        // 表头：左对齐 -12 字符，右对齐 8 字符，右对齐 10.2 浮点
        out.printf("%-12s %8s %10s%n", "Product", "Qty", "Price")
        out.println("-".repeat(32))
 
        items.forEach { (name, qty, price) ->
            out.printf("%-12s %8d %10.2f%n", name, qty, price)
        }
 
        out.println("-".repeat(32))
        val total = items.sumOf { it.second * it.third }
        out.printf("%-12s %19.2f%n", "Total", total)
    }
 
    // 打印文件内容验证
    println(file.readText())
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.StandardOpenOption
 
fun main() {
    val path = Path("nio_output.txt")
 
    // writeText — 与 File.writeText 语义相同
    path.writeText("NIO2 写入测试\n")
 
    // appendText — 追加
    path.appendText("追加的第二行\n")
 
    // writeLines — 直接写入字符串列表，每个元素自动换行
    val lines = listOf("Line A", "Line B", "Line C")
    Path("lines_output.txt").writeLines(lines)
 
    // 使用 OpenOption 精细控制写入行为
    path.writeText(
        "带选项的写入",
        // CREATE: 不存在则创建
        // TRUNCATE_EXISTING: 存在则清空
        // WRITE: 写入模式
        StandardOpenOption.CREATE,
        StandardOpenOption.TRUNCATE_EXISTING,
        StandardOpenOption.WRITE
    )
 
    println(path.readText())
}

import java.io.File
 
fun main() {
    val file = File("config.yaml")
 
    // exists() 检查文件系统中是否存在该路径对应的文件或目录
    if (file.exists()) {
        println("配置文件已存在，大小: ${file.length()} bytes")
    } else {
        println("配置文件不存在，将创建默认配置")
        file.writeText("app:\n  name: MyApp\n  version: 1.0")
    }
 
    // 还有一些相关的判断方法
    println("是文件: ${file.isFile}")           // true（不是目录）
    println("是目录: ${file.isDirectory}")       // false
    println("可读: ${file.canRead()}")           // true（通常）
    println("可写: ${file.canWrite()}")          // true（通常）
    println("是隐藏文件: ${file.isHidden}")      // false（Unix 下以 . 开头才是）
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.LinkOption
 
fun main() {
    val path = Path("config.yaml")
 
    // 基本存在性检查
    println("存在: ${path.exists()}")
    println("不存在: ${path.notExists()}")
 
    // 注意：exists() 返回 false 不等于 notExists() 返回 true
    // 当权限不足无法确定时，两者可能都返回 false
 
    // 不跟随符号链接的检查
    println("存在(不跟随链接): ${path.exists(LinkOption.NOFOLLOW_LINKS)}")
 
    // Path 的类型判断
    println("是常规文件: ${path.isRegularFile()}")
    println("是目录: ${path.isDirectory()}")
    println("是符号链接: ${path.isSymbolicLink()}")
}

import java.io.File
import java.io.FileNotFoundException
 
fun main() {
    val file = File("data.txt")
 
    // 不推荐：先检查再操作（存在竞态）
    // if (file.exists()) { file.readText() }
 
    // 推荐：直接操作，捕获异常
    try {
        val content = file.readText()
        println(content)
    } catch (e: FileNotFoundException) {
        println("文件不存在: ${e.message}")
    }
}

import java.io.File
 
fun main() {
    val file = File("new_file.txt")
 
    // createNewFile() 返回 Boolean
    // true  → 文件不存在，成功创建了空文件
    // false → 文件已存在，什么都没做
    val created = file.createNewFile()
    println("文件创建成功: $created") // 第一次: true
 
    // 再次调用
    val createdAgain = file.createNewFile()
    println("再次创建: $createdAgain") // false，文件已存在
 
    // 清理
    file.delete()
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.FileAlreadyExistsException
import java.nio.file.attribute.PosixFilePermissions
 
fun main() {
    val path = Path("new_file_nio.txt")
 
    // Path.createFile() 在文件已存在时抛出异常（而非返回 false）
    try {
        path.createFile()
        println("文件创建成功")
    } catch (e: FileAlreadyExistsException) {
        println("文件已存在: ${e.message}")
    }
 
    // 在 Unix/Linux/macOS 上可以指定权限
    // val pathWithPerms = Path("secure.txt").createFile(
    //     PosixFilePermissions.asFileAttribute(
    //         PosixFilePermissions.fromString("rw-------")
    //     )
    // )
 
    // 清理
    path.deleteIfExists()
}

import java.io.File
 
fun main() {
    // === File.delete() ===
    val file = File("temp.txt")
    file.writeText("临时数据")
 
    // delete() 返回 Boolean
    // true  → 删除成功
    // false → 删除失败（文件不存在、权限不足、目录非空等）
    // 注意：不会抛异常，失败原因不明确
    val deleted = file.delete()
    println("删除成功: $deleted") // true
 
    // 删除不存在的文件
    val deletedAgain = file.delete()
    println("再次删除: $deletedAgain") // false，但不知道为什么失败
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.DirectoryNotEmptyException
 
fun main() {
    val path = Path("temp_nio.txt")
    path.writeText("临时数据")
 
    // Path.deleteIfExists() 返回 Boolean
    // true  → 文件存在且已删除
    // false → 文件本来就不存在
    val deleted = path.deleteIfExists()
    println("删除成功: $deleted") // true
 
    // Path.deleteExisting() 在文件不存在时抛出 NoSuchFileException
    // path.deleteExisting() // 此时会抛异常
 
    // 删除非空目录会抛 DirectoryNotEmptyException
    val dir = Path("test_dir")
    dir.createDirectory()
    Path("test_dir/child.txt").writeText("子文件")
 
    try {
        dir.deleteIfExists() // 抛异常：目录非空
    } catch (e: DirectoryNotEmptyException) {
        println("无法删除非空目录: ${e.message}")
        // 需要先递归删除内容
        Path("test_dir/child.txt").deleteIfExists()
        dir.deleteIfExists()
    }
}

import java.io.File
 
fun main() {
    // 创建临时文件
    val tempFile = File.createTempFile("myapp_", ".tmp")
    println("临时文件: ${tempFile.absolutePath}")
 
    // 注册 JVM 退出时删除
    tempFile.deleteOnExit()
 
    // 使用临时文件...
    tempFile.writeText("处理中的临时数据")
 
    // 程序结束时，JVM 会自动删除这个文件
    // 注意：如果 JVM 异常终止（kill -9），钩子不会执行
}

import java.io.File
 
fun main() {
    // 准备源文件
    val source = File("source.txt")
    source.writeText("这是源文件的内容\n包含多行数据\n用于测试复制功能")
 
    // === 基本复制 ===
    // copyTo 返回目标 File 对象
    val dest = source.copyTo(File("dest.txt"))
    println("复制完成: ${dest.name}, 大小: ${dest.length()} bytes")
 
    // === 覆盖已存在的文件 ===
    // 默认情况下，如果目标文件已存在，会抛出 FileAlreadyExistsException
    try {
        source.copyTo(File("dest.txt")) // 抛异常！
    } catch (e: FileAlreadyExistsException) {
        println("目标文件已存在: ${e.message}")
    }
 
    // 设置 overwrite = true 允许覆盖
    source.copyTo(File("dest.txt"), overwrite = true)
    println("覆盖复制完成")
 
    // === bufferSize 参数 ===
    // 控制复制时的缓冲区大小，默认 8KB
    // 大文件可以增大缓冲区提升性能
    source.copyTo(
        target = File("dest_large_buf.txt"),
        overwrite = true,
        bufferSize = 64 * 1024  // 64KB 缓冲区
    )
 
    // 清理
    listOf("source.txt", "dest.txt", "dest_large_buf.txt").forEach {
        File(it).delete()
    }
}

public fun File.copyTo(
    target: File,                  // 目标文件
    overwrite: Boolean = false,    // 是否覆盖已存在的目标
    bufferSize: Int = DEFAULT_BUFFER_SIZE  // 缓冲区大小（8192）
): File

import java.io.File
 
fun main() {
    // 准备目录结构
    val srcDir = File("src_dir")
    srcDir.mkdirs()
    File("src_dir/a.txt").writeText("文件 A")
    File("src_dir/sub").mkdirs()
    File("src_dir/sub/b.txt").writeText("文件 B")
 
    // copyRecursively 递归复制整个目录树
    val destDir = File("dest_dir")
    val success = srcDir.copyRecursively(
        target = destDir,
        overwrite = false,
        // onError 回调处理复制过程中的错误
        onError = { file, exception ->
            println("复制 ${file.path} 失败: ${exception.message}")
            OnErrorAction.SKIP  // SKIP 跳过该文件继续，TERMINATE 终止整个复制
        }
    )
    println("递归复制${if (success) "成功" else "失败"}")
 
    // 验证
    destDir.walkTopDown().forEach { println(it.path) }
 
    // 清理
    srcDir.deleteRecursively()
    destDir.deleteRecursively()
}

import java.io.File
 
fun main() {
    val original = File("old_name.txt")
    original.writeText("原始内容")
 
    // === File.renameTo() ===
    // 返回 Boolean，不抛异常
    // 问题1：跨文件系统移动可能失败
    // 问题2：失败时不知道原因
    // 问题3：不同 OS 行为不一致
    val target = File("new_name.txt")
    val success = original.renameTo(target)
    println("重命名${if (success) "成功" else "失败"}")
 
    // 清理
    target.delete()
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.StandardCopyOption
 
fun main() {
    val source = Path("original.txt")
    source.writeText("原始内容")
 
    // === Path.moveTo() — 推荐方式 ===
    // 底层使用 Files.move()，行为明确且跨平台一致
    val dest = source.moveTo(Path("moved.txt"))
    println("移动完成: ${dest.name}")
 
    // 如果目标已存在，默认抛 FileAlreadyExistsException
    // 使用 overwrite = true 覆盖
    Path("another.txt").also { it.writeText("另一个文件") }
    dest.moveTo(Path("another.txt"), overwrite = true)
 
    // moveTo 还支持原子移动（如果文件系统支持）
    // 原子移动意味着：要么完全成功，要么完全不动，不会出现中间状态
    // 这在并发环境中非常重要
    Path("another.txt").moveTo(
        Path("final.txt"),
        StandardCopyOption.ATOMIC_MOVE
    )
 
    // 清理
    Path("final.txt").deleteIfExists()
}

import java.io.File
import kotlin.io.path.*
import java.nio.file.Path
 
fun main() {
    // === Java/Kotlin File 方式 ===
    // 在系统临时目录创建临时文件
    val tempFile = File.createTempFile(
        "myapp_",    // 前缀
        ".tmp"       // 后缀
    )
    println("临时文件: ${tempFile.absolutePath}")
    // 类似: /tmp/myapp_1234567890.tmp (Linux/Mac)
    // 类似: C:\Users\xxx\AppData\Local\Temp\myapp_1234567890.tmp (Windows)
 
    // 指定临时文件所在目录
    val customDir = File("my_temp")
    customDir.mkdirs()
    val tempInCustomDir = File.createTempFile("data_", ".csv", customDir)
    println("自定义目录临时文件: ${tempInCustomDir.path}")
 
    // === kotlin.io.path 方式 ===
    val tempPath = kotlin.io.path.createTempFile(
        prefix = "nio_",
        suffix = ".dat"
    )
    println("NIO 临时文件: $tempPath")
 
    // 在指定目录创建
    val tempInDir = kotlin.io.path.createTempFile(
        directory = Path("my_temp"),
        prefix = "nio_data_",
        suffix = ".bin"
    )
 
    // 清理
    tempFile.delete()
    tempInCustomDir.delete()
    tempPath.deleteIfExists()
    tempInDir.deleteIfExists()
    customDir.delete()
}

import java.io.File
import java.text.SimpleDateFormat
import java.util.Date
 
fun main() {
    val file = File("metadata_demo.txt")
    file.writeText("Hello, metadata!")
 
    // 基本属性
    println("文件名: ${file.name}")              // metadata_demo.txt
    println("父目录: ${file.parent}")             // null（相对路径时）
    println("绝对路径: ${file.absolutePath}")
    println("规范路径: ${file.canonicalPath}")     // 解析 . 和 .. 后的路径
 
    // 大小
    println("文件大小: ${file.length()} bytes")
 
    // 时间戳
    val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    println("最后修改: ${sdf.format(Date(file.lastModified()))}")
 
    // 修改时间戳
    file.setLastModified(0L) // 设置为 epoch 时间
    println("修改后时间: ${sdf.format(Date(file.lastModified()))}")
 
    // 权限（部分方法在 Windows 上行为不同）
    println("可读: ${file.canRead()}")
    println("可写: ${file.canWrite()}")
    println("可执行: ${file.canExecute()}")
 
    // 设置权限
    file.setReadOnly()                    // 设为只读
    println("设为只读后可写: ${file.canWrite()}") // false
    file.setWritable(true)               // 恢复可写
 
    // 扩展名和名称分离
    println("扩展名: ${file.extension}")          // txt
    println("无扩展名名称: ${file.nameWithoutExtension}") // metadata_demo
 
    // 清理
    file.delete()
}

import kotlin.io.path.*
import java.nio.file.Path
import java.nio.file.attribute.BasicFileAttributes
import java.nio.file.Files
 
fun main() {
    val path = Path("nio_meta.txt")
    path.writeText("NIO metadata demo")
 
    // 基本属性
    println("文件名: ${path.name}")
    println("父路径: ${path.parent}")
    println("绝对路径: ${path.absolute()}")
    println("文件大小: ${path.fileSize()} bytes")
 
    // 读取完整的文件属性（一次系统调用获取所有属性，比逐个查询高效）
    val attrs: BasicFileAttributes = Files.readAttributes(
        path,
        BasicFileAttributes::class.java
    )
    println("创建时间: ${attrs.creationTime()}")
    println("最后修改: ${attrs.lastModifiedTime()}")
    println("最后访问: ${attrs.lastAccessTime()}")
    println("是符号链接: ${attrs.isSymbolicLink}")
 
    // 清理
    path.deleteIfExists()
}

import java.io.File
import java.io.IOException
import java.nio.file.FileAlreadyExistsException
import java.nio.file.NoSuchFileException
 
fun main() {
    // 模式一：使用 runCatching 进行函数式异常处理
    val result = runCatching {
        File("nonexistent.txt").readText()
    }
 
    result
        .onSuccess { content ->
            println("读取成功: $content")
        }
        .onFailure { error ->
            println("读取失败: ${error.message}")
        }
 
    // 也可以提供默认值
    val content = runCatching {
        File("config.txt").readText()
    }.getOrDefault("默认配置内容")
    println("配置: $content")
 
    // 模式二：封装安全操作函数
    fun safeWriteText(file: File, text: String): Boolean {
        return try {
            // 确保父目录存在
            file.parentFile?.mkdirs()
            // 先写入临时文件，再原子替换（防止写入中途失败导致数据丢失）
            val tempFile = File(file.parent ?: ".", ".${file.name}.tmp")
            tempFile.writeText(text)
            // renameTo 在同一文件系统上通常是原子的
            val success = tempFile.renameTo(file)
            if (!success) {
                // 回退：直接写入
                file.writeText(text)
                tempFile.delete()
            }
            true
        } catch (e: IOException) {
            println("写入失败: ${e.message}")
            false
        }
    }
 
    // 使用安全写入
    safeWriteText(File("safe_output.txt"), "安全写入的内容")
 
    // 清理
    File("safe_output.txt").delete()
}

val file = File("output.txt")
file.writeText("AAA")
file.appendText("BBB")
file.writeText("CCC")
file.appendText("DDD")

// 方式 A
repeat(10000) { file.appendText("log line $it\n") }
 
// 方式 B
file.bufferedWriter().use { w ->
    repeat(10000) { w.write("log line $it\n") }
}
 
// 方式 C
val sb = StringBuilder()
repeat(10000) { sb.appendLine("log line $it") }
file.writeText(sb.toString())
 
// 方式 D
repeat(10000) { file.writeText("log line $it\n") }

import kotlin.io.path.*  // 引入 path 扩展函数
import java.nio.file.Path
 
fun main() {
    // === createDirectory：只创建最后一级目录 ===
    // 如果父目录不存在，会抛出 java.nio.file.NoSuchFileException
    val singleDir: Path = Path("output")  // 构建路径对象
    singleDir.createDirectory()           // 创建 "output" 目录
 
    // === createDirectories：递归创建所有缺失的中间目录 ===
    // 类似于 Linux 的 mkdir -p 命令
    val nestedDir: Path = Path("output/logs/2024/archive")
    nestedDir.createDirectories()  // 一次性创建 output -> logs -> 2024 -> archive
 
    // === 重复创建的行为差异 ===
    // createDirectory() 在目录已存在时抛出 FileAlreadyExistsException
    // createDirectories() 在目录已存在时静默成功（幂等操作）
    nestedDir.createDirectories()  // 安全，不会报错
 
    // === 实战模式：条件创建 ===
    val dataDir = Path("data")
    if (!dataDir.exists()) {       // 先检查是否存在
        dataDir.createDirectory()  // 不存在才创建
    }
 
    // 更简洁的写法：直接用 createDirectories（推荐）
    Path("data").createDirectories()  // 存在就跳过，不存在就创建
}

import kotlin.io.path.*
 
fun main() {
    val projectDir = Path("my-project")
 
    // === 列举所有直接子项 ===
    // 返回 List<Path>，包含文件和子目录（不递归进入子目录）
    val allEntries: List<Path> = projectDir.listDirectoryEntries()
    allEntries.forEach { entry ->
        // name 属性获取文件/目录名（不含父路径）
        println("${entry.name} -> isDirectory: ${entry.isDirectory()}")
    }
 
    // === 使用 glob 模式过滤 ===
    // glob 是一种简单的通配符语法，比正则表达式更直观
 
    // 只列出 .kt 文件
    val ktFiles = projectDir.listDirectoryEntries("*.kt")
 
    // 只列出 .kt 和 .java 文件（花括号表示"或"）
    val sourceFiles = projectDir.listDirectoryEntries("*.{kt,java}")
 
    // 只列出以 test 开头的文件
    val testFiles = projectDir.listDirectoryEntries("test*")
 
    // 只列出所有 JSON 配置文件
    val configs = projectDir.listDirectoryEntries("*.json")
 
    // === 结合 Kotlin 集合操作进行精细过滤 ===
    val largeKtFiles = projectDir.listDirectoryEntries("*.kt")
        .filter { it.fileSize() > 1024 }       // 大于 1KB 的文件
        .sortedByDescending { it.fileSize() }   // 按大小降序排列
        .take(5)                                 // 取前 5 个
 
    largeKtFiles.forEach { file ->
        // 打印文件名和大小（转换为 KB）
        println("${file.name}: ${file.fileSize() / 1024} KB")
    }
}

import kotlin.io.path.*
 
fun main() {
    val root = Path("my-project")
 
    // === forEachDirectoryEntry：遍历直接子项（非递归） ===
    // 与 listDirectoryEntries 类似，但不创建中间 List，更节省内存
    root.forEachDirectoryEntry("*.kt") { entry ->  // 支持 glob 过滤
        println("Found: ${entry.name}")             // 逐个处理
    }
 
    // === Path.walk()（Kotlin 1.9.20+，kotlin.io.path 包） ===
    // 返回 Sequence<Path>，惰性递归遍历整棵目录树
    val allFiles: Sequence<Path> = root.walk()  // 默认深度优先（DFS）
    allFiles
        .filter { it.isRegularFile() }          // 只保留普通文件（排除目录）
        .filter { it.extension == "kt" }        // 只保留 .kt 扩展名
        .forEach { println(it) }                // 打印完整路径
}

import kotlin.io.path.*
import java.nio.file.Path
 
// 递归打印目录树，类似 Linux 的 tree 命令
fun printTree(dir: Path, prefix: String = "", isLast: Boolean = true) {
    // 打印当前节点（目录名），使用树形连接符
    val connector = if (isLast) "└── " else "├── "  // 最后一项用 └，其余用 ├
    println("$prefix$connector${dir.name}/")          // 目录名后加 / 标识
 
    // 获取当前目录的所有子项，并按名称排序
    val children = dir.listDirectoryEntries()
        .sortedWith(                                   // 自定义排序规则
            compareByDescending<Path> { it.isDirectory() }  // 目录排在前面
                .thenBy { it.name }                         // 同类型按名称字母序
        )
 
    // 计算下一级的缩进前缀
    val childPrefix = prefix + if (isLast) "    " else "│   "
 
    children.forEachIndexed { index, child ->          // 带索引遍历
        val childIsLast = (index == children.size - 1) // 判断是否为最后一项
        if (child.isDirectory()) {
            printTree(child, childPrefix, childIsLast) // 递归处理子目录
        } else {
            val conn = if (childIsLast) "└── " else "├── "
            println("$childPrefix$conn${child.name}")  // 打印文件名
        }
    }
}
 
fun main() {
    val projectRoot = Path("my-project")
    println(projectRoot.name + "/")  // 打印根目录名
    printTree(projectRoot)           // 开始递归打印
}

my-project/
└── my-project/
    ├── src/
    │   ├── main/
    │   │   └── Main.kt
    │   └── test/
    │       └── MainTest.kt
    ├── build.gradle.kts
    └── settings.gradle.kts

import java.io.File
 
fun main() {
    val root = File("my-project")
 
    // === 基本用法：自顶向下遍历 ===
    // walkTopDown 返回 Sequence<File>，惰性求值
    root.walkTopDown().forEach { file ->
        // 计算缩进层级：相对路径中的分隔符数量
        val depth = file.relativeTo(root).path
            .count { it == File.separatorChar }  // 统计路径分隔符个数
        val indent = "  ".repeat(depth)          // 每层缩进两个空格
        val icon = if (file.isDirectory) "📁" else "📄"  // 目录和文件用不同图标
        println("$indent$icon ${file.name}")
    }
}

my-project/
├── src/
│   ├── Main.kt
│   └── utils/
│       └── Helper.kt
├── test/
│   └── MainTest.kt
└── README.md

import java.io.File
 
fun main() {
    val root = File("my-project")
 
    // === 自底向上遍历 ===
    root.walkBottomUp().forEach { file ->
        println(file.relativeTo(root))  // 打印相对路径
    }
    // 输出顺序（与 walkTopDown 相反）：
    // Main.kt
    // Helper.kt
    // utils
    // src
    // MainTest.kt
    // test
    // README.md
    // my-project（根目录最后）
}

import java.io.File
 
fun main() {
    val tempDir = File("temp-workspace")
 
    // === 安全的递归删除 ===
    // walkBottomUp 保证子项在父目录之前被处理
    tempDir.walkBottomUp().forEach { file ->
        val deleted = file.delete()  // 删除当前文件或空目录
        if (deleted) {
            println("Deleted: ${file.path}")
        } else {
            println("Failed to delete: ${file.path}")
        }
    }
 
    // Kotlin 也提供了更简洁的内置方法
    // tempDir.deleteRecursively()  // 内部实现原理与上面类似
}

import java.io.File
 
fun main() {
    val root = File("my-project")
 
    // === maxDepth 控制递归层数 ===
    // maxDepth(1) 表示只看根目录和它的直接子项（共 2 层）
    root.walkTopDown()
        .maxDepth(1)          // 限制深度为 1（根 + 直接子项）
        .forEach { println(it.name) }
    // 输出：my-project, src, test, README.md
    // 不会进入 src/ 或 test/ 内部
 
    // maxDepth(2) 会多看一层
    root.walkTopDown()
        .maxDepth(2)          // 根 + 子项 + 孙项
        .forEach { println(it.relativeTo(root)) }
    // 输出：., src, src/Main.kt, src/utils, test, test/MainTest.kt, README.md
    // 注意 utils/ 内部的 Helper.kt 不会出现
 
    // maxDepth(0) 只返回根目录自身
    root.walkTopDown()
        .maxDepth(0)
        .toList()             // 结果：[my-project]
}

my-project/          ← depth 0（根目录自身）
├── src/             ← depth 1
│   ├── Main.kt      ← depth 2
│   └── utils/       ← depth 2
│       └── Helper.kt ← depth 3
├── test/            ← depth 1
│   └── MainTest.kt  ← depth 2
└── README.md        ← depth 1

import java.io.File
 
fun main() {
    val root = File("my-project")
 
    // === onEnter：进入目录前的守门回调 ===
    root.walkTopDown()
        .onEnter { dir ->
            // 跳过隐藏目录（以 . 开头）和 build 产物目录
            val skip = dir.name.startsWith(".") ||  // .git, .idea 等
                       dir.name == "build" ||        // Gradle 构建产物
                       dir.name == "node_modules"    // npm 依赖（如果有）
            !skip  // 返回 true 表示进入，false 表示跳过
        }
        .filter { it.isFile }                        // 只保留文件
        .filter { it.extension in listOf("kt", "java") }  // 只要源代码
        .forEach { println(it.relativeTo(root)) }
}

import java.io.File
 
fun main() {
    val root = File("my-project")
    var fileCount = 0  // 文件计数器
 
    root.walkTopDown()
        .onEnter { dir ->
            println("→ Entering: ${dir.name}")  // 进入目录时打印
            true                                 // 始终进入
        }
        .onLeave { dir ->
            println("← Leaving: ${dir.name}")   // 离开目录时打印
        }
        .forEach { file ->
            if (file.isFile) {
                fileCount++  // 统计文件数量
            }
        }
 
    println("Total files: $fileCount")
}

import kotlin.io.path.*
 
fun main() {
    val root = Path("my-project")
 
    // === Path.walk() 基本用法 ===
    // 默认使用 PathWalkOption 为空集，即自顶向下深度优先
    root.walk()
        .filter { it.isRegularFile() }    // 只保留普通文件
        .filter { it.extension == "kt" }  // 只要 Kotlin 源文件
        .forEach { println(it) }
 
    // === 包含隐藏文件和符号链接 ===
    root.walk(PathWalkOption.INCLUDE_DIRECTORIES)  // 结果中包含目录本身
        .forEach { println(it) }
 
    // === 结合 Sequence 操作进行复杂查询 ===
    // 找出项目中最大的 5 个 Kotlin 文件
    val top5 = root.walk()
        .filter { it.isRegularFile() }             // 只要文件
        .filter { it.extension == "kt" }           // 只要 .kt
        .sortedByDescending { it.fileSize() }      // 按大小降序
        .take(5)                                    // 取前 5 个
        .toList()                                   // 终端操作，触发求值
 
    top5.forEachIndexed { index, path ->
        println("#${index + 1}: ${path.name} (${path.fileSize() / 1024} KB)")
    }
}

import java.io.File
 
// 项目分析结果数据类
data class ProjectStats(
    val totalFiles: Int,           // 总文件数
    val totalDirs: Int,            // 总目录数
    val totalSize: Long,           // 总大小（字节）
    val filesByExtension: Map<String, Int>,  // 按扩展名统计文件数
    val largestFiles: List<File>,  // 最大的文件列表
    val deepestPath: String        // 最深的路径
)
 
fun analyzeProject(root: File): ProjectStats {
    var totalFiles = 0                          // 文件计数器
    var totalDirs = 0                           // 目录计数器
    var totalSize = 0L                          // 总大小累加器
    val extCount = mutableMapOf<String, Int>()  // 扩展名 -> 文件数
    var maxDepth = 0                            // 最大深度
    var deepestPath = ""                        // 最深路径
 
    // 使用 walkTopDown 遍历，跳过不需要的目录
    val allFiles = root.walkTopDown()
        .onEnter { dir ->
            // 剪枝：跳过版本控制、构建产物、IDE 配置
            dir.name !in setOf(".git", ".idea", "build", "out", "node_modules")
        }
        .onLeave { dir ->
            totalDirs++  // 离开目录时计数
        }
        .filter { it.isFile }  // 只处理文件
        .toList()              // 收集为列表
 
    allFiles.forEach { file ->
        totalFiles++                                    // 文件计数
        totalSize += file.length()                      // 累加大小
        val ext = file.extension.ifEmpty { "no-```kotlin
ext" }  // 获取扩展名，无扩展名标记为 "no-ext"
        extCount[ext] = (extCount[ext] ?: 0) + 1       // 扩展名计数
 
        // 计算当前文件的深度
        val depth = file.relativeTo(root).path
            .count { it == File.separatorChar }         // 路径分隔符数量即深度
        if (depth > maxDepth) {                         // 更新最大深度
            maxDepth = depth
            deepestPath = file.relativeTo(root).path
        }
    }
 
    // 找出最大的 5 个文件
    val largest = allFiles
        .sortedByDescending { it.length() }  // 按文件大小降序
        .take(5)                              // 取前 5 个
 
    return ProjectStats(
        totalFiles = totalFiles,
        totalDirs = totalDirs,
        totalSize = totalSize,
        filesByExtension = extCount.toSortedMap(),  // 按扩展名字母序排列
        largestFiles = largest,
        deepestPath = deepestPath
    )
}
 
fun main() {
    val root = File("my-project")
    val stats = analyzeProject(root)
 
    println("=== 项目分析报告 ===")
    println("文件总数: ${stats.totalFiles}")
    println("目录总数: ${stats.totalDirs}")
    println("总大小: ${stats.totalSize / 1024} KB")
    println()
 
    println("--- 文件类型分布 ---")
    stats.filesByExtension.forEach { (ext, count) ->
        // 用 # 号绘制简易柱状图
        val bar = "#".repeat(count.coerceAtMost(30))  // 最多 30 个 #
        println("  .$ext: $bar ($count)")
    }
    println()
 
    println("--- 最大文件 TOP 5 ---")
    stats.largestFiles.forEachIndexed { i, file ->
        println("  #${i + 1}: ${file.name} (${file.length() / 1024} KB)")
    }
    println()
 
    println("最深路径: ${stats.deepestPath}")
}

import java.io.File
import java.io.IOException
 
fun main() {
    val root = File("/some/system/path")
 
    root.walkTopDown()
        .onEnter { dir ->
            // 尝试进入目录，如果没有读权限则跳过
            dir.canRead()  // 返回 false 时自动跳过该子树
        }
        .onFail { file, exception ->
            // 当访问某个文件/目录失败时调用
            // file: 出问题的文件
            // exception: 具体的异常（通常是 IOException）
            when (exception) {
                is java.nio.file.AccessDeniedException ->
                    System.err.println("权限不足，跳过: ${file.path}")
                is java.nio.file.NoSuchFileException ->
                    System.err.println("文件已被删除: ${file.path}")
                else ->
                    System.err.println("未知错误 [${file.path}]: ${exception.message}")
            }
            // onFail 不需要返回值，遍历会自动继续处理下一个条目
        }
        .filter { it.isFile }
        .forEach { file ->
            // 安全地处理每个文件
            try {
                println("${file.name}: ${file.length()} bytes")
            } catch (e: SecurityException) {
                System.err.println("安全异常: ${e.message}")
            }
        }
}

import java.io.File
 
fun main() {
    val root = File("large-project")
 
    // ❌ 反模式：先收集所有文件到 List，再过滤
    // 如果目录包含 100 万个文件，这会占用大量内存
    val bad = root.walkTopDown()
        .toList()                    // 一次性加载所有路径到内存！
        .filter { it.extension == "kt" }
 
    // ✅ 正确做法：利用 Sequence 的惰性求值，边遍历边过滤
    // 内存中同一时刻只持有当前正在处理的路径
    val good = root.walkTopDown()
        .onEnter { it.name != ".git" }  // 尽早剪枝，避免进入无关子树
        .filter { it.isFile }            // 先过滤掉目录
        .filter { it.extension == "kt" } // 再过滤扩展名
        .take(100)                       // 如果只需要前 100 个，尽早终止
        .toList()                        // 最终才收集
 
    // ✅ 正确做法：用 find 替代 filter + first（找到即停）
    val target = root.walkTopDown()
        .onEnter { it.name != "build" }
        .find { it.name == "Application.kt" }  // 找到第一个就停止遍历
    println("Found: ${target?.path ?: "not found"}")
 
    // ✅ 正确做法：统计时用 fold/reduce 而不是 toList + sum
    val totalKtSize = root.walkTopDown()
        .onEnter { it.name !in setOf(".git", "build", ".idea") }
        .filter { it.isFile && it.extension == "kt" }
        .fold(0L) { acc, file ->         // 流式累加，不创建中间集合
            acc + file.length()
        }
    println("Kotlin 源码总大小: ${totalKtSize / 1024} KB")
}