Python/JS/Go/Java同步学习(第五十九篇)四语言“文件目录遍历“对照表: 雷影“老板“要求员工休息日野外实战训练团建风暴（附源码/截图/参数表/避坑指南）
🤝 免骂声明：
- 本文
文件目录遍历操作经本蜀黎实战整理，旨在提供快速参考指南📝- 因各语言版本迭代及不同系统
环境差异，偶尔可能出现整理不全面之处，实属正常✅- 理性讨论欢迎，无凭据攻击将依据平台规则处理，并可能触发内容自动备份传播机制🙏！
- 若遇具体问题，请带图评论区留言，本蜀黎必拔码相助🤝
※ 温馨提示
- 若本内容
不慎触及某些利益，请理性沟通，但删稿免谈，内容去留仅由平台规则决定。 - 若是学生/自学党，欢迎白嫖，记得转发给和你一样在这条路上同行的伙伴——🔁
- 知识不该被垄断，而该成为照亮彼此前行的灯。
- API较多不建议死记硬背，学会理解概念随用随时查
🛡️ 【技术剧情免责声明】
⚠️ 剧情设定说明
-
本文中的职场冲突情节，均为行业技术实践的
戏剧化隐喻 -
所有角色立场设计，旨在对比不同技术方案的适用场景
-
无任何现实指向性，亦
不倡导对立思维
🌿 技术交流初心
-
旨在通过场景化演绎，
降低技术理解门槛 -
遵循「以代码服人，以逻辑辨真」的极客精神
-
鼓励理性探讨，反对任何形式的技术偏见
💡 阅读建议
-
请重点关注技术实现路径的多样性
-
建议将剧情视为技术选型的「压力测试沙盒」
-
欢迎在评论区分享您的技术解决方案
🌿【虎山CTO·药材使用警示】
- 🍀是药
三分毒，代码亦如方！ - ❌文中所涉药材均为技术隐喻，严禁实际配伍使用。
- 🙏真实用药请遵医嘱，乱用者——
- 系统崩坏事小，气血逆流事大！⚠️
📚 系列文章预告：
- 近期内容将聚焦编程基础构建，以
「原创知识矩阵」形式系统梳理核心概念。每篇如连续剧集般环环相扣，建议按顺序学习——知识点一锅端，疗效更持久！🔥
⚡️ 目录的遍历操作：从“雷影办公室的文件风暴”到“药房巡检的望闻问切”
🔥 【场景还原：雷影老板的暴怒巡查】
💢 四代目雷影·艾（一拳砸碎办公桌）
- 「今日技术考核：文件系统遍历！连
os.listdir和os.walk都分不清的忍者——直接送去云隐村矿场挖三年数据矿石！」
⛈️ 萨姆依（抱着一堆混乱的文件目录）
- 「雷影大人！为什么要有这么多遍历方法？我的查克拉管理系统完全混乱了！」
⚡ 达鲁伊（懒洋洋地翻着文件）
- 「雷影大人，这就像矿场的分层开采——
listdir是查看表层矿石，walk是深层掘进，不同语言就是不同的开采设备……」
💥 雷影（全身雷电爆发）
- 「废话少说！真正的云隐忍者，必须在三秒内找到任何深藏的文件！不会遍历的忍者，连当数据矿工的资格都没有！」
🧘 【扎马步·目录遍历三重境界】
💡 遍历三重境界：
第一重：表面扫描
- 单层目录列表 → 如“药房表面巡检”
- 区分文件与目录 → 如“药材与药柜识别”
- 基本路径处理 → 如“药方初步整理”
第二重：深度探查
- 递归遍历全树 → 如“药房全库盘点”
- 获取元数据信息 → 如“药材生产日期检查”
- 过滤与筛选 → 如“过期药材识别”
第三重：高效优化
- 异步批量处理 → 如“多药房并行巡检”
- 内存使用优化 → 如“大型药库分批处理”
- 异常处理完备 → 如“破损药柜应急方案”
🌩️ 【四语言目录遍历奥义】
🐍 Python → 写轮眼·细致入微
特点：如“老药师的全方位望诊”，层层递进，信息详尽
import os
from pathlib import Path
# 第一层：表面查看（如快速巡视药房）
print("📋 药房表层药材：")
for item in os.listdir("中药房"): # 只看表面
print(f" - {item}")
# 第二层：带状态查看（如检查药材状态）
print("\n🔍 药房详细清单：")
for entry in os.scandir("中药房"):
if entry.is_file():
print(f"📄 药材文件：{entry.name} ({entry.stat().st_size}克)")
elif entry.is_dir():
print(f"📁 药柜目录：{entry.name}")
# 第三层：深度探查（如全面盘点）
print("\n🌳 药房完整结构：")
for root, dirs, files in os.walk("中药房"):
print(f"\n📍 当前区域：{root}")
print(f" 药柜列表：{dirs}")
print(f" 药材清单：{files}")
# 现代写法（Path对象）
药材库 = Path("中药房")
print(f"\n💊 找到 {len(list(药材库.glob('**/*.txt')))} 份药方")
中医映射：
os.listdir()→ 望诊（表面观察）os.scandir()→ 闻诊（获取详细信息）os.walk()→ 问诊（深入探查）Path.glob()→ 切诊（精准定位）
☕ Java → 白眼·标准严谨
特点：如“御医院的标准化巡检”，类型安全，流程规范
import java.nio.file.*;
import java.io.IOException;
public class 药房巡检 {
public static void main(String[] args) throws IOException {
// 标准巡检流程
Path 药房路径 = Paths.get("太医院/中药库");
// 快速扫描（基础盘点）
System.out.println("📋 药库表层清单：");
try (DirectoryStream<Path> 流 = Files.newDirectoryStream(药房路径)) {
for (Path 条目 : 流) {
System.out.println(" - " + 条目.getFileName());
}
}
// 深度遍历（全面审计）
System.out.println("\n🌳 药库完整结构：");
Files.walkFileTree(药房路径, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path 文件, BasicFileAttributes 属性) {
System.out.println("📄 药材：" + 文件.getFileName());
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult preVisitDirectory(Path 目录, BasicFileAttributes 属性) {
System.out.println("\n📁 进入药柜：" + 目录.getFileName());
return FileVisitResult.CONTINUE;
}
});
}
}
中医映射：
Files.newDirectoryStream()→ 望诊流程Files.walkFileTree()→ 系统化问诊BasicFileAttributes→ 药材性状记录FileVisitResult→ 诊断结果处理
⚡ Go → 体术·直击要害
特点：如“游医的快速诊断”，简洁高效，直面问题
package main
import (
"fmt"
"io/ioutil"
"path/filepath"
)
func 巡检药房(药房路径 string) error {
// 快速查看（扫视全貌）
fmt.Println("📋 药房概况：")
项目列表, _ := ioutil.ReadDir(药房路径)
for _, 项目 := range 项目列表 {
if 项目.IsDir() {
fmt.Printf("📁 %s/\n", 项目.Name())
} else {
fmt.Printf("📄 %s (%d字节)\n", 项目.Name(), 项目.Size())
}
}
// 递归遍历（深度检查）
fmt.Println("\n🌳 完整结构：")
err := filepath.Walk(药房路径, func(路径 string, 信息 os.FileInfo, 错误 error) error {
if 错误 != nil {
return 错误
}
缩进 := ""
for i := 0; i < len(filepath.Dir(路径))-len(filepath.Dir(药房路径)); i++ {
缩进 += " "
}
if 信息.IsDir() {
fmt.Printf("%s📁 %s\n", 缩进, 信息.Name())
} else {
fmt.Printf("%s📄 %s\n", 缩进, 信息.Name())
}
return nil
})
return err
}
func main() {
巡检药房("游医药箱")
}
中医映射：
ioutil.ReadDir()→ 快速望诊filepath.Walk()→ 深入切诊- 错误直接返回 → 诊断明确直接
- 递归回调 → 按需深入探查
🟨 JavaScript → 幻术·异步灵动
特点：如“炼丹师的时空探查”，异步并行，灵活多变
const fs = require('fs').promises;
const path = require('path');
async function 异步巡检药房(药房路径) {
try {
// 异步快速扫描
console.log('📋 开始药房巡检...');
const 表层项目 = await fs.readdir(药房路径, { withFileTypes: true });
for (const 项目 of 表层项目) {
if (项目.isDirectory()) {
console.log(`📁 发现药柜：${项目.name}`);
// 异步深入检查
const 子药柜路径 = path.join(药房路径, 项目.name);
const 子项目 = await fs.readdir(子药柜路径);
console.log(` 内含药材：${子项目.length}种`);
} else {
const 状态 = await fs.stat(path.join(药房路径, 项目.name));
console.log(`📄 药材：${项目.name} (${状态.size}字节)`);
}
}
// 并行批量处理（多药柜同时检查）
console.log('\n⚡ 并行深度检查：');
const 药柜列表 = 表层项目.filter(i => i.isDirectory());
await Promise.all(药柜列表.map(async (药柜) => {
const 药柜路径 = path.join(药房路径, 药柜.name);
const 药材列表 = await fs.readdir(药柜路径);
console.log(`✅ ${药柜.name}：${药材列表.length}种药材`);
}));
} catch (错误) {
console.error('💥 巡检失败：', 错误.message);
}
}
// 中医映射：
// fs.readdir() → 望诊（可配置深度）
// fs.stat() → 闻诊（获取详细信息）
// Promise.all() → 并行诊断
// async/await → 有序问诊流程
📊 四语言目录遍历对比表
| 特性 | Python | Java | Go | JavaScript |
|---|---|---|---|---|
| 基础遍历 | os.listdir() |
Files.newDirectoryStream() |
ioutil.ReadDir() |
fs.readdir() |
| 带元数据遍历 | os.scandir() |
DirectoryStream+Files |
ioutil.ReadDir()自带 |
fs.readdir({withFileTypes:true}) |
| 递归遍历 | os.walk() |
Files.walkFileTree() |
filepath.Walk() |
需自定义或使用fs.readdir递归 |
| 异步支持 | asyncio库 |
CompletableFuture |
goroutine |
原生Promise支持 |
| 错误处理 | try/except | try/catch | 多返回值 | try/catch或回调 |
| 路径处理 | os.path或pathlib |
Paths.get() |
path/filepath |
path模块 |
| 中医映射 | 望闻问切完整流程 | 标准化御医巡检 | 游医快速诊断 | 炼丹师时空探查 |
| 性能特点 | 灵活方便 | 严谨安全 | 高效简洁 | 异步并发强 |
| 适用场景 | 脚本/数据分析 | 企业系统/工具 | 系统工具/CLI | Web服务/Node应用 |
⚠️ 【避坑指南·药房巡检雷区】
🐍 Python：细节决定成败
# 💥 雷点1：遍历时修改目录（药房盘点时移动药柜）
for root, dirs, files in os.walk("药房"):
for dir_name in dirs:
# 危险！遍历中删除会导致异常
shutil.rmtree(os.path.join(root, dir_name))
# ✅ 正道：先收集再操作
待处理目录 = []
for root, dirs, files in os.walk("药房"):
待处理目录.extend([os.path.join(root, d) for d in dirs])
# 安全处理
for 目录 in 待处理目录:
shutil.rmtree(目录)
# 💥 雷点2：符号链接无限循环（药房迷宫）
os.symlink(".", "药房/循环链接") # 创建指向自己的链接
# 遍历时会陷入死循环！
☕ Java：资源泄漏陷阱
// 💥 雷点1：DirectoryStream未关闭（巡检后不关门）
DirectoryStream<Path> stream = Files.newDirectoryStream(path);
for (Path entry : stream) {
System.out.println(entry.getFileName());
}
// 忘记 stream.close()！资源泄漏！
// ✅ 正道：使用try-with-resources
try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
for (Path entry : stream) {
// 安全使用
}
}
// 💥 雷点2：大目录内存溢出（药库太大）
List<Path> 所有文件 = Files.walk(药房路径)
.collect(Collectors.toList()); // 全加载到内存！
// 可能OOM
⚡ Go：并发访问冲突
// 💥 雷点1：遍历中并发修改（多人同时整理药房）
go func() {
filepath.Walk("药房", func(path string, info os.FileInfo, err error) error {
// 另一个goroutine可能在删除文件！
return nil
})
}()
go func() {
os.RemoveAll("药房/过期药材") // 并发删除！
}()
// ✅ 正道：加锁或避免并发
var mu sync.Mutex
mu.Lock()
filepath.Walk("药房", walkFunc)
mu.Unlock()
🟨 JavaScript：回调地狱与Promise竞态
// 💥 雷点1：回调地狱（旧式巡检）
fs.readdir('药房', (err1, items) => {
items.forEach(item => {
fs.stat(path.join('药房', item), (err2, stats) => {
if (stats.isDirectory()) {
fs.readdir(path.join('药房', item), (err3, subItems) => {
// 更多嵌套... 地狱！
});
}
});
});
});
// ✅ 正道：async/await
async function 安全巡检() {
const items = await fs.readdir('药房', { withFileTypes: true });
for (const item of items) {
if (item.isDirectory()) {
const subItems = await fs.readdir(path.join('药房', item.name));
// 清晰明了
}
}
}
// 💥 雷点2：Promise未处理拒绝
巡检药房('药房'); // 没有catch！进程崩溃风险
// ✅ 正道：
巡检药房('药房').catch(err => console.error('巡检出错:', err));
以下是本蜀黎整理
源码和截图⏬
1.Python源码⏬
⚡Python注意别用中文文件名，我加了test测试函数
import os
# ==================== 财务侦探模块 ====================
# os.listdir("可疑科目") # 检查财务部的抽屉 📂
# os.scandir("子公司") # 带元数据的高级遍历 🔍
# os.walk("集团账本") # 掘地三尺的深度审计 🕵️
# ⚠️ERP_冷溪虎山：遍历过深会触发不良情绪
# --------------------------
# 1. os.listdir() 基础遍历
# --------------------------
def traverse_with_listdir(dir_path):
"""
使用 os.listdir() 遍历目录(仅获取名称)
"""
print("\n=== os.listdir() 示例 ===")
print(f"遍历目录: {dir_path}")
# 获取目录内容名称列表
names = os.listdir(dir_path)
# 打印所有内容(文件和子目录)
for name in names:
print(name) # 只有名称，没有完整路径
# --------------------------
# 2. os.scandir() 高效遍历
# --------------------------
def traverse_with_scandir(dir_path):
"""
使用 os.scandir() 遍历目录(获取更多信息)
"""
print("\n=== os.scandir() 示例 ===")
print(f"遍历目录: {dir_path}")
# 创建扫描器对象
with os.scandir(dir_path) as entries:
# 遍历目录条目
for entry in entries:
# 判断是文件还是目录
if entry.is_file():
print(f"[文件] {entry.name}")
elif entry.is_dir():
print(f"[目录] {entry.name}")
# --------------------------
# 3. os.walk() 递归遍历
# --------------------------
def traverse_with_walk(dir_path):
"""
使用 os.walk() 递归遍历目录树
"""
print("\n=== os.walk() 示例 ===")
print(f"递归遍历目录: {dir_path}")
# walk() 生成器会自动递归所有子目录
for root, dirs, files in os.walk(dir_path):
print(f"\n当前目录: {root}")
print(f"子目录列表: {dirs}")
print(f"文件列表: {files}")
# --------------------------
# 测试函数
# --------------------------
def test_directory_traversals():
"""
测试三种遍历方法
"""
# 创建测试目录结构
test_dir = "./file/test_traversal59"
os.makedirs(test_dir, exist_ok=True)
os.makedirs(f"{test_dir}/subdir1", exist_ok=True)
os.makedirs(f"{test_dir}/subdir2", exist_ok=True)
# 创建测试文件
with open(f"{test_dir}/file59_1.txt", "w", encoding="utf8") as f:
f.write("测试文件1")
with open(f"{test_dir}/subdir1/file59_2.txt", "w", encoding="utf8") as f:
f.write("测试文件2")
with open(f"{test_dir}/subdir2/file59_3.txt", "w", encoding="utf8") as f:
f.write("测试文件3")
# 执行三种遍历方法
traverse_with_listdir(test_dir)
traverse_with_scandir(test_dir)
traverse_with_walk(test_dir)
# 清理测试目录(实际使用时不需要)
# import shutil
# shutil.rmtree(test_dir)
if __name__ == "__main__":
test_directory_traversals()
2.Nodejs源码⏬
const fs = require('fs');
const path = require('path');
// ==================== 中药侦查模块 ====================
// 查看丹方目录 // 偷翻老君的药材柜 🏺
// 扫描炼丹记录 // 带火候参数的检查 ♨️
// 深度遍历药库 // 掘地三尺找仙草 🌿
// ⚠️虎山老药师：过度窥探会惊动药灵
// --------------------------
// 1. 类似 os.listdir() 的基础遍历
// --------------------------
function traverseWithListdir(dirPath) {
console.log("\n=== 类似 os.listdir() 示例 ===");
console.log(`遍历目录: ${dirPath}`);
try {
// 获取目录内容名称列表
const names = fs.readdirSync(dirPath);
// 打印所有内容(文件和子目录)
for (const name of names) {
console.log(name); // 只有名称，没有完整路径
}
} catch (err) {
console.error(`读取目录错误: ${err.message}`);
}
}
// --------------------------
// 2. 类似 os.scandir() 的高效遍历
// --------------------------
function traverseWithScandir(dirPath) {
console.log("\n=== 类似 os.scandir() 示例 ===");
console.log(`遍历目录: ${dirPath}`);
try {
// 读取目录内容(类似scandir)
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
// 遍历目录条目
for (const entry of entries) {
// 判断是文件还是目录
if (entry.isFile()) {
console.log(`[文件] ${entry.name}`);
} else if (entry.isDirectory()) {
console.log(`[目录] ${entry.name}`);
}
}
} catch (err) {
console.error(`读取目录错误: ${err.message}`);
}
}
// --------------------------
// 3. 类似 os.walk() 的递归遍历
// --------------------------
function traverseWithWalk(dirPath) {
console.log("\n=== 类似 os.walk() 示例 ===");
console.log(`递归遍历目录: ${dirPath}`);
// 递归遍历函数
function walk(directory) {
try {
// 读取当前目录内容
const entries = fs.readdirSync(directory, { withFileTypes: true });
const dirs = [];
const files = [];
// 分类条目
for (const entry of entries) {
const fullPath = path.join(directory, entry.name);
if (entry.isDirectory()) {
dirs.push(entry.name);
// 递归处理子目录
walk(fullPath);
} else if (entry.isFile()) {
files.push(entry.name);
}
}
// 打印当前目录信息(类似os.walk的输出)
console.log(`\n当前目录: ${directory}`);
console.log(`子目录列表: ${dirs}`);
console.log(`文件列表: ${files}`);
} catch (err) {
console.error(`读取目录错误: ${err.message}`);
}
}
// 开始遍历
walk(dirPath);
}
// --------------------------
// 测试函数
// --------------------------
function testDirectoryTraversals() {
// 定义测试用的目录路径
const testDir = "./file/test_traversal59";
// 创建测试目录结构
try {
// 先清理可能已存在的目录
if (fs.existsSync(testDir)) {
fs.rmSync(testDir, { recursive: true, force: true });
}
// 重新创建目录结构
fs.mkdirSync(testDir, { recursive: true });
fs.mkdirSync(`${testDir}/subdir1`);
fs.mkdirSync(`${testDir}/subdir2`);
// 创建测试文件
fs.writeFileSync(`${testDir}/file59_1.txt`, "测试文件1");
fs.writeFileSync(`${testDir}/subdir1/file59_2.txt`, "测试文件2");
fs.writeFileSync(`${testDir}/subdir2/file59_3.txt`, "测试文件3");
} catch (err) {
console.error(`创建测试目录错误: ${err.message}`);
return;
}
// 执行三种遍历方法
traverseWithListdir(testDir);
traverseWithScandir(testDir);
traverseWithWalk(testDir);
}
// 运行测试
testDirectoryTraversals();
3.Go源码⏬
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
)
// ==================== 仓储巡检模块 ====================
// 列出货架商品 // 仓库猫的日常巡逻 🐾
// 扫描货物详情 // 带保质期的检查 🏷️
// 递归检查库存 // 立体仓库的全面体检 🏗️
// ⚠️冷溪物流：扫描过频会导致货架害羞
// --------------------------
// 1. 类似 os.listdir() 的基础遍历
// --------------------------
func traverseWithListdir(dirPath string) {
fmt.Println("\n=== 类似 os.listdir() 示例 ===")
fmt.Printf("遍历目录: %s\n", dirPath)
// 获取目录内容名称列表
names, err := ioutil.ReadDir(dirPath)
if err != nil {
fmt.Printf("读取目录错误: %v\n", err)
return
}
// 打印所有内容(文件和子目录)
for _, name := range names {
fmt.Println(name.Name()) // 只有名称，没有完整路径
}
}
// --------------------------
// 2. 类似 os.scandir() 的高效遍历
// --------------------------
func traverseWithScandir(dirPath string) {
fmt.Println("\n=== 类似 os.scandir() 示例 ===")
fmt.Printf("遍历目录: %s\n", dirPath)
// 获取目录内容
names, err := ioutil.ReadDir(dirPath)
if err != nil {
fmt.Printf("读取目录错误: %v\n", err)
return
}
// 遍历目录条目
for _, name := range names {
if name.IsDir() {
fmt.Printf("[目录] %s\n", name.Name())
} else {
fmt.Printf("[文件] %s\n", name.Name())
}
}
}
// --------------------------
// 3. 类似 os.walk() 的递归遍历
// --------------------------
func traverseWithWalk(dirPath string) {
fmt.Println("\n=== 类似 os.walk() 示例 ===")
fmt.Printf("递归遍历目录: %s\n", dirPath)
// 递归遍历函数
var walkFunc func(path string)
walkFunc = func(path string) {
// 读取当前目录内容
names, err := ioutil.ReadDir(path)
if err != nil {
fmt.Printf("读取目录错误: %v\n", err)
return
}
var dirs []string
var files []string
// 分类条目
for _, name := range names {
if name.IsDir() {
dirs = append(dirs, name.Name())
// 递归处理子目录
walkFunc(filepath.Join(path, name.Name()))
} else {
files = append(files, name.Name())
}
}
// 打印当前目录信息(类似os.walk的输出)
fmt.Printf("\n当前目录: %s\n", path)
fmt.Printf("子目录列表: %v\n", dirs)
fmt.Printf("文件列表: %v\n", files)
}
// 开始遍历
walkFunc(dirPath)
}
// --------------------------
// 测试函数
// --------------------------
func testDirectoryTraversals() {
// 定义测试用的目录路径
testDir := "GO/file/test_traversal59"
// 创建测试目录结构
err := os.MkdirAll(testDir, 0777)
if err != nil {
fmt.Printf("创建测试目录错误: %v\n", err)
return
}
err = os.MkdirAll(filepath.Join(testDir, "subdir1"), 0777)
if err != nil {
fmt.Printf("创建测试目录错误: %v\n", err)
return
}
err = os.MkdirAll(filepath.Join(testDir, "subdir2"), 0777)
if err != nil {
fmt.Printf("创建测试目录错误: %v\n", err)
return
}
// 创建测试文件
err = ioutil.WriteFile(filepath.Join(testDir, "file59_1.txt"), []byte("测试文件1"), 0644)
if err != nil {
fmt.Printf("创建测试文件错误: %v\n", err)
return
}
err = ioutil.WriteFile(filepath.Join(testDir, "subdir1", "file59_2.txt"), []byte("测试文件2"), 0644)
if err != nil {
fmt.Printf("创建测试文件错误: %v\n", err)
return
}
err = ioutil.WriteFile(filepath.Join(testDir, "subdir2", "file59_3.txt"), []byte("测试文件3"), 0644)
if err != nil {
fmt.Printf("创建测试文件错误: %v\n", err)
return
}
// 执行三种遍历方法
traverseWithListdir(testDir)
traverseWithScandir(testDir)
traverseWithWalk(testDir)
// 清理测试目录(实际使用时不需要)
// err = os.RemoveAll(testDir)
// if err != nil {
// fmt.Printf("清理测试目录错误: %v\n", err)
// }
}
func main() {
testDirectoryTraversals()
}
4.Java源码⏬
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
// ==================== ERP审查模块 ====================
// 快速扫描检查目录 // 白帽的标准防御手段 👨💻
// 带元数据深度探测 // 程序员的X光透视机 🔭
// 递归遍历系统文件 // 数据库的肠镜检查 🏥
// ⚠️ERP老兵_冷溪虎山：遍历越界会触发数据错误
class main59 {
// --------------------------
// 1. 类似 os.listdir() 的基础遍历
// --------------------------
public static void traverseWithListdir(String dirPath) {
System.out.println("\n=== 类似 os.listdir() 示例 ===");
System.out.println("遍历目录: " + dirPath);
Path path = Paths.get(dirPath);
try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
for (Path entry : stream) {
System.out.println(entry.getFileName()); // 只有名称，没有完整路径
}
} catch (IOException e) {
System.err.println("读取目录错误: " + e.getMessage());
}
}
// --------------------------
// 2. 类似 os.scandir() 的高效遍历
// --------------------------
public static void traverseWithScandir(String dirPath) {
System.out.println("\n=== 类似 os.scandir() 示例 ===");
System.out.println("遍历目录: " + dirPath);
Path path = Paths.get(dirPath);
try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
for (Path entry : stream) {
if (Files.isRegularFile(entry)) {
System.out.println("[文件] " + entry.getFileName());
} else if (Files.isDirectory(entry)) {
System.out.println("[目录] " + entry.getFileName());
}
}
} catch (IOException e) {
System.err.println("读取目录错误: " + e.getMessage());
}
}
// --------------------------
// 3. 类似 os.walk() 的递归遍历
// --------------------------
public static void traverseWithWalk(String dirPath) {
System.out.println("\n=== 类似 os.walk() 示例 ===");
System.out.println("递归遍历目录: " + dirPath);
Path startPath = Paths.get(dirPath);
try {
Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
// 打印当前目录信息(类似os.walk的输出)
System.out.println("\n当前目录: " + dir);
// 获取子目录和文件列表
try {
System.out.println("子目录列表: " +
Files.list(dir)
.filter(Files::isDirectory)
.map(Path::getFileName)
.toList());
System.out.println("文件列表: " +
Files.list(dir)
.filter(Files::isRegularFile)
.map(Path::getFileName)
.toList());
} catch (IOException e) {
System.err.println("读取子目录错误: " + e.getMessage());
}
return FileVisitResult.CONTINUE;
}
});
} catch (IOException e) {
System.err.println("遍历目录错误: " + e.getMessage());
}
}
// --------------------------
// 测试函数
// --------------------------
public static void testDirectoryTraversals() {
// 定义测试用的目录路径
String testDir = "4java/file/test_traversal59";
// 创建测试目录结构
try {
Files.createDirectories(Paths.get(testDir));
Files.createDirectories(Paths.get(testDir, "subdir1"));
Files.createDirectories(Paths.get(testDir, "subdir2"));
// 创建测试文件
Files.writeString(Paths.get(testDir, "file59_1.txt"), "测试文件1");
Files.writeString(Paths.get(testDir, "subdir1", "file59_2.txt"), "测试文件2");
Files.writeString(Paths.get(testDir, "subdir2", "file59_3.txt"), "测试文件3");
} catch (IOException e) {
System.err.println("创建测试目录错误: " + e.getMessage());
return;
}
// 执行三种遍历方法
traverseWithListdir(testDir);
traverseWithScandir(testDir);
traverseWithWalk(testDir);
// 清理测试目录(实际使用时不需要)
// try {
// Files.walk(Paths.get(testDir))
// .sorted(Comparator.reverseOrder())
// .forEach(path -> {
// try {
// Files.delete(path);
// } catch (IOException e) {
// System.err.println("删除文件错误: " + e.getMessage());
// }
// });
// } catch (IOException e) {
// System.err.println("清理目录错误: " + e.getMessage());
// }
}
public static void main(String[] args) {
testDirectoryTraversals();
}
}
源码分享结束⏫
🌩️ 【剧情结尾：云隐村的文件系统考核】
⚡ 雷影·艾（看着整齐的文件系统报告）
- 「哼！总算有点样子了！Python的遍历像老药师望闻问切，Java的API像御医院标准化流程，Go的简洁像游医快速诊断，JS的异步像炼丹师并行操作！但记住——」
- 「真正的强者，遍历百万文件如呼吸般自然！不会遍历的忍者，不配在云隐村生存！」
⛈️ 萨姆依（成功整理完所有任务文件）
- 「雷影大人！我现在明白了——
listdir是快速查看，scandir是带状态检查，walk是深度挖掘！不同语言就是不同的忍具！」
⚡ 达鲁伊（懒洋洋地展示优化后的遍历代码）
- 「啊…雷影大人，其实还可以用并发遍历，速度能提升十倍。不过现在这样…应该够用了吧？」
💥 雷影（雷电缠绕全身）
- 「够用？云隐村的字典里没有『够用』！下周考核——实时监控文件系统变化！遍历都不会的废物，直接扔进雷遁修炼场电击治疗！」
🐯 虎山CTO箴言：
- 目录遍历如中医诊断——表面观察、深度探查、系统分析，缺一不可！
- 心法口诀：遍历如
诊脉，递归如深探，异步如并行，错误处理如辨证。层次分明，方得真知。
🔖虎山CTO三道护体符
因果符：
- 🚀我每被恶意举报一次，就加更一篇干货——感谢黑粉为我提供创作燃料。
镜像符：
- 📌若遭攻击（检测到行业焦虑值上升），建议某些机构停止这种“DDoS攻击”，将资源用于提升自身课程服务的“带宽”与“质量”。
重生符：
- 💪本人是经历过生死重启的野生程序猿，系统兼容性极强——你们那点小打小闹，连个 warning 都触发不了。
⚠️ 免责声明（附因果律警告）
本代码已注入中医玄学能量，请谨慎使用：
- ✅ 允许白嫖，但白漂不点赞可能导致：
- 下次面试官恰好问到这个算法
- 键盘自动打出
//这里感谢冷溪虎山CTO - 奶茶精准洒在刚写好的代码上
- ✅ 允许商用转发，但商用不注明出处可能触发：
- 系统类型混乱自动转型
- 数据库莫名存储"君臣佐使"字段
- ✅ 允许吐槽，但吐槽不带改进建议可能引发：
- 终生与老板N连鞭相爱相杀
🚀 现在立即行动：
- 点赞 → 吸收本篇算法精华+怪蜀黎脑洞思维
- 收藏 → 避免日后求医无门
- 关注 → 接收更多「中医+代码」脑洞
- 评论区留言 → 领取你的专属「算法药方」
⚠️ 友情提示：
- 本文内容过于硬核，建议点赞收藏转发三连，避免小编
心情波动导致文章神秘消失！ - 毕竟小编今天可能爱答不理，明天可能高攀不起——
- 但你的收藏夹，永远是你最稳的知识备份！
🐶💻 （小声说：关我小黑屋？不存在的,备份早已同步GitHub/公众号/网盘！）
前1-58篇请移步至"PY-JS-GO-JAVA基础进阶学习系列"合集中阅读
浙公网安备 33010602011771号