java --> ( 难度等级: [0, 1) || 挂载数据: 无 ) 
├── java初阶 --> ( 难度等级: [0.0, 0.25) || 挂载数据: 无 ) 
│   ├── Java的历史和演变 --> ( 难度等级: [0.0, 0.0156) || 挂载数据: 无 ) 
│   │   ├── Java的家世 --> ( 难度等级: [0.0, 0.0017) || 挂载数据: 无 ) 
│   │   │   ├── 现代编程语言的诞生：C语言 --> ( 难度等级: [0.0, 0.0006) || 挂载数据: qa: 1 ) 
│   │   │   ├── C++：下一个阶段 --> ( 难度等级: [0.0006, 0.0012) || 挂载数据: qa: 5 ) 
│   │   │   └── Java出现的时机已经成熟 --> ( 难度等级: [0.0012, 0.0017) || 挂载数据: 无 ) 
│   │   ├── Java的诞生 --> ( 难度等级: [0.0017, 0.0035) || 挂载数据: 无 ) 
│   │   ├── Java改变Internet的方式 --> ( 难度等级: [0.0035, 0.0052) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java applet --> ( 难度等级: [0.0035, 0.0041) || 挂载数据: 无 ) 
│   │   │   ├── 安全性 --> ( 难度等级: [0.0041, 0.0046) || 挂载数据: 无 ) 
│   │   │   └── 可移植性 --> ( 难度等级: [0.0046, 0.0052) || 挂载数据: 无 ) 
│   │   ├── Java的魔力：字节码 --> ( 难度等级: [0.0052, 0.0069) || 挂载数据: 无 ) 
│   │   ├── servlet：服务器端的Java --> ( 难度等级: [0.0069, 0.0087) || 挂载数据: 无 ) 
│   │   ├── Java的关键特性 --> ( 难度等级: [0.0087, 0.0104) || 挂载数据: 无 ) 
│   │   │   ├── 简单性 --> ( 难度等级: [0.0087, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   ├── 面向对象 --> ( 难度等级: [0.0089, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象概述 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   └── 面向对象程序设计的特点 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── Java中的类与对象 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 类的定义 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 9 ) 
│   │   │   │   │   ├── 对象的创建与使用 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── 存储到什么地方 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 3 ) 
│   │   │   │   │   │   └── Java中的数组 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── 访问控制符 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── String类与StringBuffer类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── String类的初始化 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── String类的常见操作 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── StringBuffer类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 4 ) 
│   │   │   │   │   │   ├── 声明字符串 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   └── 创建字符串 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── System类与Runtime类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── System类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   └── Runtime类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── Math类与Random类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Math类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── Random类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 5 ) 
│   │   │   │   │   │   ├── Math类概述 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 常用数学运算方法 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 包装类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Integer类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── Number类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── Integer --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 4 ) 
│   │   │   │   │   │   ├── Boolean --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 7 ) 
│   │   │   │   │   │   ├── Character --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   └── Number --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 日期与时间类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Date类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── Calendar类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   └── JDK 8的日期与时间类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 格式化类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── DateFormat类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── SimpleDateFormat类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── DateTimeFormatter类 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用引用操纵对象 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 永远不需要销毁对象 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 作用域 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 对象的作用域 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 构建一个Java程序 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 名字可见性 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 运用其他构件 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 编码风格 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 访问对象的属性和行为 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 对象的引用 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 8 ) 
│   │   │   │   │   ├── 对象的销毁 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 打印对象和toString方法 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   └── ==和equals方法 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── 类的封装 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   │   └── 如何实现封装 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 构造方法 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 构造方法的定义 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 5 ) 
│   │   │   │   │   └── 构造方法的重载 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   ├── static关键字 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 静态变量 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 静态方法 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 静态代码块 --> ( 难度等级: [0.0089, 0.0089) || 挂载数据: qa: 5 ) 
│   │   │   │   ├── 类的继承 --> ( 难度等级: [0.0089, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 继承的概念 --> ( 难度等级: [0.0089, 0.009) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 重写父类方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── extends关键字 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── 所有类的父类——Object类 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── 重写父类的方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── super限定 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   └── 调用父类构造器 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── final关键字 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰类 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰变量 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── final数据 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final类 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   └── 有关final的忠告 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 多态 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 多态概述 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 对象的类型转换 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 转机 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 方法调用绑定 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 产生正确的行为 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 可扩展性 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 缺陷：“覆盖”私有方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 多态性 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 引用变量的强制类型转换 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── JDK 8的Lambda表达式 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   └── Lambda表达式入门 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构化程序设计简介 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 程序的三种基本结构 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象程序设计简介 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象的基本特征 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   ├── 方法详解 --> ( 难度等级: [0.009, 0.009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 方法的所属性 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 方法的参数传递机制 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 形参个数可变的方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 递归方法 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 类成员 --> ( 难度等级: [0.009, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解类成员 --> ( 难度等级: [0.009, 0.009) || 挂载数据: qa: 8 ) 
│   │   │   │   │   └── 单例（Singleton）类 --> ( 难度等级: [0.009, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── final修饰符 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final成员变量 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── final局部变量 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 7 ) 
│   │   │   │   │   ├── final修饰基本类型变量和引用类型变量的区别 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── 可执行“宏替换”的final变量 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 不可变类 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── Java 9改进的接口 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接口的概念 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Java 9中接口的定义 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接口的继承 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 4 ) 
│   │   │   │   │   └── 面向接口编程 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── Java 11增强的Lambda表达式 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Lambda表达式中使用var --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Lambda表达式调用Arrays的类方法 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── 枚举类 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 手动实现枚举类 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 枚举类入门 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 实现接口的枚举类 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 3 ) 
│   │   │   │   │   └── 包含抽象方法的枚举类 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   ├── 修饰符的适用范围 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │   └── 多版本JAR包 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: 无 ) 
│   │   │   │       ├── jar命令详解 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 10 ) 
│   │   │   │       ├── 创建可执行的JAR包 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 4 ) 
│   │   │   │       └── 关于JAR包的技巧 --> ( 难度等级: [0.0091, 0.0091) || 挂载数据: qa: 10 ) 
│   │   │   ├── 健壮性 --> ( 难度等级: [0.0091, 0.0093) || 挂载数据: 无 ) 
│   │   │   ├── 多线程 --> ( 难度等级: [0.0093, 0.0095) || 挂载数据: qa: 10 ) 
│   │   │   ├── 体系结构中立 --> ( 难度等级: [0.0095, 0.0098) || 挂载数据: 无 ) 
│   │   │   ├── 解释执行和高性能 --> ( 难度等级: [0.0098, 0.01) || 挂载数据: 无 ) 
│   │   │   ├── 分布式 --> ( 难度等级: [0.01, 0.0102) || 挂载数据: qa: 1 ) 
│   │   │   └── 动态性 --> ( 难度等级: [0.0102, 0.0104) || 挂载数据: 无 ) 
│   │   ├── Java的演变历程 --> ( 难度等级: [0.0104, 0.0122) || 挂载数据: 无 ) 
│   │   ├── Java SE 8 --> ( 难度等级: [0.0122, 0.0139) || 挂载数据: qa: 4 ) 
│   │   └── 文化革新 --> ( 难度等级: [0.0139, 0.0156) || 挂载数据: 无 ) 
│   ├── Java综述 --> ( 难度等级: [0.0156, 0.0312) || 挂载数据: 无 ) 
│   │   ├── 面向对象编程 --> ( 难度等级: [0.0156, 0.0182) || 挂载数据: qa: 1 ) 
│   │   │   ├── 两种范式 --> ( 难度等级: [0.0156, 0.0161) || 挂载数据: 无 ) 
│   │   │   ├── 抽象 --> ( 难度等级: [0.0161, 0.0167) || 挂载数据: 无 ) 
│   │   │   ├── OOP三原则 --> ( 难度等级: [0.0167, 0.0172) || 挂载数据: 无 ) 
│   │   │   ├── 面向对象基础 --> ( 难度等级: [0.0172, 0.0177) || 挂载数据: 无 ) 
│   │   │   │   └── 模块 --> ( 难度等级: [0.0172, 0.0177) || 挂载数据: 无 ) 
│   │   │   └── Java核心类 --> ( 难度等级: [0.0177, 0.0182) || 挂载数据: 无 ) 
│   │   │       ├── StringJoiner --> ( 难度等级: [0.0177, 0.0179) || 挂载数据: 无 ) 
│   │   │       ├── 包装类型 --> ( 难度等级: [0.0179, 0.0181) || 挂载数据: qa: 1 ) 
│   │   │       └── 记录类 --> ( 难度等级: [0.0181, 0.0182) || 挂载数据: 无 ) 
│   │   ├── 第一个简单程序 --> ( 难度等级: [0.0182, 0.0208) || 挂载数据: qa: 2 ) 
│   │   │   ├── 输入程序 --> ( 难度等级: [0.0182, 0.0191) || 挂载数据: qa: 10 ) 
│   │   │   ├── 编译程序 --> ( 难度等级: [0.0191, 0.02) || 挂载数据: 无 ) 
│   │   │   └── 深入分析第一个示例程序 --> ( 难度等级: [0.02, 0.0208) || 挂载数据: qa: 1 ) 
│   │   ├── 第二个简短程序 --> ( 难度等级: [0.0208, 0.0234) || 挂载数据: 无 ) 
│   │   ├── 两种控制语句 --> ( 难度等级: [0.0234, 0.026) || 挂载数据: 无 ) 
│   │   │   ├── if语句 --> ( 难度等级: [0.0234, 0.0247) || 挂载数据: qa: 2 ) 
│   │   │   └── for循环 --> ( 难度等级: [0.0247, 0.026) || 挂载数据: qa: 10 ) 
│   │   ├── 使用代码块 --> ( 难度等级: [0.026, 0.0286) || 挂载数据: 无 ) 
│   │   └── Java类库 --> ( 难度等级: [0.0286, 0.0312) || 挂载数据: 无 ) 
│   ├── 数据类型、变量和数组 --> ( 难度等级: [0.0312, 0.0469) || 挂载数据: 无 ) 
│   │   ├── Java是强类型化的语言 --> ( 难度等级: [0.0312, 0.0317) || 挂载数据: 无 ) 
│   │   ├── 基本类型 --> ( 难度等级: [0.0317, 0.0321) || 挂载数据: 无 ) 
│   │   ├── 整型 --> ( 难度等级: [0.0321, 0.0325) || 挂载数据: 无 ) 
│   │   │   ├── byte --> ( 难度等级: [0.0321, 0.0322) || 挂载数据: qa: 10 ) 
│   │   │   ├── short --> ( 难度等级: [0.0322, 0.0323) || 挂载数据: qa: 1 ) 
│   │   │   ├── int --> ( 难度等级: [0.0323, 0.0324) || 挂载数据: qa: 10 ) 
│   │   │   └── long --> ( 难度等级: [0.0324, 0.0325) || 挂载数据: qa: 7 ) 
│   │   ├── 浮点型 --> ( 难度等级: [0.0325, 0.0329) || 挂载数据: 无 ) 
│   │   │   ├── float --> ( 难度等级: [0.0325, 0.0327) || 挂载数据: 无 ) 
│   │   │   └── double --> ( 难度等级: [0.0327, 0.0329) || 挂载数据: qa: 6 ) 
│   │   ├── 字符型 --> ( 难度等级: [0.0329, 0.0333) || 挂载数据: qa: 1 ) 
│   │   ├── 布尔型 --> ( 难度等级: [0.0333, 0.0337) || 挂载数据: 无 ) 
│   │   ├── 深入分析字面值 --> ( 难度等级: [0.0337, 0.0341) || 挂载数据: 无 ) 
│   │   │   ├── 整型字面值 --> ( 难度等级: [0.0337, 0.0338) || 挂载数据: qa: 2 ) 
│   │   │   ├── 浮点型字面值 --> ( 难度等级: [0.0338, 0.0339) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型字面值 --> ( 难度等级: [0.0339, 0.034) || 挂载数据: 无 ) 
│   │   │   ├── 字符型字面值 --> ( 难度等级: [0.034, 0.034) || 挂载数据: qa: 1 ) 
│   │   │   └── 字符串字面值 --> ( 难度等级: [0.034, 0.0341) || 挂载数据: 无 ) 
│   │   ├── 变量 --> ( 难度等级: [0.0341, 0.0345) || 挂载数据: 无 ) 
│   │   │   ├── 变量的声明 --> ( 难度等级: [0.0341, 0.0343) || 挂载数据: qa: 1 ) 
│   │   │   ├── 动态初始化 --> ( 难度等级: [0.0343, 0.0344) || 挂载数据: 无 ) 
│   │   │   └── 变量的作用域和生存期 --> ( 难度等级: [0.0344, 0.0345) || 挂载数据: 无 ) 
│   │   ├── 类型转换和强制类型转换 --> ( 难度等级: [0.0345, 0.035) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java的自动类型转换 --> ( 难度等级: [0.0345, 0.0347) || 挂载数据: 无 ) 
│   │   │   └── 强制转换不兼容的类型 --> ( 难度等级: [0.0347, 0.035) || 挂载数据: qa: 4 ) 
│   │   ├── 表达式中的自动类型提升 --> ( 难度等级: [0.035, 0.0354) || 挂载数据: 无 ) 
│   │   ├── 数组 --> ( 难度等级: [0.0354, 0.0358) || 挂载数据: 无 ) 
│   │   │   ├── 一维数组 --> ( 难度等级: [0.0354, 0.0355) || 挂载数据: qa: 10 ) 
│   │   │   ├── 多维数组 --> ( 难度等级: [0.0355, 0.0356) || 挂载数据: 无 ) 
│   │   │   └── 另一种数组声明语法 --> ( 难度等级: [0.0356, 0.0358) || 挂载数据: qa: 1 ) 
│   │   ├── 关于字符串的一些说明 --> ( 难度等级: [0.0358, 0.0362) || 挂载数据: qa: 1 ) 
│   │   │   ├── 字符串的连接 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接字符串 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 连接其他数据类型 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 10 ) 
│   │   │   ├── 提取字符串信息 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取字符串长度 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 获取指定位置的字符 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 获取子字符串索引位置 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 判断字符串首尾内容 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 9 ) 
│   │   │   │   ├── 获取字符数组 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 判断子字符串是否存在 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   ├── 字符串的操作 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 截取字符串 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 字符串替换 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 字符串分割 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 大小写转换 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 去除空白内容 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 比较字符串是否相等 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取子字符串 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 去除空格 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 判断字符串的开始与结尾 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 按字典顺序比较两个字符串 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   │   └── 字母大小写转换 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   ├── 可变字符串StringBuffer类 --> ( 难度等级: [0.0358, 0.0358) || 挂载数据: 无 ) 
│   │   │   ├── 不可变String --> ( 难度等级: [0.0358, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── 重载"+"与StringBuilder --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 1 ) 
│   │   │   ├── 无意识的递归 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── String上的操作 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── 格式化输出 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── printf（） --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── System.out.format（） --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── Formatter类 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── 格式化说明符 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── Formatter转换 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   └── String.format（） --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 2 ) 
│   │   │   ├── 正则表达式 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 基础 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── 创建正则表达式 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 限定符 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── Pattern和Matcher --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── split（） --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 替换操作 --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   │   ├── reset（） --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 正则表达式与Java I/O --> ( 难度等级: [0.0359, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── 扫描输入 --> ( 难度等级: [0.0359, 0.036) || 挂载数据: 无 ) 
│   │   │   │   ├── Scanner定界符 --> ( 难度等级: [0.0359, 0.036) || 挂载数据: 无 ) 
│   │   │   │   └── 用正则表达式扫描 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── StringTokenizer --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── 获取字符串信息 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串查找 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   │   └── 获取指定索引位置的字符 --> ( 难度等级: [0.036, 0.036) || 挂载数据: qa: 10 ) 
│   │   │   ├── 格式化字符串 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   │   └── 常规类型格式化 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── 字符串生成器 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── 子串 --> ( 难度等级: [0.036, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── 拼接 --> ( 难度等级: [0.036, 0.0361) || 挂载数据: 无 ) 
│   │   │   ├── 不可变字符串 --> ( 难度等级: [0.0361, 0.0361) || 挂载数据: 无 ) 
│   │   │   ├── 检测字符串是否相等 --> ( 难度等级: [0.0361, 0.0361) || 挂载数据: qa: 2 ) 
│   │   │   ├── 空串与Null串 --> ( 难度等级: [0.0361, 0.0361) || 挂载数据: 无 ) 
│   │   │   ├── 码点与代码单元 --> ( 难度等级: [0.0361, 0.0361) || 挂载数据: 无 ) 
│   │   │   ├── String API --> ( 难度等级: [0.0361, 0.0361) || 挂载数据: 无 ) 
│   │   │   ├── 阅读联机API文档 --> ( 难度等级: [0.0361, 0.0362) || 挂载数据: qa: 2 ) 
│   │   │   └── 构建字符串 --> ( 难度等级: [0.0362, 0.0362) || 挂载数据: 无 ) 
│   │   ├── 向C/C++程序员提供指针方面的说明 --> ( 难度等级: [0.0362, 0.0366) || 挂载数据: qa: 6 ) 
│   │   ├── 数组的定义 --> ( 难度等级: [0.0366, 0.037) || 挂载数据: qa: 3 ) 
│   │   ├── 数组的常见操作 --> ( 难度等级: [0.037, 0.0374) || 挂载数据: 无 ) 
│   │   ├── 数组的概述 --> ( 难度等级: [0.0374, 0.0378) || 挂载数据: 无 ) 
│   │   ├── 创建一维数组 --> ( 难度等级: [0.0378, 0.0382) || 挂载数据: 无 ) 
│   │   ├── 给一维数组赋值 --> ( 难度等级: [0.0382, 0.0387) || 挂载数据: qa: 5 ) 
│   │   ├── 获取数组长度 --> ( 难度等级: [0.0387, 0.0391) || 挂载数据: qa: 1 ) 
│   │   ├── 一维数组的使用场景 --> ( 难度等级: [0.0391, 0.0395) || 挂载数据: qa: 1 ) 
│   │   ├── 不规则数组 --> ( 难度等级: [0.0395, 0.0399) || 挂载数据: 无 ) 
│   │   ├── 数组的基本操作 --> ( 难度等级: [0.0399, 0.0403) || 挂载数据: 无 ) 
│   │   │   ├── 遍历数组 --> ( 难度等级: [0.0399, 0.04) || 挂载数据: qa: 4 ) 
│   │   │   ├── 填充和批量替换数组元素 --> ( 难度等级: [0.04, 0.04) || 挂载数据: 无 ) 
│   │   │   ├── 填充替换数组元素 --> ( 难度等级: [0.04, 0.0401) || 挂载数据: qa: 4 ) 
│   │   │   ├── 对数组进行排序 --> ( 难度等级: [0.0401, 0.0402) || 挂载数据: 无 ) 
│   │   │   └── 数组查询 --> ( 难度等级: [0.0402, 0.0403) || 挂载数据: qa: 2 ) 
│   │   ├── 数组是第一级对象 --> ( 难度等级: [0.0403, 0.0407) || 挂载数据: 无 ) 
│   │   ├── 返回一个数组 --> ( 难度等级: [0.0407, 0.0411) || 挂载数据: qa: 2 ) 
│   │   ├── 创建测试数据 --> ( 难度等级: [0.0411, 0.0415) || 挂载数据: 无 ) 
│   │   │   ├── Arrays.fill（） --> ( 难度等级: [0.0411, 0.0413) || 挂载数据: qa: 1 ) 
│   │   │   ├── 数据生成器（Generator） --> ( 难度等级: [0.0413, 0.0414) || 挂载数据: 无 ) 
│   │   │   └── 从Generator中创建数组 --> ( 难度等级: [0.0414, 0.0415) || 挂载数据: qa: 5 ) 
│   │   ├── Arrays实用功能 --> ( 难度等级: [0.0415, 0.0419) || 挂载数据: 无 ) 
│   │   │   ├── 复制数组 --> ( 难度等级: [0.0415, 0.0416) || 挂载数据: 无 ) 
│   │   │   ├── 数组元素的比较 --> ( 难度等级: [0.0416, 0.0417) || 挂载数据: qa: 3 ) 
│   │   │   ├── 数组排序 --> ( 难度等级: [0.0417, 0.0418) || 挂载数据: qa: 4 ) 
│   │   │   └── 在已排序的数组中查找 --> ( 难度等级: [0.0418, 0.0419) || 挂载数据: qa: 1 ) 
│   │   ├── 数组排序算法 --> ( 难度等级: [0.0419, 0.0424) || 挂载数据: 无 ) 
│   │   │   ├── 冒泡排序 --> ( 难度等级: [0.0419, 0.0421) || 挂载数据: qa: 4 ) 
│   │   │   ├── 直接选择排序 --> ( 难度等级: [0.0421, 0.0422) || 挂载数据: qa: 4 ) 
│   │   │   └── 反转排序 --> ( 难度等级: [0.0422, 0.0424) || 挂载数据: qa: 3 ) 
│   │   ├── 内存中的数组 --> ( 难度等级: [0.0424, 0.0428) || 挂载数据: qa: 2 ) 
│   │   ├── 基本类型数组的初始化 --> ( 难度等级: [0.0428, 0.0432) || 挂载数据: 无 ) 
│   │   ├── 引用类型数组的初始化 --> ( 难度等级: [0.0432, 0.0436) || 挂载数据: 无 ) 
│   │   ├── 操作数组的工具类：Arrays --> ( 难度等级: [0.0436, 0.044) || 挂载数据: 无 ) 
│   │   ├── 数组应用举例 --> ( 难度等级: [0.044, 0.0444) || 挂载数据: 无 ) 
│   │   ├── char类型 --> ( 难度等级: [0.0444, 0.0448) || 挂载数据: qa: 10 ) 
│   │   ├── boolean类型 --> ( 难度等级: [0.0448, 0.0452) || 挂载数据: 无 ) 
│   │   ├── 声明数组 --> ( 难度等级: [0.0452, 0.0456) || 挂载数据: 无 ) 
│   │   ├── 访问数组元素 --> ( 难度等级: [0.0456, 0.0461) || 挂载数据: 无 ) 
│   │   ├── for each循环 --> ( 难度等级: [0.0461, 0.0465) || 挂载数据: 无 ) 
│   │   └── 数组拷贝 --> ( 难度等级: [0.0465, 0.0469) || 挂载数据: 无 ) 
│   ├── 运算符 --> ( 难度等级: [0.0469, 0.0625) || 挂载数据: 无 ) 
│   │   ├── 算术运算符 --> ( 难度等级: [0.0469, 0.0479) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基本算术运算符 --> ( 难度等级: [0.0469, 0.0471) || 挂载数据: qa: 1 ) 
│   │   │   ├── 求模运算符 --> ( 难度等级: [0.0471, 0.0474) || 挂载数据: 无 ) 
│   │   │   ├── 算术与赋值复合运算符 --> ( 难度等级: [0.0474, 0.0477) || 挂载数据: 无 ) 
│   │   │   └── 自增与自减运算符 --> ( 难度等级: [0.0477, 0.0479) || 挂载数据: 无 ) 
│   │   ├── 位运算符 --> ( 难度等级: [0.0479, 0.049) || 挂载数据: 无 ) 
│   │   │   ├── 位逻辑运算符 --> ( 难度等级: [0.0479, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 左移 --> ( 难度等级: [0.0481, 0.0483) || 挂载数据: 无 ) 
│   │   │   ├── 右移 --> ( 难度等级: [0.0483, 0.0485) || 挂载数据: 无 ) 
│   │   │   ├── 无符号右移 --> ( 难度等级: [0.0485, 0.0488) || 挂载数据: qa: 4 ) 
│   │   │   └── 位运算符与赋值的组合 --> ( 难度等级: [0.0488, 0.049) || 挂载数据: qa: 9 ) 
│   │   ├── 关系运算符 --> ( 难度等级: [0.049, 0.05) || 挂载数据: 无 ) 
│   │   ├── 布尔逻辑运算符 --> ( 难度等级: [0.05, 0.051) || 挂载数据: 无 ) 
│   │   ├── 赋值运算符 --> ( 难度等级: [0.051, 0.0521) || 挂载数据: 无 ) 
│   │   ├── “?”运算符 --> ( 难度等级: [0.0521, 0.0531) || 挂载数据: qa: 3 ) 
│   │   ├── 运算符的优先级 --> ( 难度等级: [0.0531, 0.0542) || 挂载数据: qa: 1 ) 
│   │   ├── 使用圆括号 --> ( 难度等级: [0.0542, 0.0552) || 挂载数据: 无 ) 
│   │   ├── 自增和自减运算符 --> ( 难度等级: [0.0552, 0.0563) || 挂载数据: 无 ) 
│   │   ├── 复合赋值运算符 --> ( 难度等级: [0.0563, 0.0573) || 挂载数据: 无 ) 
│   │   ├── 扩展后的赋值运算符 --> ( 难度等级: [0.0573, 0.0583) || 挂载数据: 无 ) 
│   │   ├── 三目运算符 --> ( 难度等级: [0.0583, 0.0594) || 挂载数据: qa: 3 ) 
│   │   ├── 数值类型之间的转换 --> ( 难度等级: [0.0594, 0.0604) || 挂载数据: 无 ) 
│   │   ├── 关系和boolean运算符 --> ( 难度等级: [0.0604, 0.0615) || 挂载数据: 无 ) 
│   │   └── 括号与运算符级别 --> ( 难度等级: [0.0615, 0.0625) || 挂载数据: qa: 2 ) 
│   ├── 控制语句 --> ( 难度等级: [0.0625, 0.0781) || 挂载数据: 无 ) 
│   │   ├── Java的选择语句 --> ( 难度等级: [0.0625, 0.0677) || 挂载数据: 无 ) 
│   │   │   ├── if语句 --> ( 难度等级: [0.0625, 0.0651) || 挂载数据: 无 ) 
│   │   │   └── switch语句 --> ( 难度等级: [0.0651, 0.0677) || 挂载数据: qa: 5 ) 
│   │   ├── 迭代语句 --> ( 难度等级: [0.0677, 0.0729) || 挂载数据: 无 ) 
│   │   │   ├── while语句 --> ( 难度等级: [0.0677, 0.0687) || 挂载数据: qa: 1 ) 
│   │   │   ├── do-while语句 --> ( 难度等级: [0.0687, 0.0698) || 挂载数据: 无 ) 
│   │   │   ├── for语句 --> ( 难度等级: [0.0698, 0.0708) || 挂载数据: qa: 1 ) 
│   │   │   ├── for循环的for-each版本 --> ( 难度等级: [0.0708, 0.0719) || 挂载数据: 无 ) 
│   │   │   └── 嵌套的循环 --> ( 难度等级: [0.0719, 0.0729) || 挂载数据: 无 ) 
│   │   └── 跳转语句 --> ( 难度等级: [0.0729, 0.0781) || 挂载数据: qa: 5 ) 
│   │       ├── 使用break语句 --> ( 难度等级: [0.0729, 0.0747) || 挂载数据: qa: 2 ) 
│   │       ├── 使用continue语句 --> ( 难度等级: [0.0747, 0.0764) || 挂载数据: 无 ) 
│   │       └── return语句 --> ( 难度等级: [0.0764, 0.0781) || 挂载数据: qa: 10 ) 
│   ├── 类 --> ( 难度等级: [0.0781, 0.0938) || 挂载数据: qa: 4 ) 
│   │   ├── 类的基础知识 --> ( 难度等级: [0.0781, 0.0791) || 挂载数据: 无 ) 
│   │   │   ├── 类的一般形式 --> ( 难度等级: [0.0781, 0.0786) || 挂载数据: qa: 1 ) 
│   │   │   └── 一个简单的类 --> ( 难度等级: [0.0786, 0.0791) || 挂载数据: 无 ) 
│   │   ├── 声明对象 --> ( 难度等级: [0.0791, 0.0801) || 挂载数据: 无 ) 
│   │   ├── 为对象引用变量赋值 --> ( 难度等级: [0.0801, 0.0811) || 挂载数据: 无 ) 
│   │   ├── 方法 --> ( 难度等级: [0.0811, 0.082) || 挂载数据: 无 ) 
│   │   │   ├── 为Box类添加方法 --> ( 难度等级: [0.0811, 0.0814) || 挂载数据: 无 ) 
│   │   │   ├── 返回值 --> ( 难度等级: [0.0814, 0.0817) || 挂载数据: qa: 2 ) 
│   │   │   └── 添加带参数的方法 --> ( 难度等级: [0.0817, 0.082) || 挂载数据: 无 ) 
│   │   ├── 构造函数 --> ( 难度等级: [0.082, 0.083) || 挂载数据: qa: 1 ) 
│   │   ├── this关键字 --> ( 难度等级: [0.083, 0.084) || 挂载数据: qa: 3 ) 
│   │   │   ├── 在构造器中调用构造器 --> ( 难度等级: [0.083, 0.0835) || 挂载数据: 无 ) 
│   │   │   └── static的含义 --> ( 难度等级: [0.0835, 0.084) || 挂载数据: qa: 2 ) 
│   │   ├── 垃圾回收 --> ( 难度等级: [0.084, 0.085) || 挂载数据: qa: 1 ) 
│   │   ├── finalize方法 --> ( 难度等级: [0.085, 0.0859) || 挂载数据: 无 ) 
│   │   ├── 堆栈类 --> ( 难度等级: [0.0859, 0.0869) || 挂载数据: qa: 2 ) 
│   │   ├── 基本成员默认值 --> ( 难度等级: [0.0869, 0.0879) || 挂载数据: 无 ) 
│   │   ├── 成员变量 --> ( 难度等级: [0.0879, 0.0889) || 挂载数据: qa: 2 ) 
│   │   ├── 成员方法 --> ( 难度等级: [0.0889, 0.0898) || 挂载数据: qa: 1 ) 
│   │   ├── 权限修饰符 --> ( 难度等级: [0.0898, 0.0908) || 挂载数据: qa: 1 ) 
│   │   ├── 操作对象的Objects工具类 --> ( 难度等级: [0.0908, 0.0918) || 挂载数据: qa: 1 ) 
│   │   ├── ThreadLocalRandom与Random --> ( 难度等级: [0.0918, 0.0928) || 挂载数据: 无 ) 
│   │   └── BigDecimal类 --> ( 难度等级: [0.0928, 0.0938) || 挂载数据: 无 ) 
│   ├── 方法和类的深入分析 --> ( 难度等级: [0.0938, 0.1094) || 挂载数据: 无 ) 
│   │   ├── 重载方法 --> ( 难度等级: [0.0938, 0.095) || 挂载数据: 无 ) 
│   │   │   ├── 区分重载方法 --> ( 难度等级: [0.0938, 0.0942) || 挂载数据: qa: 7 ) 
│   │   │   ├── 涉及基本类型的重载 --> ( 难度等级: [0.0942, 0.0946) || 挂载数据: 无 ) 
│   │   │   └── 以返回值区分重载方法 --> ( 难度等级: [0.0946, 0.095) || 挂载数据: qa: 1 ) 
│   │   ├── 将对象用作参数 --> ( 难度等级: [0.095, 0.0962) || 挂载数据: 无 ) 
│   │   ├── 参数传递的深入分析 --> ( 难度等级: [0.0962, 0.0974) || 挂载数据: 无 ) 
│   │   ├── 返回对象 --> ( 难度等级: [0.0974, 0.0986) || 挂载数据: 无 ) 
│   │   ├── 递归 --> ( 难度等级: [0.0986, 0.0998) || 挂载数据: qa: 4 ) 
│   │   ├── 访问控制 --> ( 难度等级: [0.0998, 0.101) || 挂载数据: 无 ) 
│   │   │   └── Java类包 --> ( 难度等级: [0.0998, 0.101) || 挂载数据: 无 ) 
│   │   │       ├── 类名冲突 --> ( 难度等级: [0.0998, 0.1002) || 挂载数据: 无 ) 
│   │   │       ├── 完整的类路径 --> ( 难度等级: [0.1002, 0.1006) || 挂载数据: 无 ) 
│   │   │       └── 创建包 --> ( 难度等级: [0.1006, 0.101) || 挂载数据: qa: 1 ) 
│   │   ├── 理解static --> ( 难度等级: [0.101, 0.1022) || 挂载数据: qa: 1 ) 
│   │   ├── final介绍 --> ( 难度等级: [0.1022, 0.1034) || 挂载数据: 无 ) 
│   │   ├── 重新审视数组 --> ( 难度等级: [0.1034, 0.1046) || 挂载数据: 无 ) 
│   │   ├── 嵌套类和内部类 --> ( 难度等级: [0.1046, 0.1058) || 挂载数据: 无 ) 
│   │   │   ├── 成员内部类 --> ( 难度等级: [0.1046, 0.1046) || 挂载数据: qa: 1 ) 
│   │   │   ├── 局部内部类 --> ( 难度等级: [0.1046, 0.1047) || 挂载数据: qa: 1 ) 
│   │   │   ├── 静态内部类 --> ( 难度等级: [0.1047, 0.1048) || 挂载数据: qa: 1 ) 
│   │   │   ├── 匿名内部类 --> ( 难度等级: [0.1048, 0.1049) || 挂载数据: qa: 7 ) 
│   │   │   │   └── 再访工厂方法 --> ( 难度等级: [0.1048, 0.1049) || 挂载数据: 无 ) 
│   │   │   ├── 创建内部类 --> ( 难度等级: [0.1049, 0.1049) || 挂载数据: qa: 2 ) 
│   │   │   ├── 链接到外部类 --> ( 难度等级: [0.1049, 0.105) || 挂载数据: qa: 3 ) 
│   │   │   ├── 使用.this与.new --> ( 难度等级: [0.105, 0.1051) || 挂载数据: qa: 10 ) 
│   │   │   ├── 接口内部的类 --> ( 难度等级: [0.1051, 0.1051) || 挂载数据: qa: 2 ) 
│   │   │   ├── 从多层嵌套类中访问外部类的成员 --> ( 难度等级: [0.1051, 0.1052) || 挂载数据: 无 ) 
│   │   │   ├── 内部类的继承 --> ( 难度等级: [0.1052, 0.1053) || 挂载数据: qa: 2 ) 
│   │   │   ├── 内部类可以被覆盖吗 --> ( 难度等级: [0.1053, 0.1053) || 挂载数据: qa: 6 ) 
│   │   │   ├── 内部类标识符 --> ( 难度等级: [0.1053, 0.1054) || 挂载数据: 无 ) 
│   │   │   ├── 非静态内部类 --> ( 难度等级: [0.1054, 0.1055) || 挂载数据: 无 ) 
│   │   │   ├── 使用内部类访问对象状态 --> ( 难度等级: [0.1055, 0.1056) || 挂载数据: qa: 2 ) 
│   │   │   ├── 内部类的特殊语法规则 --> ( 难度等级: [0.1056, 0.1056) || 挂载数据: 无 ) 
│   │   │   ├── 内部类是否有用、必要和 --> ( 难度等级: [0.1056, 0.1057) || 挂载数据: 无 ) 
│   │   │   └── 由外部方法访问变量 --> ( 难度等级: [0.1057, 0.1058) || 挂载数据: qa: 1 ) 
│   │   ├── String类介绍 --> ( 难度等级: [0.1058, 0.107) || 挂载数据: 无 ) 
│   │   ├── 使用命令行参数 --> ( 难度等级: [0.107, 0.1082) || 挂载数据: 无 ) 
│   │   └── varargs：可变长度参数 --> ( 难度等级: [0.1082, 0.1094) || 挂载数据: 无 ) 
│   │       ├── 重载varargs方法 --> ( 难度等级: [0.1082, 0.1088) || 挂载数据: 无 ) 
│   │       └── varargs方法与模糊性 --> ( 难度等级: [0.1088, 0.1094) || 挂载数据: 无 ) 
│   ├── 继承 --> ( 难度等级: [0.1094, 0.125) || 挂载数据: qa: 7 ) 
│   │   ├── 继承的基础知识 --> ( 难度等级: [0.1094, 0.1105) || 挂载数据: 无 ) 
│   │   │   ├── 成员访问与继承 --> ( 难度等级: [0.1094, 0.1097) || 挂载数据: 无 ) 
│   │   │   ├── 一个更实际的例子 --> ( 难度等级: [0.1097, 0.1101) || 挂载数据: 无 ) 
│   │   │   └── 超类变量可以引用子类对象 --> ( 难度等级: [0.1101, 0.1105) || 挂载数据: 无 ) 
│   │   ├── 使用super关键字 --> ( 难度等级: [0.1105, 0.1116) || 挂载数据: 无 ) 
│   │   │   ├── 使用super调用超类的构造函数 --> ( 难度等级: [0.1105, 0.111) || 挂载数据: qa: 5 ) 
│   │   │   └── super的另一种用法 --> ( 难度等级: [0.111, 0.1116) || 挂载数据: qa: 10 ) 
│   │   ├── 创建多级继承层次 --> ( 难度等级: [0.1116, 0.1127) || 挂载数据: 无 ) 
│   │   ├── 构造函数的调用时机 --> ( 难度等级: [0.1127, 0.1138) || 挂载数据: 无 ) 
│   │   ├── 方法重写 --> ( 难度等级: [0.1138, 0.115) || 挂载数据: 无 ) 
│   │   ├── 动态方法调度 --> ( 难度等级: [0.115, 0.1161) || 挂载数据: 无 ) 
│   │   │   ├── 重写方法的目的 --> ( 难度等级: [0.115, 0.1155) || 挂载数据: qa: 1 ) 
│   │   │   └── 应用方法重写 --> ( 难度等级: [0.1155, 0.1161) || 挂载数据: qa: 3 ) 
│   │   ├── 使用抽象类 --> ( 难度等级: [0.1161, 0.1172) || 挂载数据: qa: 1 ) 
│   │   │   └── 抽象类的作用 --> ( 难度等级: [0.1161, 0.1172) || 挂载数据: qa: 10 ) 
│   │   ├── 在继承中使用final关键字 --> ( 难度等级: [0.1172, 0.1183) || 挂载数据: 无 ) 
│   │   │   ├── 使用final关键字阻止重写 --> ( 难度等级: [0.1172, 0.1177) || 挂载数据: 无 ) 
│   │   │   └── 使用final关键字阻止继承 --> ( 难度等级: [0.1177, 0.1183) || 挂载数据: 无 ) 
│   │   ├── Object类 --> ( 难度等级: [0.1183, 0.1194) || 挂载数据: 无 ) 
│   │   ├── “是一个”（is-a）与“像是一个”（is-like-a）关系 --> ( 难度等级: [0.1194, 0.1205) || 挂载数据: qa: 8 ) 
│   │   ├── Object：所有类的超类 --> ( 难度等级: [0.1205, 0.1217) || 挂载数据: qa: 1 ) 
│   │   │   ├── Object类型的变量 --> ( 难度等级: [0.1205, 0.1211) || 挂载数据: qa: 10 ) 
│   │   │   └── hashCode方法 --> ( 难度等级: [0.1211, 0.1217) || 挂载数据: qa: 4 ) 
│   │   ├── 泛型数组列表 --> ( 难度等级: [0.1217, 0.1228) || 挂载数据: 无 ) 
│   │   │   ├── 声明数组列表 --> ( 难度等级: [0.1217, 0.122) || 挂载数据: 无 ) 
│   │   │   ├── 访问数组列表元素 --> ( 难度等级: [0.122, 0.1224) || 挂载数据: 无 ) 
│   │   │   └── 类型化与原始数组列表的 --> ( 难度等级: [0.1224, 0.1228) || 挂载数据: 无 ) 
│   │   ├── 参数数量可变的方法 --> ( 难度等级: [0.1228, 0.1239) || 挂载数据: 无 ) 
│   │   └── 继承的设计技巧 --> ( 难度等级: [0.1239, 0.125) || 挂载数据: 无 ) 
│   ├── 包和接口 --> ( 难度等级: [0.125, 0.1406) || 挂载数据: 无 ) 
│   │   ├── 包 --> ( 难度等级: [0.125, 0.1272) || 挂载数据: 无 ) 
│   │   │   ├── 定义包 --> ( 难度等级: [0.125, 0.1252) || 挂载数据: 无 ) 
│   │   │   ├── 包查找与CLASSPATH --> ( 难度等级: [0.1252, 0.1253) || 挂载数据: qa: 1 ) 
│   │   │   ├── 一个简短的包示例 --> ( 难度等级: [0.1253, 0.1255) || 挂载数据: 无 ) 
│   │   │   ├── 代码组织 --> ( 难度等级: [0.1255, 0.1256) || 挂载数据: 无 ) 
│   │   │   ├── 创建独一无二的包名 --> ( 难度等级: [0.1256, 0.1258) || 挂载数据: 无 ) 
│   │   │   ├── 定制工具库 --> ( 难度等级: [0.1258, 0.126) || 挂载数据: 无 ) 
│   │   │   ├── 用import改变行为 --> ( 难度等级: [0.126, 0.1261) || 挂载数据: qa: 7 ) 
│   │   │   ├── 对使用包的忠告 --> ( 难度等级: [0.1261, 0.1263) || 挂载数据: 无 ) 
│   │   │   ├── 包名 --> ( 难度等级: [0.1263, 0.1264) || 挂载数据: 无 ) 
│   │   │   ├── 类的导入 --> ( 难度等级: [0.1264, 0.1266) || 挂载数据: qa: 5 ) 
│   │   │   ├── 在包中增加类 --> ( 难度等级: [0.1266, 0.1268) || 挂载数据: 无 ) 
│   │   │   ├── 包访问 --> ( 难度等级: [0.1268, 0.1269) || 挂载数据: qa: 8 ) 
│   │   │   ├── 类路径 --> ( 难度等级: [0.1269, 0.1271) || 挂载数据: qa: 3 ) 
│   │   │   └── 设置类路径 --> ( 难度等级: [0.1271, 0.1272) || 挂载数据: qa: 1 ) 
│   │   ├── 访问保护 --> ( 难度等级: [0.1272, 0.1295) || 挂载数据: 无 ) 
│   │   ├── 导入包 --> ( 难度等级: [0.1295, 0.1317) || 挂载数据: qa: 5 ) 
│   │   ├── 接口 --> ( 难度等级: [0.1317, 0.1339) || 挂载数据: qa: 1 ) 
│   │   │   ├── 定义接口 --> ( 难度等级: [0.1317, 0.1318) || 挂载数据: qa: 6 ) 
│   │   │   ├── 实现接口 --> ( 难度等级: [0.1318, 0.132) || 挂载数据: qa: 10 ) 
│   │   │   ├── 嵌套接口 --> ( 难度等级: [0.132, 0.1321) || 挂载数据: qa: 3 ) 
│   │   │   ├── 应用接口 --> ( 难度等级: [0.1321, 0.1322) || 挂载数据: 无 ) 
│   │   │   ├── 接口中的变量 --> ( 难度等级: [0.1322, 0.1324) || 挂载数据: 无 ) 
│   │   │   ├── 接口可以扩展 --> ( 难度等级: [0.1324, 0.1325) || 挂载数据: 无 ) 
│   │   │   ├── 完全解耦 --> ( 难度等级: [0.1325, 0.1326) || 挂载数据: qa: 6 ) 
│   │   │   ├── Java中的“多重继承” --> ( 难度等级: [0.1326, 0.1327) || 挂载数据: 无 ) 
│   │   │   ├── 通过继承来扩展接口 --> ( 难度等级: [0.1327, 0.1329) || 挂载数据: 无 ) 
│   │   │   │   └── 组合接口时的名字冲突 --> ( 难度等级: [0.1327, 0.1329) || 挂载数据: qa: 2 ) 
│   │   │   ├── 适配接口 --> ( 难度等级: [0.1329, 0.133) || 挂载数据: qa: 1 ) 
│   │   │   ├── 接口中的域 --> ( 难度等级: [0.133, 0.1331) || 挂载数据: 无 ) 
│   │   │   │   └── 初始化接口中的域 --> ( 难度等级: [0.133, 0.1331) || 挂载数据: qa: 10 ) 
│   │   │   ├── 接口的属性 --> ( 难度等级: [0.1331, 0.1333) || 挂载数据: 无 ) 
│   │   │   ├── 静态和私有方法 --> ( 难度等级: [0.1333, 0.1334) || 挂载数据: 无 ) 
│   │   │   ├── 默认方法 --> ( 难度等级: [0.1334, 0.1335) || 挂载数据: 无 ) 
│   │   │   ├── 解决默认方法冲突 --> ( 难度等级: [0.1335, 0.1337) || 挂载数据: 无 ) 
│   │   │   ├── Comparator接口 --> ( 难度等级: [0.1337, 0.1338) || 挂载数据: 无 ) 
│   │   │   └── 对象克隆 --> ( 难度等级: [0.1338, 0.1339) || 挂载数据: 无 ) 
│   │   ├── 默认接口方法 --> ( 难度等级: [0.1339, 0.1362) || 挂载数据: 无 ) 
│   │   │   ├── 默认方法的基础知识 --> ( 难度等级: [0.1339, 0.135) || 挂载数据: 无 ) 
│   │   │   └── 一个更加实用的例子 --> ( 难度等级: [0.135, 0.1362) || 挂载数据: 无 ) 
│   │   ├── 在接口中使用静态方法 --> ( 难度等级: [0.1362, 0.1384) || 挂载数据: 无 ) 
│   │   └── 关于包和接口的最后说明 --> ( 难度等级: [0.1384, 0.1406) || 挂载数据: 无 ) 
│   ├── 异常处理 --> ( 难度等级: [0.1406, 0.1562) || 挂载数据: qa: 1 ) 
│   │   ├── 异常处理的基础知识 --> ( 难度等级: [0.1406, 0.1411) || 挂载数据: 无 ) 
│   │   ├── 异常类型 --> ( 难度等级: [0.1411, 0.1416) || 挂载数据: qa: 1 ) 
│   │   ├── 未捕获的异常 --> ( 难度等级: [0.1416, 0.1421) || 挂载数据: 无 ) 
│   │   ├── 使用try和catch --> ( 难度等级: [0.1421, 0.1426) || 挂载数据: qa: 1 ) 
│   │   ├── 多条catch子句 --> ( 难度等级: [0.1426, 0.1431) || 挂载数据: 无 ) 
│   │   ├── 嵌套的try语句 --> ( 难度等级: [0.1431, 0.1436) || 挂载数据: 无 ) 
│   │   ├── throw --> ( 难度等级: [0.1436, 0.144) || 挂载数据: 无 ) 
│   │   ├── throws --> ( 难度等级: [0.144, 0.1445) || 挂载数据: qa: 1 ) 
│   │   ├── finally --> ( 难度等级: [0.1445, 0.145) || 挂载数据: 无 ) 
│   │   ├── Java的内置异常 --> ( 难度等级: [0.145, 0.1455) || 挂载数据: 无 ) 
│   │   ├── 创建自己的异常子类 --> ( 难度等级: [0.1455, 0.146) || 挂载数据: 无 ) 
│   │   ├── 链式异常 --> ( 难度等级: [0.146, 0.1465) || 挂载数据: 无 ) 
│   │   ├── 3个近期添加的异常特性 --> ( 难度等级: [0.1465, 0.147) || 挂载数据: 无 ) 
│   │   ├── 使用异常 --> ( 难度等级: [0.147, 0.1475) || 挂载数据: qa: 1 ) 
│   │   │   ├── 异常的类型 --> ( 难度等级: [0.147, 0.1471) || 挂载数据: qa: 8 ) 
│   │   │   ├── throws关键字 --> ( 难度等级: [0.1471, 0.1472) || 挂载数据: 无 ) 
│   │   │   ├── throw关键字 --> ( 难度等级: [0.1472, 0.1473) || 挂载数据: 无 ) 
│   │   │   ├── 自定义异常 --> ( 难度等级: [0.1473, 0.1474) || 挂载数据: 无 ) 
│   │   │   └── 异常参数 --> ( 难度等级: [0.1474, 0.1475) || 挂载数据: 无 ) 
│   │   ├── 异常概述 --> ( 难度等级: [0.1475, 0.1479) || 挂载数据: 无 ) 
│   │   ├── 捕捉处理异常 --> ( 难度等级: [0.1479, 0.1484) || 挂载数据: 无 ) 
│   │   │   └── try-catch代码块 --> ( 难度等级: [0.1479, 0.1484) || 挂载数据: 无 ) 
│   │   ├── 在方法中抛出异常 --> ( 难度等级: [0.1484, 0.1489) || 挂载数据: 无 ) 
│   │   │   ├── 使用throws关键字抛出异常 --> ( 难度等级: [0.1484, 0.1487) || 挂载数据: qa: 2 ) 
│   │   │   └── 使用throw关键字抛出异常 --> ( 难度等级: [0.1487, 0.1489) || 挂载数据: 无 ) 
│   │   ├── 处理程序异常错误 --> ( 难度等级: [0.1489, 0.1494) || 挂载数据: 无 ) 
│   │   │   └── 错误 --> ( 难度等级: [0.1489, 0.1494) || 挂载数据: 无 ) 
│   │   ├── Java常见异常 --> ( 难度等级: [0.1494, 0.1499) || 挂载数据: 无 ) 
│   │   ├── 运行时异常 --> ( 难度等级: [0.1499, 0.1504) || 挂载数据: 无 ) 
│   │   ├── 异常处理机制 --> ( 难度等级: [0.1504, 0.1509) || 挂载数据: 无 ) 
│   │   │   ├── 使用try...catch捕获异常 --> ( 难度等级: [0.1504, 0.1505) || 挂载数据: qa: 1 ) 
│   │   │   ├── 异常类的继承体系 --> ( 难度等级: [0.1505, 0.1505) || 挂载数据: 无 ) 
│   │   │   ├── 多异常捕获 --> ( 难度等级: [0.1505, 0.1506) || 挂载数据: qa: 1 ) 
│   │   │   ├── 访问异常信息 --> ( 难度等级: [0.1506, 0.1507) || 挂载数据: qa: 3 ) 
│   │   │   ├── 使用finally回收资源 --> ( 难度等级: [0.1507, 0.1507) || 挂载数据: 无 ) 
│   │   │   ├── 异常处理的嵌套 --> ( 难度等级: [0.1507, 0.1508) || 挂载数据: qa: 6 ) 
│   │   │   └── Java 9增强的自动关闭资源的try语句 --> ( 难度等级: [0.1508, 0.1509) || 挂载数据: 无 ) 
│   │   ├── Checked异常和Runtime异常体系 --> ( 难度等级: [0.1509, 0.1514) || 挂载数据: 无 ) 
│   │   │   ├── 使用throws声明抛出异常 --> ( 难度等级: [0.1509, 0.1511) || 挂载数据: 无 ) 
│   │   │   └── 方法重写时声明抛出异常的限制 --> ( 难度等级: [0.1511, 0.1514) || 挂载数据: 无 ) 
│   │   ├── 使用throw抛出异常 --> ( 难度等级: [0.1514, 0.1519) || 挂载数据: 无 ) 
│   │   │   ├── 自定义异常类 --> ( 难度等级: [0.1514, 0.1516) || 挂载数据: qa: 4 ) 
│   │   │   └── 使用throw语句抛出异常 --> ( 难度等级: [0.1516, 0.1519) || 挂载数据: qa: 4 ) 
│   │   ├── Java的异常跟踪栈 --> ( 难度等级: [0.1519, 0.1523) || 挂载数据: 无 ) 
│   │   ├── 异常处理规则 --> ( 难度等级: [0.1523, 0.1528) || 挂载数据: 无 ) 
│   │   │   ├── 不要过度使用异常 --> ( 难度等级: [0.1523, 0.1525) || 挂载数据: 无 ) 
│   │   │   ├── 不要使用过于庞大的try块 --> ( 难度等级: [0.1525, 0.1526) || 挂载数据: 无 ) 
│   │   │   ├── 避免使用Catch All语句 --> ( 难度等级: [0.1526, 0.1527) || 挂载数据: qa: 1 ) 
│   │   │   └── 不要忽略捕获到的异常 --> ( 难度等级: [0.1527, 0.1528) || 挂载数据: 无 ) 
│   │   ├── Java的异常 --> ( 难度等级: [0.1528, 0.1533) || 挂载数据: 无 ) 
│   │   ├── NullPointerException --> ( 难度等级: [0.1533, 0.1538) || 挂载数据: qa: 6 ) 
│   │   ├── 使用断言 --> ( 难度等级: [0.1538, 0.1543) || 挂载数据: 无 ) 
│   │   ├── 使用JDK Logging --> ( 难度等级: [0.1543, 0.1548) || 挂载数据: 无 ) 
│   │   ├── 使用Commons Logging --> ( 难度等级: [0.1548, 0.1553) || 挂载数据: qa: 1 ) 
│   │   ├── 使用Log4j --> ( 难度等级: [0.1553, 0.1558) || 挂载数据: qa: 4 ) 
│   │   └── 使用SLF4J和Logback --> ( 难度等级: [0.1558, 0.1562) || 挂载数据: qa: 2 ) 
│   ├── 多线程编程 --> ( 难度等级: [0.1562, 0.1719) || 挂载数据: 无 ) 
│   │   ├── Java线程模型 --> ( 难度等级: [0.1562, 0.1577) || 挂载数据: 无 ) 
│   │   │   ├── 线程优先级 --> ( 难度等级: [0.1562, 0.1566) || 挂载数据: 无 ) 
│   │   │   ├── 同步 --> ( 难度等级: [0.1566, 0.157) || 挂载数据: 无 ) 
│   │   │   ├── 消息传递 --> ( 难度等级: [0.157, 0.1573) || 挂载数据: 无 ) 
│   │   │   └── Thread类和Runnable接口 --> ( 难度等级: [0.1573, 0.1577) || 挂载数据: 无 ) 
│   │   ├── 主线程 --> ( 难度等级: [0.1577, 0.1591) || 挂载数据: 无 ) 
│   │   ├── 创建线程 --> ( 难度等级: [0.1591, 0.1605) || 挂载数据: 无 ) 
│   │   │   ├── 实现Runnable接口 --> ( 难度等级: [0.1591, 0.1593) || 挂载数据: 无 ) 
│   │   │   ├── 扩展Thread类 --> ( 难度等级: [0.1593, 0.1594) || 挂载数据: 无 ) 
│   │   │   ├── 选择一种创建方式 --> ( 难度等级: [0.1594, 0.1596) || 挂载数据: qa: 2 ) 
│   │   │   ├── Thread类实现多线程 --> ( 难度等级: [0.1596, 0.1598) || 挂载数据: 无 ) 
│   │   │   ├── Runnable接口实现多线程 --> ( 难度等级: [0.1598, 0.16) || 挂载数据: 无 ) 
│   │   │   ├── Callable接口实现多线程 --> ( 难度等级: [0.16, 0.1602) || 挂载数据: 无 ) 
│   │   │   ├── 三种实现多线程方式的对比分析 --> ( 难度等级: [0.1602, 0.1603) || 挂载数据: 无 ) 
│   │   │   └── 后台线程 --> ( 难度等级: [0.1603, 0.1605) || 挂载数据: qa: 2 ) 
│   │   ├── 创建多个线程 --> ( 难度等级: [0.1605, 0.1619) || 挂载数据: 无 ) 
│   │   ├── 使用isAlive和join方法 --> ( 难度等级: [0.1619, 0.1634) || 挂载数据: 无 ) 
│   │   ├── 线程优先级 --> ( 难度等级: [0.1634, 0.1648) || 挂载数据: 无 ) 
│   │   ├── 同步 --> ( 难度等级: [0.1648, 0.1662) || 挂载数据: 无 ) 
│   │   │   ├── 使用同步方法 --> ( 难度等级: [0.1648, 0.1649) || 挂载数据: qa: 1 ) 
│   │   │   ├── synchronized语句 --> ( 难度等级: [0.1649, 0.1651) || 挂载数据: 无 ) 
│   │   │   ├── 竞态条件的一个例子 --> ( 难度等级: [0.1651, 0.1652) || 挂载数据: 无 ) 
│   │   │   ├── 竞态条件详解 --> ( 难度等级: [0.1652, 0.1653) || 挂载数据: 无 ) 
│   │   │   ├── 锁对象 --> ( 难度等级: [0.1653, 0.1655) || 挂载数据: qa: 2 ) 
│   │   │   ├── 条件对象 --> ( 难度等级: [0.1655, 0.1656) || 挂载数据: 无 ) 
│   │   │   ├── synchronized关键字 --> ( 难度等级: [0.1656, 0.1658) || 挂载数据: qa: 10 ) 
│   │   │   ├── 监视器概念 --> ( 难度等级: [0.1658, 0.1659) || 挂载数据: 无 ) 
│   │   │   ├── volatile字段 --> ( 难度等级: [0.1659, 0.1661) || 挂载数据: 无 ) 
│   │   │   └── 线程局部变量 --> ( 难度等级: [0.1661, 0.1662) || 挂载数据: 无 ) 
│   │   ├── 线程间通信 --> ( 难度等级: [0.1662, 0.1676) || 挂载数据: 无 ) 
│   │   ├── 挂起、恢复与停止线程 --> ( 难度等级: [0.1676, 0.169) || 挂载数据: qa: 1 ) 
│   │   ├── 获取线程的状态 --> ( 难度等级: [0.169, 0.1705) || 挂载数据: 无 ) 
│   │   └── 使用多线程 --> ( 难度等级: [0.1705, 0.1719) || 挂载数据: 无 ) 
│   │       ├── 线程概述 --> ( 难度等级: [0.1705, 0.1706) || 挂载数据: 无 ) 
│   │       │   ├── 进程 --> ( 难度等级: [0.1705, 0.1705) || 挂载数据: 无 ) 
│   │       │   │   ├── 建立一个进程 --> ( 难度等级: [0.1705, 0.1705) || 挂载数据: qa: 8 ) 
│   │       │   │   ├── 运行一个进程 --> ( 难度等级: [0.1705, 0.1705) || 挂载数据: qa: 6 ) 
│   │       │   │   └── 进程句柄 --> ( 难度等级: [0.1705, 0.1705) || 挂载数据: 无 ) 
│   │       │   ├── 线程 --> ( 难度等级: [0.1705, 0.1705) || 挂载数据: qa: 10 ) 
│   │       │   └── 多线程的优势 --> ( 难度等级: [0.1705, 0.1706) || 挂载数据: 无 ) 
│   │       ├── 线程的生命周期及状态转换 --> ( 难度等级: [0.1706, 0.1707) || 挂载数据: 无 ) 
│   │       │   ├── 新建和就绪状态 --> ( 难度等级: [0.1706, 0.1706) || 挂载数据: qa: 4 ) 
│   │       │   ├── 运行和阻塞状态 --> ( 难度等级: [0.1706, 0.1706) || 挂载数据: 无 ) 
│   │       │   └── 线程死亡 --> ( 难度等级: [0.1706, 0.1707) || 挂载数据: 无 ) 
│   │       ├── 线程的调度 --> ( 难度等级: [0.1707, 0.1708) || 挂载数据: 无 ) 
│   │       │   ├── 线程休眠 --> ( 难度等级: [0.1707, 0.1707) || 挂载数据: qa: 1 ) 
│   │       │   ├── 线程让步 --> ( 难度等级: [0.1707, 0.1707) || 挂载数据: 无 ) 
│   │       │   └── 线程插队 --> ( 难度等级: [0.1707, 0.1708) || 挂载数据: 无 ) 
│   │       ├── 多线程同步 --> ( 难度等级: [0.1708, 0.1709) || 挂载数据: qa: 3 ) 
│   │       │   ├── 同步代码块 --> ( 难度等级: [0.1708, 0.1708) || 挂载数据: qa: 8 ) 
│   │       │   └── 同步锁 --> ( 难度等级: [0.1708, 0.1709) || 挂载数据: qa: 1 ) 
│   │       ├── 多线程通信 --> ( 难度等级: [0.1709, 0.171) || 挂载数据: 无 ) 
│   │       ├── 线程池 --> ( 难度等级: [0.171, 0.1711) || 挂载数据: qa: 1 ) 
│   │       │   ├── Executor接口实现线程池管理 --> ( 难度等级: [0.171, 0.171) || 挂载数据: 无 ) 
│   │       │   ├── CompletableFuture类实现线程池管理 --> ( 难度等级: [0.171, 0.171) || 挂载数据: 无 ) 
│   │       │   ├── 使用线程池管理线程 --> ( 难度等级: [0.171, 0.171) || 挂载数据: 无 ) 
│   │       │   └── 使用ForkJoinPool利用多CPU --> ( 难度等级: [0.171, 0.1711) || 挂载数据: qa: 10 ) 
│   │       ├── 线程简介 --> ( 难度等级: [0.1711, 0.1712) || 挂载数据: 无 ) 
│   │       ├── 实现线程的两种方式 --> ( 难度等级: [0.1712, 0.1713) || 挂载数据: 无 ) 
│   │       │   └── 继承Thread类 --> ( 难度等级: [0.1712, 0.1713) || 挂载数据: qa: 1 ) 
│   │       ├── 操作线程的方法 --> ( 难度等级: [0.1713, 0.1714) || 挂载数据: 无 ) 
│   │       │   ├── 线程的中断 --> ( 难度等级: [0.1713, 0.1713) || 挂载数据: qa: 1 ) 
│   │       │   └── 线程的礼让 --> ( 难度等级: [0.1713, 0.1714) || 挂载数据: 无 ) 
│   │       ├── 线程的同步 --> ( 难度等级: [0.1714, 0.1715) || 挂载数据: qa: 3 ) 
│   │       │   ├── 线程同步机制 --> ( 难度等级: [0.1714, 0.1714) || 挂载数据: qa: 5 ) 
│   │       │   ├── 释放同步监视器的锁定 --> ( 难度等级: [0.1714, 0.1714) || 挂载数据: 无 ) 
│   │       │   └── 同步锁（Lock） --> ( 难度等级: [0.1714, 0.1715) || 挂载数据: qa: 2 ) 
│   │       ├── 控制线程 --> ( 难度等级: [0.1715, 0.1716) || 挂载数据: qa: 1 ) 
│   │       │   ├── join线程 --> ( 难度等级: [0.1715, 0.1715) || 挂载数据: 无 ) 
│   │       │   ├── 线程睡眠：sleep --> ( 难度等级: [0.1715, 0.1715) || 挂载数据: qa: 5 ) 
│   │       │   └── 改变线程优先级 --> ( 难度等级: [0.1715, 0.1716) || 挂载数据: 无 ) 
│   │       ├── 线程通信 --> ( 难度等级: [0.1716, 0.1717) || 挂载数据: 无 ) 
│   │       │   ├── 传统的线程通信 --> ( 难度等级: [0.1716, 0.1716) || 挂载数据: 无 ) 
│   │       │   ├── 使用Condition控制线程通信 --> ( 难度等级: [0.1716, 0.1716) || 挂载数据: 无 ) 
│   │       │   └── 使用阻塞队列（BlockingQueue）控制线程通信 --> ( 难度等级: [0.1716, 0.1717) || 挂载数据: 无 ) 
│   │       ├── 线程组和未处理的异常 --> ( 难度等级: [0.1717, 0.1718) || 挂载数据: 无 ) 
│   │       └── 线程相关类 --> ( 难度等级: [0.1718, 0.1719) || 挂载数据: 无 ) 
│   │           ├── ThreadLocal类 --> ( 难度等级: [0.1718, 0.1718) || 挂载数据: qa: 2 ) 
│   │           ├── 包装线程不安全的集合 --> ( 难度等级: [0.1718, 0.1718) || 挂载数据: qa: 1 ) 
│   │           ├── 线程安全的集合类 --> ( 难度等级: [0.1718, 0.1718) || 挂载数据: qa: 1 ) 
│   │           └── Java 9新增的发布-订阅框架 --> ( 难度等级: [0.1718, 0.1719) || 挂载数据: 无 ) 
│   ├── 枚举、自动装箱与注解(元数据) --> ( 难度等级: [0.1719, 0.1875) || 挂载数据: 无 ) 
│   │   ├── 枚举 --> ( 难度等级: [0.1719, 0.1745) || 挂载数据: qa: 2 ) 
│   │   │   ├── 枚举的基础知识 --> ( 难度等级: [0.1719, 0.1724) || 挂载数据: qa: 1 ) 
│   │   │   ├── values和valueOf方法 --> ( 难度等级: [0.1724, 0.1729) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java枚举是类类型 --> ( 难度等级: [0.1729, 0.1734) || 挂载数据: 无 ) 
│   │   │   ├── 枚举继承自Enum类 --> ( 难度等级: [0.1734, 0.174) || 挂载数据: 无 ) 
│   │   │   └── 另一个枚举示例 --> ( 难度等级: [0.174, 0.1745) || 挂载数据: 无 ) 
│   │   ├── 类型封装器 --> ( 难度等级: [0.1745, 0.1771) || 挂载数据: 无 ) 
│   │   │   ├── Character封装器 --> ( 难度等级: [0.1745, 0.1753) || 挂载数据: 无 ) 
│   │   │   ├── Boolean封装器 --> ( 难度等级: [0.1753, 0.1762) || 挂载数据: 无 ) 
│   │   │   └── 数值类型封装器 --> ( 难度等级: [0.1762, 0.1771) || 挂载数据: 无 ) 
│   │   ├── 自动装箱 --> ( 难度等级: [0.1771, 0.1797) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱与方法 --> ( 难度等级: [0.1771, 0.1776) || 挂载数据: qa: 10 ) 
│   │   │   ├── 表达式中发生的自动装箱/拆箱 --> ( 难度等级: [0.1776, 0.1781) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型和字符型数值的自动装箱/拆箱 --> ( 难度等级: [0.1781, 0.1786) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱/拆箱有助于防止错误 --> ( 难度等级: [0.1786, 0.1792) || 挂载数据: qa: 2 ) 
│   │   │   └── 一些警告 --> ( 难度等级: [0.1792, 0.1797) || 挂载数据: 无 ) 
│   │   ├── 注解(元数据) --> ( 难度等级: [0.1797, 0.1823) || 挂载数据: 无 ) 
│   │   │   ├── 注解的基础知识 --> ( 难度等级: [0.1797, 0.18) || 挂载数据: 无 ) 
│   │   │   ├── 指定保留策略 --> ( 难度等级: [0.18, 0.1803) || 挂载数据: qa: 2 ) 
│   │   │   ├── 在运行时使用反射获取注解 --> ( 难度等级: [0.1803, 0.1807) || 挂载数据: qa: 2 ) 
│   │   │   ├── AnnotatedElement接口 --> ( 难度等级: [0.1807, 0.181) || 挂载数据: 无 ) 
│   │   │   ├── 使用默认值 --> ( 难度等级: [0.181, 0.1813) || 挂载数据: 无 ) 
│   │   │   ├── 标记注解 --> ( 难度等级: [0.1813, 0.1816) || 挂载数据: 无 ) 
│   │   │   ├── 单成员注解 --> ( 难度等级: [0.1816, 0.182) || 挂载数据: 无 ) 
│   │   │   └── 内置注解 --> ( 难度等级: [0.182, 0.1823) || 挂载数据: 无 ) 
│   │   ├── 类型注解 --> ( 难度等级: [0.1823, 0.1849) || 挂载数据: 无 ) 
│   │   └── 重复注解 --> ( 难度等级: [0.1849, 0.1875) || 挂载数据: qa: 2 ) 
│   ├── I/O、applet以及其他主题 --> ( 难度等级: [0.1875, 0.2031) || 挂载数据: 无 ) 
│   │   ├── I/O的基础知识 --> ( 难度等级: [0.1875, 0.1882) || 挂载数据: 无 ) 
│   │   │   ├── 流 --> ( 难度等级: [0.1875, 0.1877) || 挂载数据: 无 ) 
│   │   │   ├── 字节流和字符流 --> ( 难度等级: [0.1877, 0.188) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符流概述 --> ( 难度等级: [0.1877, 0.1878) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 字符流操作文件 --> ( 难度等级: [0.1878, 0.1879) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 转换流 --> ( 难度等级: [0.1879, 0.188) || 挂载数据: qa: 7 ) 
│   │   │   └── 预定义流 --> ( 难度等级: [0.188, 0.1882) || 挂载数据: 无 ) 
│   │   ├── 读取控制台输入 --> ( 难度等级: [0.1882, 0.1889) || 挂载数据: 无 ) 
│   │   │   ├── 读取字符 --> ( 难度等级: [0.1882, 0.1886) || 挂载数据: qa: 10 ) 
│   │   │   └── 读取字符串 --> ( 难度等级: [0.1886, 0.1889) || 挂载数据: 无 ) 
│   │   ├── 向控制台写输出 --> ( 难度等级: [0.1889, 0.1896) || 挂载数据: 无 ) 
│   │   ├── PrintWriter类 --> ( 难度等级: [0.1896, 0.1903) || 挂载数据: 无 ) 
│   │   ├── 读/写文件 --> ( 难度等级: [0.1903, 0.1911) || 挂载数据: qa: 1 ) 
│   │   ├── 自动关闭文件 --> ( 难度等级: [0.1911, 0.1918) || 挂载数据: 无 ) 
│   │   ├── applet的基础知识 --> ( 难度等级: [0.1918, 0.1925) || 挂载数据: 无 ) 
│   │   ├── transient和volatile修饰符 --> ( 难度等级: [0.1925, 0.1932) || 挂载数据: 无 ) 
│   │   ├── 使用instanceof运算符 --> ( 难度等级: [0.1932, 0.1939) || 挂载数据: 无 ) 
│   │   ├── strictfp --> ( 难度等级: [0.1939, 0.1946) || 挂载数据: 无 ) 
│   │   ├── 本地方法 --> ( 难度等级: [0.1946, 0.1953) || 挂载数据: qa: 3 ) 
│   │   ├── 使用assert --> ( 难度等级: [0.1953, 0.196) || 挂载数据: 无 ) 
│   │   ├── 静态导入 --> ( 难度等级: [0.196, 0.1967) || 挂载数据: 无 ) 
│   │   ├── 通过this调用重载的构造函数 --> ( 难度等级: [0.1967, 0.1974) || 挂载数据: qa: 1 ) 
│   │   ├── 紧凑API配置文件 --> ( 难度等级: [0.1974, 0.1982) || 挂载数据: 无 ) 
│   │   ├── 转换数据 --> ( 难度等级: [0.1982, 0.1989) || 挂载数据: qa: 1 ) 
│   │   ├── 获取基本类型 --> ( 难度等级: [0.1989, 0.1996) || 挂载数据: 无 ) 
│   │   ├── 视图缓冲器 --> ( 难度等级: [0.1996, 0.2003) || 挂载数据: 无 ) 
│   │   ├── 用缓冲器操纵数据 --> ( 难度等级: [0.2003, 0.201) || 挂载数据: 无 ) 
│   │   ├── 缓冲器的细节 --> ( 难度等级: [0.201, 0.2017) || 挂载数据: 无 ) 
│   │   ├── 内存映射文件 --> ( 难度等级: [0.2017, 0.2024) || 挂载数据: 无 ) 
│   │   └── 文件加锁 --> ( 难度等级: [0.2024, 0.2031) || 挂载数据: 无 ) 
│   ├── 泛型 --> ( 难度等级: [0.2031, 0.2188) || 挂载数据: qa: 5 ) 
│   │   ├── 什么是泛型 --> ( 难度等级: [0.2031, 0.2035) || 挂载数据: qa: 1 ) 
│   │   ├── 一个简单的泛型示例 --> ( 难度等级: [0.2035, 0.2039) || 挂载数据: 无 ) 
│   │   │   ├── 泛型只使用引用类型 --> ( 难度等级: [0.2035, 0.2036) || 挂载数据: 无 ) 
│   │   │   ├── 基于不同类型参数的泛型类型是不同的 --> ( 难度等级: [0.2036, 0.2038) || 挂载数据: qa: 3 ) 
│   │   │   └── 泛型提升类型安全性的原理 --> ( 难度等级: [0.2038, 0.2039) || 挂载数据: 无 ) 
│   │   ├── 带两个类型参数的泛型类 --> ( 难度等级: [0.2039, 0.2043) || 挂载数据: 无 ) 
│   │   ├── 泛型类的一般形式 --> ( 难度等级: [0.2043, 0.2046) || 挂载数据: qa: 2 ) 
│   │   ├── 有界类型 --> ( 难度等级: [0.2046, 0.205) || 挂载数据: 无 ) 
│   │   ├── 使用通配符参数 --> ( 难度等级: [0.205, 0.2054) || 挂载数据: 无 ) 
│   │   ├── 创建泛型方法 --> ( 难度等级: [0.2054, 0.2058) || 挂载数据: 无 ) 
│   │   ├── 泛型接口 --> ( 难度等级: [0.2058, 0.2062) || 挂载数据: qa: 1 ) 
│   │   ├── 原始类型与遗留代码 --> ( 难度等级: [0.2062, 0.2066) || 挂载数据: 无 ) 
│   │   ├── 泛型类层次 --> ( 难度等级: [0.2066, 0.2069) || 挂载数据: qa: 1 ) 
│   │   │   ├── 使用泛型超类 --> ( 难度等级: [0.2066, 0.2066) || 挂载数据: 无 ) 
│   │   │   ├── 泛型子类 --> ( 难度等级: [0.2066, 0.2067) || 挂载数据: 无 ) 
│   │   │   ├── 泛型层次中的运行时类型比较 --> ( 难度等级: [0.2067, 0.2068) || 挂载数据: 无 ) 
│   │   │   ├── 强制转换 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: qa: 1 ) 
│   │   │   └── 重写泛型类的方法 --> ( 难度等级: [0.2069, 0.2069) || 挂载数据: 无 ) 
│   │   ├── 泛型的类型推断 --> ( 难度等级: [0.2069, 0.2073) || 挂载数据: 无 ) 
│   │   ├── 擦除 --> ( 难度等级: [0.2073, 0.2077) || 挂载数据: 无 ) 
│   │   ├── 模糊性错误 --> ( 难度等级: [0.2077, 0.2081) || 挂载数据: 无 ) 
│   │   ├── 使用泛型的一些限制 --> ( 难度等级: [0.2081, 0.2085) || 挂载数据: qa: 6 ) 
│   │   │   ├── 对静态成员的一些限制 --> ( 难度等级: [0.2081, 0.2082) || 挂载数据: qa: 1 ) 
│   │   │   ├── 对泛型数组的一些限制 --> ( 难度等级: [0.2082, 0.2083) || 挂载数据: 无 ) 
│   │   │   └── 对泛型异常的限制 --> ( 难度等级: [0.2083, 0.2085) || 挂载数据: qa: 1 ) 
│   │   ├── 定义泛型类 --> ( 难度等级: [0.2085, 0.2088) || 挂载数据: 无 ) 
│   │   ├── 泛型的用法 --> ( 难度等级: [0.2088, 0.2092) || 挂载数据: 无 ) 
│   │   ├── 一个元组类库 --> ( 难度等级: [0.2092, 0.2096) || 挂载数据: 无 ) 
│   │   ├── 一个栈类 --> ( 难度等级: [0.2096, 0.21) || 挂载数据: 无 ) 
│   │   ├── RandomList --> ( 难度等级: [0.21, 0.2104) || 挂载数据: 无 ) 
│   │   ├── 泛型方法 --> ( 难度等级: [0.2104, 0.2107) || 挂载数据: 无 ) 
│   │   │   ├── 利用类型参数推断 --> ( 难度等级: [0.2104, 0.2104) || 挂载数据: 无 ) 
│   │   │   ├── 可变参数与泛型方法 --> ( 难度等级: [0.2104, 0.2105) || 挂载数据: qa: 3 ) 
│   │   │   ├── 用于Generator的泛型方法 --> ( 难度等级: [0.2105, 0.2105) || 挂载数据: 无 ) 
│   │   │   ├── 一个通用的Generator --> ( 难度等级: [0.2105, 0.2105) || 挂载数据: 无 ) 
│   │   │   ├── 简化元组的使用 --> ( 难度等级: [0.2105, 0.2106) || 挂载数据: 无 ) 
│   │   │   ├── 一个Set实用工具 --> ( 难度等级: [0.2106, 0.2106) || 挂载数据: 无 ) 
│   │   │   ├── 定义泛型方法 --> ( 难度等级: [0.2106, 0.2107) || 挂载数据: qa: 1 ) 
│   │   │   ├── “菱形”语法与泛型构造器 --> ( 难度等级: [0.2107, 0.2107) || 挂载数据: 无 ) 
│   │   │   └── 类型推断 --> ( 难度等级: [0.2107, 0.2107) || 挂载数据: 无 ) 
│   │   ├── 构建复杂模型 --> ( 难度等级: [0.2107, 0.2111) || 挂载数据: 无 ) 
│   │   ├── 擦除的神秘之处 --> ( 难度等级: [0.2111, 0.2115) || 挂载数据: 无 ) 
│   │   │   ├── C++的方式 --> ( 难度等级: [0.2111, 0.2113) || 挂载数据: 无 ) 
│   │   │   ├── 迁移的可兼容性 --> ( 难度等级: [0.2113, 0.2114) || 挂载数据: qa: 1 ) 
│   │   │   └── 边界处的动作 --> ( 难度等级: [0.2114, 0.2115) || 挂载数据: qa: 1 ) 
│   │   ├── 擦除的补偿 --> ( 难度等级: [0.2115, 0.2119) || 挂载数据: 无 ) 
│   │   │   └── 泛型数组 --> ( 难度等级: [0.2115, 0.2119) || 挂载数据: qa: 1 ) 
│   │   ├── 边界 --> ( 难度等级: [0.2119, 0.2123) || 挂载数据: 无 ) 
│   │   ├── 通配符 --> ( 难度等级: [0.2123, 0.2127) || 挂载数据: 无 ) 
│   │   │   ├── 编译器有多聪明？ --> ( 难度等级: [0.2123, 0.2124) || 挂载数据: qa: 1 ) 
│   │   │   ├── 抗变 --> ( 难度等级: [0.2124, 0.2125) || 挂载数据: 无 ) 
│   │   │   ├── 无界通配符 --> ( 难度等级: [0.2125, 0.2126) || 挂载数据: 无 ) 
│   │   │   └── 捕获转换 --> ( 难度等级: [0.2126, 0.2127) || 挂载数据: 无 ) 
│   │   ├── 自限定的类型 --> ( 难度等级: [0.2127, 0.213) || 挂载数据: 无 ) 
│   │   │   ├── 离奇的循环泛型 --> ( 难度等级: [0.2127, 0.2128) || 挂载数据: 无 ) 
│   │   │   ├── 自限定 --> ( 难度等级: [0.2128, 0.2129) || 挂载数据: 无 ) 
│   │   │   └── 参数协变 --> ( 难度等级: [0.2129, 0.213) || 挂载数据: 无 ) 
│   │   ├── 动态类型安全 --> ( 难度等级: [0.213, 0.2134) || 挂载数据: 无 ) 
│   │   ├── 混用 --> ( 难度等级: [0.2134, 0.2138) || 挂载数据: 无 ) 
│   │   │   ├── C++中的混用 --> ( 难度等级: [0.2134, 0.2135) || 挂载数据: 无 ) 
│   │   │   ├── 与接口混用 --> ( 难度等级: [0.2135, 0.2136) || 挂载数据: 无 ) 
│   │   │   ├── 使用装饰器模式 --> ( 难度等级: [0.2136, 0.2137) || 挂载数据: 无 ) 
│   │   │   └── 与动态代理混用 --> ( 难度等级: [0.2137, 0.2138) || 挂载数据: 无 ) 
│   │   ├── 潜在类型机制 --> ( 难度等级: [0.2138, 0.2142) || 挂载数据: 无 ) 
│   │   ├── 缺乏潜在类型机制的补偿 --> ( 难度等级: [0.2142, 0.2146) || 挂载数据: 无 ) 
│   │   │   ├── 将一个方法应用于序列 --> ( 难度等级: [0.2142, 0.2143) || 挂载数据: 无 ) 
│   │   │   ├── 当你并未碰巧拥有正确的接口时 --> ( 难度等级: [0.2143, 0.2144) || 挂载数据: 无 ) 
│   │   │   └── 用适配器仿真潜在类型机制 --> ( 难度等级: [0.2144, 0.2146) || 挂载数据: 无 ) 
│   │   ├── 将函数对象用作策略 --> ( 难度等级: [0.2146, 0.2149) || 挂载数据: 无 ) 
│   │   ├── 泛型的常规用法 --> ( 难度等级: [0.2149, 0.2153) || 挂载数据: 无 ) 
│   │   ├── 泛型的高级用法 --> ( 难度等级: [0.2153, 0.2157) || 挂载数据: 无 ) 
│   │   ├── 泛型入门 --> ( 难度等级: [0.2157, 0.2161) || 挂载数据: 无 ) 
│   │   │   ├── 编译时不检查类型的异常 --> ( 难度等级: [0.2157, 0.2159) || 挂载数据: 无 ) 
│   │   │   └── Java 9增强的“菱形”语法 --> ( 难度等级: [0.2159, 0.2161) || 挂载数据: qa: 1 ) 
│   │   ├── 从泛型类派生子类 --> ( 难度等级: [0.2161, 0.2165) || 挂载数据: 无 ) 
│   │   ├── 并不存在泛型类 --> ( 难度等级: [0.2165, 0.2168) || 挂载数据: 无 ) 
│   │   ├── 类型通配符 --> ( 难度等级: [0.2168, 0.2172) || 挂载数据: 无 ) 
│   │   │   ├── 使用类型通配符 --> ( 难度等级: [0.2168, 0.2169) || 挂载数据: 无 ) 
│   │   │   ├── 设定类型通配符的上限 --> ( 难度等级: [0.2169, 0.217) || 挂载数据: 无 ) 
│   │   │   ├── 设定类型通配符的下限 --> ( 难度等级: [0.217, 0.2171) || 挂载数据: 无 ) 
│   │   │   └── 设定泛型形参的上限 --> ( 难度等级: [0.2171, 0.2172) || 挂载数据: qa: 1 ) 
│   │   ├── 编写泛型 --> ( 难度等级: [0.2172, 0.2176) || 挂载数据: 无 ) 
│   │   ├── 擦拭法 --> ( 难度等级: [0.2176, 0.218) || 挂载数据: 无 ) 
│   │   ├── extends通配符 --> ( 难度等级: [0.218, 0.2184) || 挂载数据: 无 ) 
│   │   └── super通配符 --> ( 难度等级: [0.2184, 0.2188) || 挂载数据: 无 ) 
│   ├── lambda表达式 --> ( 难度等级: [0.2188, 0.2344) || 挂载数据: 无 ) 
│   │   ├── lambda表达式简介 --> ( 难度等级: [0.2188, 0.2201) || 挂载数据: 无 ) 
│   │   │   ├── lambda表达式的基础知识 --> ( 难度等级: [0.2188, 0.2192) || 挂载数据: 无 ) 
│   │   │   ├── 函数式接口 --> ( 难度等级: [0.2192, 0.2196) || 挂载数据: 无 ) 
│   │   │   └── 几个lambda表达式示例 --> ( 难度等级: [0.2196, 0.2201) || 挂载数据: 无 ) 
│   │   ├── 块lambda表达式 --> ( 难度等级: [0.2201, 0.2214) || 挂载数据: 无 ) 
│   │   ├── 泛型函数式接口 --> ( 难度等级: [0.2214, 0.2227) || 挂载数据: 无 ) 
│   │   ├── 作为参数传递lambda表达式 --> ( 难度等级: [0.2227, 0.224) || 挂载数据: 无 ) 
│   │   ├── lambda表达式与异常 --> ( 难度等级: [0.224, 0.2253) || 挂载数据: 无 ) 
│   │   ├── lambda表达式和变量捕获 --> ( 难度等级: [0.2253, 0.2266) || 挂载数据: 无 ) 
│   │   ├── 方法引用 --> ( 难度等级: [0.2266, 0.2279) || 挂载数据: 无 ) 
│   │   │   ├── 静态方法的方法引用 --> ( 难度等级: [0.2266, 0.2272) || 挂载数据: 无 ) 
│   │   │   └── 泛型中的方法引用 --> ( 难度等级: [0.2272, 0.2279) || 挂载数据: qa: 4 ) 
│   │   ├── 构造函数引用 --> ( 难度等级: [0.2279, 0.2292) || 挂载数据: 无 ) 
│   │   ├── 预定义的函数式接口 --> ( 难度等级: [0.2292, 0.2305) || 挂载数据: 无 ) 
│   │   ├── lambda表达式的语法 --> ( 难度等级: [0.2305, 0.2318) || 挂载数据: 无 ) 
│   │   ├── 构造器引用 --> ( 难度等级: [0.2318, 0.2331) || 挂载数据: 无 ) 
│   │   └── 再谈Comparator --> ( 难度等级: [0.2331, 0.2344) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.2344, 0.25) || 挂载数据: 无 ) 
│       ├── Java开发入门 --> ( 难度等级: [0.2344, 0.2347) || 挂载数据: 无 ) 
│       │   ├── Java概述 --> ( 难度等级: [0.2344, 0.2344) || 挂载数据: 无 ) 
│       │   │   ├── 什么是Java --> ( 难度等级: [0.2344, 0.2344) || 挂载数据: 无 ) 
│       │   │   └── Java语言的特点 --> ( 难度等级: [0.2344, 0.2344) || 挂载数据: 无 ) 
│       │   ├── JDK的使用 --> ( 难度等级: [0.2344, 0.2345) || 挂载数据: 无 ) 
│       │   │   ├── 什么是JDK --> ( 难度等级: [0.2344, 0.2344) || 挂载数据: qa: 10 ) 
│       │   │   ├── 安装JDK --> ( 难度等级: [0.2344, 0.2345) || 挂载数据: qa: 2 ) 
│       │   │   └── JDK目录介绍 --> ( 难度等级: [0.2345, 0.2345) || 挂载数据: 无 ) 
│       │   ├── 系统环境变量 --> ( 难度等级: [0.2345, 0.2345) || 挂载数据: 无 ) 
│       │   │   ├── PATH环境变量 --> ( 难度等级: [0.2345, 0.2345) || 挂载数据: qa: 1 ) 
│       │   │   └── CLASSPATH环境变量 --> ( 难度等级: [0.2345, 0.2345) || 挂载数据: qa: 9 ) 
│       │   ├── 第一个Java程序 --> ( 难度等级: [0.2345, 0.2346) || 挂载数据: 无 ) 
│       │   │   ├── 编辑Java源代码 --> ( 难度等级: [0.2345, 0.2345) || 挂载数据: 无 ) 
│       │   │   ├── 编译Java程序 --> ( 难度等级: [0.2345, 0.2346) || 挂载数据: qa: 10 ) 
│       │   │   └── 根据CLASSPATH环境变量定位类 --> ( 难度等级: [0.2346, 0.2346) || 挂载数据: 无 ) 
│       │   ├── Java的运行机制 --> ( 难度等级: [0.2346, 0.2346) || 挂载数据: 无 ) 
│       │   └── Eclipse开发工具 --> ( 难度等级: [0.2346, 0.2347) || 挂载数据: qa: 1 ) 
│       │       ├── Eclipse概述 --> ( 难度等级: [0.2346, 0.2347) || 挂载数据: 无 ) 
│       │       ├── Eclipse的安装与启动 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: qa: 1 ) 
│       │       └── 使用Eclipse进行程序开发 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: qa: 1 ) 
│       ├── Java编程基础 --> ( 难度等级: [0.2347, 0.235) || 挂载数据: 无 ) 
│       │   ├── Java的基本语法 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: 无 ) 
│       │   │   ├── Java的基本语法格式 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: qa: 5 ) 
│       │   │   ├── Java中的注释 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: 无 ) 
│       │   │   ├── Java中的关键字 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: 无 ) 
│       │   │   └── Java中的标识符 --> ( 难度等级: [0.2347, 0.2347) || 挂载数据: qa: 1 ) 
│       │   ├── Java中的变量与常量 --> ( 难度等级: [0.2347, 0.2348) || 挂载数据: 无 ) 
│       │   │   ├── 变量的定义 --> ( 难度等级: [0.2347, 0.2348) || 挂载数据: qa: 5 ) 
│       │   │   ├── 变量的数据类型 --> ( 难度等级: [0.2348, 0.2348) || 挂载数据: 无 ) 
│       │   │   ├── 变量的类型转换32目录Java基础入门(第2版)2.2.4变量的作用域 --> ( 难度等级: [0.2348, 0.2348) || 挂载数据: 无 ) 
│       │   │   ├── Java中的常量 --> ( 难度等级: [0.2348, 0.2348) || 挂载数据: qa: 3 ) 
│       │   │   └── 指数记数法 --> ( 难度等级: [0.2348, 0.2348) || 挂载数据: 无 ) 
│       │   ├── Java中的运算符 --> ( 难度等级: [0.2348, 0.2349) || 挂载数据: 无 ) 
│       │   │   ├── 比较运算符 --> ( 难度等级: [0.2348, 0.2348) || 挂载数据: qa: 2 ) 
│       │   │   ├── 逻辑运算符 --> ( 难度等级: [0.2348, 0.2349) || 挂载数据: qa: 2 ) 
│       │   │   └── 条件运算符 --> ( 难度等级: [0.2349, 0.2349) || 挂载数据: qa: 1 ) 
│       │   ├── 选择结构语句 --> ( 难度等级: [0.2349, 0.2349) || 挂载数据: 无 ) 
│       │   │   ├── if条件语句 --> ( 难度等级: [0.2349, 0.2349) || 挂载数据: qa: 10 ) 
│       │   │   └── switch条件语句 --> ( 难度等级: [0.2349, 0.2349) || 挂载数据: 无 ) 
│       │   └── 循环结构语句 --> ( 难度等级: [0.2349, 0.235) || 挂载数据: 无 ) 
│       │       ├── do…while循环语句 --> ( 难度等级: [0.2349, 0.235) || 挂载数据: qa: 5 ) 
│       │       └── for循环语句 --> ( 难度等级: [0.235, 0.235) || 挂载数据: qa: 2 ) 
│       ├── 集合 --> ( 难度等级: [0.235, 0.2353) || 挂载数据: qa: 4 ) 
│       │   ├── 集合概述 --> ( 难度等级: [0.235, 0.235) || 挂载数据: 无 ) 
│       │   ├── Collection接口 --> ( 难度等级: [0.235, 0.235) || 挂载数据: 无 ) 
│       │   ├── List接口 --> ( 难度等级: [0.235, 0.235) || 挂载数据: 无 ) 
│       │   │   ├── List接口简介 --> ( 难度等级: [0.235, 0.235) || 挂载数据: 无 ) 
│       │   │   ├── ArrayList集合 --> ( 难度等级: [0.235, 0.235) || 挂载数据: qa: 10 ) 
│       │   │   └── LinkedList集合 --> ( 难度等级: [0.235, 0.235) || 挂载数据: qa: 1 ) 
│       │   ├── Collection集合遍历 --> ( 难度等级: [0.235, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── Iterator遍历集合 --> ( 难度等级: [0.235, 0.235) || 挂载数据: qa: 10 ) 
│       │   │   ├── foreach遍历集合 --> ( 难度等级: [0.235, 0.235) || 挂载数据: qa: 2 ) 
│       │   │   └── JDK 8的forEach遍历集合 --> ( 难度等级: [0.235, 0.2351) || 挂载数据: 无 ) 
│       │   ├── Set接口 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── Set接口简介 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── HashSet集合 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   └── TreeSet集合 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   ├── Map接口 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── Map接口简介 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 1 ) 
│       │   │   ├── HashMap集合 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 10 ) 
│       │   │   ├── Map集合遍历 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 5 ) 
│       │   │   ├── TreeMap集合 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 1 ) 
│       │   │   └── Properties集合 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   ├── 常用工具类 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── Collections工具类 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 3 ) 
│       │   │   └── Arrays工具类 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 4 ) 
│       │   ├── 聚合操作 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── 聚合操作简介 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── 创建Stream流对象 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── Stream流的常用方法 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   └── Parallel Stream（并行流） --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   ├── Java集合框架 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   │   ├── 集合接口与实现分离 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 4 ) 
│       │   │   └── 泛型实用方法 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   ├── 集合框架中的接口 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: 无 ) 
│       │   ├── 链表 --> ( 难度等级: [0.2351, 0.2351) || 挂载数据: qa: 2 ) 
│       │   ├── 数组列表 --> ( 难度等级: [0.2351, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 散列集 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 树集 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 优先队列 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 基本映射操作 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: qa: 1 ) 
│       │   │   ├── 更新映射条目 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 映射视图 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 弱散列映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 链接散列集与映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 枚举集与映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   └── 标识散列映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 算法 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: qa: 4 ) 
│       │   │   ├── 二分查找 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 简单算法 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: qa: 10 ) 
│       │   │   ├── 批操作 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   └── 编写自己的算法 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: qa: 2 ) 
│       │   ├── 遗留的集合 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 属性映射 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   │   ├── 栈 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: qa: 2 ) 
│       │   │   └── 位集 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── Java集合简介 --> ( 难度等级: [0.2352, 0.2352) || 挂载数据: 无 ) 
│       │   ├── 编写equals方法 --> ( 难度等级: [0.2352, 0.2353) || 挂载数据: 无 ) 
│       │   ├── 编写equals和hashCode --> ( 难度等级: [0.2353, 0.2353) || 挂载数据: qa: 4 ) 
│       │   ├── 使用TreeMap --> ( 难度等级: [0.2353, 0.2353) || 挂载数据: qa: 4 ) 
│       │   ├── 使用Properties --> ( 难度等级: [0.2353, 0.2353) || 挂载数据: 无 ) 
│       │   └── 使用Deque --> ( 难度等级: [0.2353, 0.2353) || 挂载数据: 无 ) 
│       ├── I/O流 --> ( 难度等级: [0.2353, 0.2356) || 挂载数据: 无 ) 
│       │   ├── I/O流概述 --> ( 难度等级: [0.2353, 0.2354) || 挂载数据: 无 ) 
│       │   ├── 字节流 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── 字节流概述 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字节流读写文件 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件的拷贝 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字节流的缓冲区 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 3 ) 
│       │   │   └── 字节缓冲流 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   ├── File类 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── File类的常用方法 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 10 ) 
│       │   │   ├── 遍历目录下的文件 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   │   ├── 删除文件及目录 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   │   ├── 创建文件对象 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── 文件操作 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件夹操作 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 1 ) 
│       │   │   ├── 目录列表器 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── 目录实用工具 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── 目录的检查及创建 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   │   ├── 文件的创建与删除 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: qa: 5 ) 
│       │   │   └── 获取文件信息 --> ( 难度等级: [0.2354, 0.2354) || 挂载数据: 无 ) 
│       │   ├── RandomAccessFile --> ( 难度等级: [0.2354, 0.2355) || 挂载数据: qa: 3 ) 
│       │   ├── 对象序列化 --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: 无 ) 
│       │   │   ├── 寻找类 --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: 无 ) 
│       │   │   ├── 序列化的控制 --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: qa: 3 ) 
│       │   │   └── 使用“持久性” --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: 无 ) 
│       │   ├── NIO --> ( 难度等级: [0.2355, 0.2356) || 挂载数据: 无 ) 
│       │   │   ├── NIO概述 --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: qa: 6 ) 
│       │   │   ├── Buffer（缓冲器） --> ( 难度等级: [0.2355, 0.2355) || 挂载数据: 无 ) 
│       │   │   ├── Channel（通道） --> ( 难度等级: [0.2355, 0.2356) || 挂载数据: 无 ) 
│       │   │   ├── Java新IO概述 --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: qa: 8 ) 
│       │   │   ├── 使用Buffer --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: 无 ) 
│       │   │   ├── 使用Channel --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: qa: 2 ) 
│       │   │   ├── 字符集和Charset --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: qa: 2 ) 
│       │   │   └── 文件锁 --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: 无 ) 
│       │   └── NIO. --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: 无 ) 
│       │       ├── Path接口 --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: 无 ) 
│       │       └── Files工具类 --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: 无 ) 
│       ├── GUI（图形用户接口） --> ( 难度等级: [0.2356, 0.2359) || 挂载数据: 无 ) 
│       │   ├── Swing概述 --> ( 难度等级: [0.2356, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── Swing特点 --> ( 难度等级: [0.2356, 0.2356) || 挂载数据: qa: 1 ) 
│       │   │   ├── Swing包 --> ( 难度等级: [0.2356, 0.2357) || 挂载数据: qa: 1 ) 
│       │   │   └── 常用Swing组件概述 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   ├── Swing顶级容器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── JFrame --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 9 ) 
│       │   │   └── JDialog --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 2 ) 
│       │   ├── 布局管理器 --> ( 难度等级: [0.2357, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── BorderLayout --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── FlowLayout --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── GridLayout --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 1 ) 
│       │   │   ├── FlowLayout流布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── BorderLayout边界布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── GridLayout网格布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── 绝对布局 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 1 ) 
│       │   │   ├── 流布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── 边界布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── 网格布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── 网格组布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: 无 ) 
│       │   │   ├── FlowLayout布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 1 ) 
│       │   │   ├── BorderLayout布局管理器 --> ( 难度等级: [0.2357, 0.2357) || 挂载数据: qa: 3 ) 
│       │   │   ├── GridLayout布局管理器 --> ( 难度等级: [0.2357, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── GridBagLayout布局管理器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── CardLayout布局管理器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   └── BoxLayout布局管理器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   ├── 事件处理 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 事件处理机制 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── Swing常用事件处理 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 1 ) 
│       │   │   ├── Java事件模型的流程 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 事件适配器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 使用内部类实现监听器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 使用外部类实现监听器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 类本身作为事件监听器类 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 匿名内部类实现监听器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 基本事件处理概念 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 简洁地指定监听器 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 适配器类 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 动作 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   └── AWT事件继承层次 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   ├── Swing常用组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 面板组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 文本组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   ├── JTextField文本框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── JPasswordField密码框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   ├── JTextArea文本域组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   ├── 文本框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 密码框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   └── 文本域组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 标签组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   ├── 按钮组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   ├── JButton按钮组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── JRadioButton单选按钮组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── JCheckBox复选框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   ├── 提交按钮组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 单选按钮组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   │   │   └── 复选框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 8 ) 
│       │   │   ├── 下拉框组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: qa: 1 ) 
│       │   │   └── 菜单组件 --> ( 难度等级: [0.2358, 0.2358) || 挂载数据: 无 ) 
│       │   ├── Swing组件的整合使用——QQ登录 --> ( 难度等级: [0.2358, 0.2359) || 挂载数据: 无 ) 
│       │   │   ├── 案例分析 --> ( 难度等级: [0.2358, 0.2359) || 挂载数据: 无 ) 
│       │   │   └── 案例实现 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: 无 ) 
│       │   └── JavaFX图形用户界面工具 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: 无 ) 
│       │       ├── JavaFX概述 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: 无 ) 
│       │       ├── JavaFX开发环境配置 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: qa: 1 ) 
│       │       ├── JavaFX基础入门 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: 无 ) 
│       │       └── JavaFX可视化管理工具 --> ( 难度等级: [0.2359, 0.2359) || 挂载数据: 无 ) 
│       ├── JDBC --> ( 难度等级: [0.2359, 0.2362) || 挂载数据: qa: 1 ) 
│       │   ├── 什么是JDBC --> ( 难度等级: [0.2359, 0.236) || 挂载数据: 无 ) 
│       │   ├── JDBC常用API --> ( 难度等级: [0.236, 0.2361) || 挂载数据: 无 ) 
│       │   │   ├── Driver接口 --> ( 难度等级: [0.236, 0.236) || 挂载数据: qa: 2 ) 
│       │   │   ├── DriverManager类 --> ( 难度等级: [0.236, 0.236) || 挂载数据: 无 ) 
│       │   │   ├── Connection接口 --> ( 难度等级: [0.236, 0.2361) || 挂载数据: qa: 10 ) 
│       │   │   ├── Statement接口 --> ( 难度等级: [0.2361, 0.2361) || 挂载数据: qa: 2 ) 
│       │   │   ├── PreparedStatement接口 --> ( 难度等级: [0.2361, 0.2361) || 挂载数据: qa: 6 ) 
│       │   │   └── ResultSet接口 --> ( 难度等级: [0.2361, 0.2361) || 挂载数据: qa: 5 ) 
│       │   ├── JDBC编程 --> ( 难度等级: [0.2361, 0.2362) || 挂载数据: 无 ) 
│       │   │   ├── JDBC的编程步骤 --> ( 难度等级: [0.2361, 0.2361) || 挂载数据: qa: 2 ) 
│       │   │   └── 实现第一个JDBC程序 --> ( 难度等级: [0.2361, 0.2362) || 挂载数据: qa: 10 ) 
│       │   └── 案例——使用JDBC实现QQ登录 --> ( 难度等级: [0.2362, 0.2362) || 挂载数据: qa: 9 ) 
│       ├── 网络编程 --> ( 难度等级: [0.2362, 0.2366) || 挂载数据: qa: 1 ) 
│       │   ├── 网络编程基础 --> ( 难度等级: [0.2362, 0.2363) || 挂载数据: qa: 2 ) 
│       │   │   ├── 网络通信协议 --> ( 难度等级: [0.2362, 0.2363) || 挂载数据: 无 ) 
│       │   │   ├── IP地址和端口号 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   ├── InetAddress --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   └── UDP与TCP协议 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   ├── UDP通信 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   ├── UDP通信简介 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 2 ) 
│       │   │   ├── DatagramPacket --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   ├── DatagramSocket --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 1 ) 
│       │   │   ├── UDP网络程序 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   └── UDP案例——聊天程序 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 4 ) 
│       │   ├── TCP通信 --> ( 难度等级: [0.2363, 0.2364) || 挂载数据: 无 ) 
│       │   │   ├── TCP通信简介 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 7 ) 
│       │   │   ├── ServerSocket --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 3 ) 
│       │   │   ├── Socket --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 10 ) 
│       │   │   ├── 简单的TCP网络程序 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: qa: 1 ) 
│       │   │   ├── 多线程的TCP网络程序 --> ( 难度等级: [0.2363, 0.2363) || 挂载数据: 无 ) 
│       │   │   └── TCP案例——文件上传 --> ( 难度等级: [0.2363, 0.2364) || 挂载数据: qa: 1 ) 
│       │   ├── 网络编程的基础知识 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: 无 ) 
│       │   │   └── 网络基础知识 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: qa: 10 ) 
│       │   ├── Java的基本网络支持 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: 无 ) 
│       │   │   ├── 使用URLDecoder和URLEncoder --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: qa: 1 ) 
│       │   │   └── URL、URLConnection和URLPermission --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: 无 ) 
│       │   ├── 基于TCP协议的网络编程 --> ( 难度等级: [0.2364, 0.2365) || 挂载数据: 无 ) 
│       │   │   ├── TCP协议基础 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用ServerSocket创建TCP服务器端 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: 无 ) 
│       │   │   ├── 使用Socket进行通信 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: qa: 4 ) 
│       │   │   ├── 记录用户信息 --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: qa: 5 ) 
│       │   │   ├── 半关闭的Socket --> ( 难度等级: [0.2364, 0.2364) || 挂载数据: 无 ) 
│       │   │   ├── 使用NIO实现非阻塞Socket通信 --> ( 难度等级: [0.2364, 0.2365) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用AIO实现非阻塞通信 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   ├── 基于UDP协议的网络编程 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   │   ├── UDP协议基础 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   │   ├── 使用DatagramSocket发送、接收数据 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   │   └── 使用MulticastSocket实现多点广播 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   ├── 使用代理服务器 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   │   ├── 直接使用Proxy创建连接 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │   │   └── 使用ProxySelector自动选择代理服务器 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: qa: 1 ) 
│       │   └── Java 11标准化的HTTP Client --> ( 难度等级: [0.2365, 0.2366) || 挂载数据: 无 ) 
│       │       ├── 发送同步GET请求 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: qa: 3 ) 
│       │       ├── 发送带请求体的请求 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: qa: 1 ) 
│       │       ├── 发送异步请求 --> ( 难度等级: [0.2365, 0.2365) || 挂载数据: 无 ) 
│       │       ├── WebSocket客户端支持 --> ( 难度等级: [0.2365, 0.2366) || 挂载数据: 无 ) 
│       │       └── 基于WebSocket的多人实时聊天 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       ├── 初识Java --> ( 难度等级: [0.2366, 0.2369) || 挂载数据: 无 ) 
│       │   ├── Java简介 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── Java的版本 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── JavaAPI文档 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── Java的应用领域 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── 怎样学好Java --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── Java API文档 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── Java代码助手 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── 使用IDE --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用IDE练习插件 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   ├── 搭建Java环境 --> ( 难度等级: [0.2366, 0.2367) || 挂载数据: 无 ) 
│       │   │   ├── JDK的下载 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── 配置JDK --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: 无 ) 
│       │   │   ├── 测试开发环境 --> ( 难度等级: [0.2366, 0.2366) || 挂载数据: qa: 5 ) 
│       │   │   └── Windows系统的JDK环境 --> ( 难度等级: [0.2366, 0.2367) || 挂载数据: qa: 1 ) 
│       │   ├── Eclipse开发环境 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: 无 ) 
│       │   │   ├── Eclipse简介 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: 无 ) 
│       │   │   ├── 下载Eclipse --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: qa: 10 ) 
│       │   │   └── Eclipse工作台 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: 无 ) 
│       │   ├── Eclipse的使用 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: 无 ) 
│       │   │   ├── 创建Java类文件 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: 无 ) 
│       │   │   ├── 使用编辑器编写程序代码 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: qa: 1 ) 
│       │   │   └── 运行Java程序 --> ( 难度等级: [0.2367, 0.2367) || 挂载数据: qa: 10 ) 
│       │   ├── 程序调试 --> ( 难度等级: [0.2367, 0.2368) || 挂载数据: 无 ) 
│       │   ├── 难点解答 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── JDK常用的基本组件 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 配置环境变量后，javac运行正常，但编译的时候仍找不到文件 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 9 ) 
│       │   │   ├── Java中变量一定要初始化吗？ --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── switch多分支语句后expression表达式的数据类型 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 多维数组的长度 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 1 ) 
│       │   │   ├── StringBuffer与String的不同之处 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 把数据抽象成类 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 局部变量和全局变量 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 1 ) 
│       │   │   ├── 类的三大特性 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 什么情况下会使用匿名内部类？ --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 6 ) 
│       │   │   ├── 异常的使用原则 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 注意随机数的取值范围 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 5 ) 
│       │   │   ├── “装箱”与“拆箱” --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 集合的使用场合 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 集合的元素数量是变化的 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── Swing组件的层级关系 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 布局的使用 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 输入/输出流的使用 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   ├── 线程的核心方法：run方法 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 8 ) 
│       │   │   ├── 线程的启动 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 2 ) 
│       │   │   ├── 无法连接数据库 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: qa: 1 ) 
│       │   │   ├── SQL语句的使用 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   │   └── AWT与Swing组件的区别 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │   └── Java语言的特性 --> ( 难度等级: [0.2368, 0.2369) || 挂载数据: 无 ) 
│       │       ├── 简单 --> ( 难度等级: [0.2368, 0.2368) || 挂载数据: 无 ) 
│       │       ├── 分布性 --> ( 难度等级: [0.2368, 0.2369) || 挂载数据: 无 ) 
│       │       ├── 解释型 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: 无 ) 
│       │       └── 动态 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: qa: 2 ) 
│       ├── Java语言基础 --> ( 难度等级: [0.2369, 0.2372) || 挂载数据: 无 ) 
│       │   ├── 代码注释 --> ( 难度等级: [0.2369, 0.237) || 挂载数据: qa: 1 ) 
│       │   │   └── 文档注释 --> ( 难度等级: [0.2369, 0.237) || 挂载数据: qa: 1 ) 
│       │   │       ├── 注释的插入 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: qa: 5 ) 
│       │   │       ├── 类注释 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: 无 ) 
│       │   │       ├── 方法注释 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: qa: 2 ) 
│       │   │       ├── 字段注释 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: qa: 2 ) 
│       │   │       ├── 通用注释 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: 无 ) 
│       │   │       ├── 包注释 --> ( 难度等级: [0.2369, 0.2369) || 挂载数据: qa: 10 ) 
│       │   │       └── 注释抽取 --> ( 难度等级: [0.2369, 0.237) || 挂载数据: 无 ) 
│       │   ├── 基本数据类型 --> ( 难度等级: [0.237, 0.237) || 挂载数据: qa: 4 ) 
│       │   │   ├── 整数类型 --> ( 难度等级: [0.237, 0.237) || 挂载数据: 无 ) 
│       │   │   ├── 浮点类型 --> ( 难度等级: [0.237, 0.237) || 挂载数据: 无 ) 
│       │   │   ├── 字符类型 --> ( 难度等级: [0.237, 0.237) || 挂载数据: qa: 1 ) 
│       │   │   ├── 布尔类型 --> ( 难度等级: [0.237, 0.237) || 挂载数据: 无 ) 
│       │   │   ├── 数值中使用下画线分隔 --> ( 难度等级: [0.237, 0.237) || 挂载数据: 无 ) 
│       │   │   └── 使用var定义变量 --> ( 难度等级: [0.237, 0.237) || 挂载数据: 无 ) 
│       │   ├── 数据类型转换 --> ( 难度等级: [0.237, 0.2371) || 挂载数据: qa: 2 ) 
│       │   │   ├── 隐式转换 --> ( 难度等级: [0.237, 0.2371) || 挂载数据: 无 ) 
│       │   │   ├── 显式转换 --> ( 难度等级: [0.2371, 0.2371) || 挂载数据: 无 ) 
│       │   │   ├── 隐式类型转换 --> ( 难度等级: [0.2371, 0.2371) || 挂载数据: qa: 1 ) 
│       │   │   └── 显式类型转换 --> ( 难度等级: [0.2371, 0.2371) || 挂载数据: qa: 6 ) 
│       │   └── Java主类结构 --> ( 难度等级: [0.2371, 0.2372) || 挂载数据: qa: 1 ) 
│       │       ├── 包声明 --> ( 难度等级: [0.2371, 0.2371) || 挂载数据: 无 ) 
│       │       ├── 编写主方法 --> ( 难度等级: [0.2371, 0.2372) || 挂载数据: 无 ) 
│       │       └── 导入API类库 --> ( 难度等级: [0.2372, 0.2372) || 挂载数据: 无 ) 
│       ├── 流程控制 --> ( 难度等级: [0.2372, 0.2375) || 挂载数据: qa: 1 ) 
│       │   ├── 程序结构 --> ( 难度等级: [0.2372, 0.2372) || 挂载数据: 无 ) 
│       │   ├── 条件语句 --> ( 难度等级: [0.2372, 0.2372) || 挂载数据: 无 ) 
│       │   │   └── switch多分支语句 --> ( 难度等级: [0.2372, 0.2372) || 挂载数据: 无 ) 
│       │   ├── 循环语句 --> ( 难度等级: [0.2372, 0.2373) || 挂载数据: qa: 1 ) 
│       │   │   ├── foreach语句 --> ( 难度等级: [0.2372, 0.2373) || 挂载数据: qa: 5 ) 
│       │   │   └── 循环语句的嵌套 --> ( 难度等级: [0.2373, 0.2373) || 挂载数据: qa: 10 ) 
│       │   ├── 复合语句 --> ( 难度等级: [0.2373, 0.2373) || 挂载数据: qa: 1 ) 
│       │   ├── 循环控制 --> ( 难度等级: [0.2373, 0.2373) || 挂载数据: qa: 7 ) 
│       │   ├── 循环 --> ( 难度等级: [0.2373, 0.2374) || 挂载数据: qa: 1 ) 
│       │   ├── 中断控制流程的语句 --> ( 难度等级: [0.2374, 0.2374) || 挂载数据: 无 ) 
│       │   ├── if判断 --> ( 难度等级: [0.2374, 0.2374) || 挂载数据: qa: 10 ) 
│       │   ├── switch多重选择 --> ( 难度等级: [0.2374, 0.2375) || 挂载数据: 无 ) 
│       │   └── while循环 --> ( 难度等级: [0.2375, 0.2375) || 挂载数据: qa: 5 ) 
│       ├── 面向对象编程基础 --> ( 难度等级: [0.2375, 0.2378) || 挂载数据: 无 ) 
│       │   └── 类的主方法 --> ( 难度等级: [0.2375, 0.2378) || 挂载数据: 无 ) 
│       ├── 面向对象核心技术 --> ( 难度等级: [0.2378, 0.2381) || 挂载数据: 无 ) 
│       │   └── 类的多态 --> ( 难度等级: [0.2378, 0.2381) || 挂载数据: 无 ) 
│       │       ├── 向上转型 --> ( 难度等级: [0.2378, 0.2379) || 挂载数据: qa: 3 ) 
│       │       │   └── 忘记对象类型 --> ( 难度等级: [0.2378, 0.2379) || 挂载数据: qa: 1 ) 
│       │       ├── 向下转型 --> ( 难度等级: [0.2379, 0.238) || 挂载数据: qa: 1 ) 
│       │       └── instanceof关键字 --> ( 难度等级: [0.238, 0.2381) || 挂载数据: qa: 1 ) 
│       ├── Swing程序设计 --> ( 难度等级: [0.2381, 0.2384) || 挂载数据: 无 ) 
│       │   ├── 常用窗体 --> ( 难度等级: [0.2381, 0.2382) || 挂载数据: 无 ) 
│       │   │   ├── JFrame窗体 --> ( 难度等级: [0.2381, 0.2382) || 挂载数据: 无 ) 
│       │   │   ├── JDialog对话框窗体 --> ( 难度等级: [0.2382, 0.2382) || 挂载数据: 无 ) 
│       │   │   └── JDialog窗体 --> ( 难度等级: [0.2382, 0.2382) || 挂载数据: qa: 4 ) 
│       │   ├── 常用面板 --> ( 难度等级: [0.2382, 0.2383) || 挂载数据: 无 ) 
│       │   │   ├── JPanel面板 --> ( 难度等级: [0.2382, 0.2382) || 挂载数据: qa: 10 ) 
│       │   │   ├── JScrollPane滚动面板 --> ( 难度等级: [0.2382, 0.2383) || 挂载数据: 无 ) 
│       │   │   └── JScrollPane面板 --> ( 难度等级: [0.2383, 0.2383) || 挂载数据: qa: 1 ) 
│       │   ├── 列表组件 --> ( 难度等级: [0.2383, 0.2384) || 挂载数据: 无 ) 
│       │   │   ├── JComboBox下拉列表框组件 --> ( 难度等级: [0.2383, 0.2383) || 挂载数据: 无 ) 
│       │   │   ├── JList列表框组件 --> ( 难度等级: [0.2383, 0.2383) || 挂载数据: 无 ) 
│       │   │   ├── 下拉列表框组件 --> ( 难度等级: [0.2383, 0.2383) || 挂载数据: 无 ) 
│       │   │   └── 列表框组件 --> ( 难度等级: [0.2383, 0.2384) || 挂载数据: 无 ) 
│       │   └── 事件监听器 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       │       ├── 动作事件监听器 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       │       ├── 键盘事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: qa: 2 ) 
│       │       ├── 鼠标事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: qa: 3 ) 
│       │       ├── 窗体事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       │       │   ├── 捕获窗体焦点变化事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       │       │   ├── 捕获窗体状态变化事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       │       │   └── 捕获其他窗体事件 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: qa: 8 ) 
│       │       ├── 监听事件简介 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: qa: 4 ) 
│       │       └── 焦点事件监听器 --> ( 难度等级: [0.2384, 0.2384) || 挂载数据: 无 ) 
│       ├── I/O（输入/输出） --> ( 难度等级: [0.2384, 0.2387) || 挂载数据: 无 ) 
│       │   ├── 流概述 --> ( 难度等级: [0.2384, 0.2385) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流 --> ( 难度等级: [0.2385, 0.2385) || 挂载数据: 无 ) 
│       │   │   ├── 输入流 --> ( 难度等级: [0.2385, 0.2385) || 挂载数据: qa: 10 ) 
│       │   │   └── 输出流 --> ( 难度等级: [0.2385, 0.2385) || 挂载数据: qa: 10 ) 
│       │   ├── 文件输入/输出流 --> ( 难度等级: [0.2385, 0.2386) || 挂载数据: qa: 2 ) 
│       │   │   ├── FileInputStream类与FileOutputStream类 --> ( 难度等级: [0.2385, 0.2385) || 挂载数据: qa: 3 ) 
│       │   │   └── FileReader类与FileWriter类 --> ( 难度等级: [0.2385, 0.2386) || 挂载数据: 无 ) 
│       │   ├── 带缓冲的输入/输出流 --> ( 难度等级: [0.2386, 0.2386) || 挂载数据: 无 ) 
│       │   │   ├── BufferedInputStream类与BufferedOutputStream类 --> ( 难度等级: [0.2386, 0.2386) || 挂载数据: qa: 1 ) 
│       │   │   └── BufferedReader类与BufferedWriter类 --> ( 难度等级: [0.2386, 0.2386) || 挂载数据: qa: 1 ) 
│       │   ├── 带缓存的输入/输出流 --> ( 难度等级: [0.2386, 0.2387) || 挂载数据: 无 ) 
│       │   ├── 数据输入/输出流 --> ( 难度等级: [0.2387, 0.2387) || 挂载数据: 无 ) 
│       │   └── ZIP压缩输入/输出流 --> ( 难度等级: [0.2387, 0.2387) || 挂载数据: 无 ) 
│       │       ├── 压缩文件 --> ( 难度等级: [0.2387, 0.2387) || 挂载数据: qa: 1 ) 
│       │       └── 解压缩ZIP文件 --> ( 难度等级: [0.2387, 0.2387) || 挂载数据: qa: 4 ) 
│       ├── 使用JDBC操作数据库 --> ( 难度等级: [0.2387, 0.2391) || 挂载数据: 无 ) 
│       │   ├── JDBC概述 --> ( 难度等级: [0.2387, 0.2389) || 挂载数据: 无 ) 
│       │   │   ├── JDBC-ODBC桥 --> ( 难度等级: [0.2387, 0.2388) || 挂载数据: 无 ) 
│       │   │   ├── JDBC技术 --> ( 难度等级: [0.2388, 0.2389) || 挂载数据: qa: 10 ) 
│       │   │   └── JDBC驱动程序的类型 --> ( 难度等级: [0.2389, 0.2389) || 挂载数据: 无 ) 
│       │   └── 数据库操作 --> ( 难度等级: [0.2389, 0.2391) || 挂载数据: 无 ) 
│       │       ├── 数据库基础 --> ( 难度等级: [0.2389, 0.2389) || 挂载数据: 无 ) 
│       │       ├── 数据查询 --> ( 难度等级: [0.2389, 0.2389) || 挂载数据: qa: 10 ) 
│       │       ├── 动态查询 --> ( 难度等级: [0.2389, 0.239) || 挂载数据: qa: 1 ) 
│       │       ├── 添加、修改、删除记录 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 2 ) 
│       │       ├── 数据库基础知识 --> ( 难度等级: [0.239, 0.239) || 挂载数据: 无 ) 
│       │       │   ├── 什么是数据库 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 10 ) 
│       │       │   ├── 数据库的种类及功能 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 1 ) 
│       │       │   └── SQL语言 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 10 ) 
│       │       ├── 向数据库发送SQL语句 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 6 ) 
│       │       ├── 处理查询结果集 --> ( 难度等级: [0.239, 0.239) || 挂载数据: 无 ) 
│       │       ├── 顺序查询 --> ( 难度等级: [0.239, 0.239) || 挂载数据: 无 ) 
│       │       ├── 模糊查询 --> ( 难度等级: [0.239, 0.239) || 挂载数据: qa: 2 ) 
│       │       └── 预处理语句 --> ( 难度等级: [0.239, 0.2391) || 挂载数据: 无 ) 
│       ├── Java绘图 --> ( 难度等级: [0.2391, 0.2394) || 挂载数据: 无 ) 
│       │   ├── Java绘图基础 --> ( 难度等级: [0.2391, 0.2391) || 挂载数据: 无 ) 
│       │   │   ├── Graphics绘图类 --> ( 难度等级: [0.2391, 0.2391) || 挂载数据: 无 ) 
│       │   │   ├── Graphics2D绘图类 --> ( 难度等级: [0.2391, 0.2391) || 挂载数据: qa: 1 ) 
│       │   │   └── Canvas画布类 --> ( 难度等级: [0.2391, 0.2391) || 挂载数据: 无 ) 
│       │   ├── 绘制几何图形 --> ( 难度等级: [0.2391, 0.2392) || 挂载数据: 无 ) 
│       │   ├── 设置颜色与画笔 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: 无 ) 
│       │   │   ├── 设置颜色 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: qa: 2 ) 
│       │   │   └── 设置画笔 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: qa: 10 ) 
│       │   ├── 图像处理 --> ( 难度等级: [0.2392, 0.2393) || 挂载数据: 无 ) 
│       │   │   ├── 绘制图像 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: 无 ) 
│       │   │   ├── 图像缩放 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: qa: 1 ) 
│       │   │   ├── 放大与缩小 --> ( 难度等级: [0.2392, 0.2392) || 挂载数据: 无 ) 
│       │   │   ├── 图像翻转 --> ( 难度等级: [0.2392, 0.2393) || 挂载数据: 无 ) 
│       │   │   ├── 图像旋转 --> ( 难度等级: [0.2393, 0.2393) || 挂载数据: qa: 1 ) 
│       │   │   └── 图像倾斜 --> ( 难度等级: [0.2393, 0.2393) || 挂载数据: 无 ) 
│       │   ├── Graphics --> ( 难度等级: [0.2393, 0.2393) || 挂载数据: 无 ) 
│       │   └── Graphics2D --> ( 难度等级: [0.2393, 0.2394) || 挂载数据: 无 ) 
│       ├── 坦克大战游戏 --> ( 难度等级: [0.2394, 0.2397) || 挂载数据: qa: 5 ) 
│       │   ├── 开发背景 --> ( 难度等级: [0.2394, 0.2394) || 挂载数据: 无 ) 
│       │   ├── 系统开发环境要求 --> ( 难度等级: [0.2394, 0.2394) || 挂载数据: 无 ) 
│       │   ├── 系统功能设计 --> ( 难度等级: [0.2394, 0.2395) || 挂载数据: 无 ) 
│       │   │   ├── 系统功能结构 --> ( 难度等级: [0.2394, 0.2395) || 挂载数据: qa: 1 ) 
│       │   │   └── 系统业务流程 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: qa: 8 ) 
│       │   ├── 枚举设计 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   │   ├── 方向枚举 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: qa: 1 ) 
│       │   │   ├── 游戏模式枚举 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   │   ├── 坦克类型枚举 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   │   └── 墙块类型枚举 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   ├── 公共类设计 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   │   ├── 绘图工具类 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   │   └── 地图工具类 --> ( 难度等级: [0.2395, 0.2395) || 挂载数据: 无 ) 
│       │   ├── 模型类设计 --> ( 难度等级: [0.2395, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 可显示图像的抽象类 --> ( 难度等级: [0.2395, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 玩家坦克类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 电脑坦克类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 2 ) 
│       │   │   ├── 子弹类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 1 ) 
│       │   │   ├── 基地类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 爆炸效果类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 1 ) 
│       │   │   └── 地图类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 1 ) 
│       │   ├── 墙块设计 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 墙块抽象类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   └── 墙块实体类 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 4 ) 
│       │   ├── 窗体类设计 --> ( 难度等级: [0.2396, 0.2397) || 挂载数据: 无 ) 
│       │   │   ├── 主窗体 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   ├── 登录面板 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: qa: 10 ) 
│       │   │   ├── 显示关卡面板 --> ( 难度等级: [0.2396, 0.2396) || 挂载数据: 无 ) 
│       │   │   └── 游戏面板 --> ( 难度等级: [0.2396, 0.2397) || 挂载数据: qa: 8 ) 
│       │   └── 游戏核心功能设计 --> ( 难度等级: [0.2397, 0.2397) || 挂载数据: 无 ) 
│       │       ├── 碰撞检测 --> ( 难度等级: [0.2397, 0.2397) || 挂载数据: qa: 1 ) 
│       │       └── 刷新帧 --> ( 难度等级: [0.2397, 0.2397) || 挂载数据: qa: 2 ) 
│       ├── 对象导论 --> ( 难度等级: [0.2397, 0.24) || 挂载数据: 无 ) 
│       │   ├── 抽象过程 --> ( 难度等级: [0.2397, 0.2397) || 挂载数据: 无 ) 
│       │   ├── 每个对象都有一个接口 --> ( 难度等级: [0.2397, 0.2398) || 挂载数据: qa: 1 ) 
│       │   ├── 每个对象都提供服务 --> ( 难度等级: [0.2398, 0.2398) || 挂载数据: 无 ) 
│       │   ├── 被隐藏的具体实现 --> ( 难度等级: [0.2398, 0.2398) || 挂载数据: qa: 2 ) 
│       │   ├── 复用具体实现 --> ( 难度等级: [0.2398, 0.2399) || 挂载数据: 无 ) 
│       │   ├── 伴随多态的可互换对象 --> ( 难度等级: [0.2399, 0.2399) || 挂载数据: 无 ) 
│       │   ├── 单根继承结构 --> ( 难度等级: [0.2399, 0.2399) || 挂载数据: 无 ) 
│       │   ├── 容器 --> ( 难度等级: [0.2399, 0.24) || 挂载数据: 无 ) 
│       │   │   └── 参数化类型（范型） --> ( 难度等级: [0.2399, 0.24) || 挂载数据: qa: 1 ) 
│       │   └── 并发编程 --> ( 难度等级: [0.24, 0.24) || 挂载数据: qa: 2 ) 
│       ├── 操作符 --> ( 难度等级: [0.24, 0.2403) || 挂载数据: 无 ) 
│       │   ├── 更简单的打印语句 --> ( 难度等级: [0.24, 0.24) || 挂载数据: 无 ) 
│       │   ├── 使用Java操作符 --> ( 难度等级: [0.24, 0.24) || 挂载数据: qa: 1 ) 
│       │   ├── 优先级 --> ( 难度等级: [0.24, 0.2401) || 挂载数据: qa: 2 ) 
│       │   ├── 赋值 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: qa: 6 ) 
│       │   ├── 算术操作符 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: 无 ) 
│       │   │   └── 一元加、减操作符 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: qa: 1 ) 
│       │   ├── 自动递增和递减 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: qa: 1 ) 
│       │   ├── 关系操作符 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: 无 ) 
│       │   │   └── 测试对象的等价性 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: 无 ) 
│       │   ├── 逻辑操作符 --> ( 难度等级: [0.2401, 0.2402) || 挂载数据: 无 ) 
│       │   │   └── 短路 --> ( 难度等级: [0.2401, 0.2402) || 挂载数据: 无 ) 
│       │   ├── 按位操作符 --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   ├── 移位操作符 --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   ├── 三元操作符if-else --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   ├── 字符串操作符 + 和 += --> ( 难度等级: [0.2402, 0.2403) || 挂载数据: 无 ) 
│       │   ├── 使用操作符时常犯的错误 --> ( 难度等级: [0.2403, 0.2403) || 挂载数据: 无 ) 
│       │   ├── 类型转换操作符 --> ( 难度等级: [0.2403, 0.2403) || 挂载数据: 无 ) 
│       │   │   ├── 截尾和舍入 --> ( 难度等级: [0.2403, 0.2403) || 挂载数据: 无 ) 
│       │   │   └── 提升 --> ( 难度等级: [0.2403, 0.2403) || 挂载数据: qa: 1 ) 
│       │   └── Java没有“sizeof” --> ( 难度等级: [0.2403, 0.2403) || 挂载数据: 无 ) 
│       ├── 控制执行流程 --> ( 难度等级: [0.2403, 0.2406) || 挂载数据: 无 ) 
│       │   ├── true和false --> ( 难度等级: [0.2403, 0.2404) || 挂载数据: qa: 9 ) 
│       │   ├── if-else --> ( 难度等级: [0.2404, 0.2404) || 挂载数据: qa: 10 ) 
│       │   ├── 迭代 --> ( 难度等级: [0.2404, 0.2404) || 挂载数据: 无 ) 
│       │   │   ├── do-while --> ( 难度等级: [0.2404, 0.2404) || 挂载数据: qa: 10 ) 
│       │   │   └── 逗号操作符 --> ( 难度等级: [0.2404, 0.2404) || 挂载数据: 无 ) 
│       │   ├── Foreach语法 --> ( 难度等级: [0.2404, 0.2405) || 挂载数据: 无 ) 
│       │   ├── return --> ( 难度等级: [0.2405, 0.2405) || 挂载数据: qa: 10 ) 
│       │   ├── break和continue --> ( 难度等级: [0.2405, 0.2405) || 挂载数据: qa: 5 ) 
│       │   ├── 臭名昭著的“goto” --> ( 难度等级: [0.2405, 0.2406) || 挂载数据: 无 ) 
│       │   └── switch --> ( 难度等级: [0.2406, 0.2406) || 挂载数据: qa: 7 ) 
│       ├── 初始化与清理 --> ( 难度等级: [0.2406, 0.2409) || 挂载数据: 无 ) 
│       │   ├── 用构造器确保初始化 --> ( 难度等级: [0.2406, 0.2407) || 挂载数据: 无 ) 
│       │   ├── 缺省构造器 --> ( 难度等级: [0.2407, 0.2407) || 挂载数据: 无 ) 
│       │   ├── 成员初始化 --> ( 难度等级: [0.2407, 0.2408) || 挂载数据: 无 ) 
│       │   │   └── 指定初始化 --> ( 难度等级: [0.2407, 0.2408) || 挂载数据: qa: 10 ) 
│       │   ├── 构造器初始化 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: 无 ) 
│       │   │   ├── 初始化顺序 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: qa: 2 ) 
│       │   │   ├── 静态数据的初始化 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: 无 ) 
│       │   │   └── 显式的静态初始化 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: qa: 2 ) 
│       │   ├── 数组初始化 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: qa: 2 ) 
│       │   │   └── 可变参数列表 --> ( 难度等级: [0.2408, 0.2408) || 挂载数据: qa: 5 ) 
│       │   ├── 枚举类型 --> ( 难度等级: [0.2408, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 基本enum特性 --> ( 难度等级: [0.2408, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   └── 将静态导入用于enum --> ( 难度等级: [0.2408, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 向enum中添加新方法 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   └── 覆盖enum的方法 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: qa: 9 ) 
│       │   │   ├── switch语句中的enum --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── values（）的神秘之处 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 实现但不继承随机选取 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: qa: 1 ) 
│       │   │   ├── 为组织而使用接口 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 使用EnumSet替代标志 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 使用EnumMap --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 常数相关的方法 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用enum的职责链 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   └── 使用enum的状态机 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 多路分发 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用enum分发 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   │   └── 使用EnumMap分发 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: 无 ) 
│       │   │   ├── 使用枚举类型设置常量 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用枚举类型的优势 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: qa: 1 ) 
│       │   └── 类初始化块 --> ( 难度等级: [0.2409, 0.2409) || 挂载数据: qa: 1 ) 
│       ├── 访问权限控制 --> ( 难度等级: [0.2409, 0.2412) || 挂载数据: 无 ) 
│       │   ├── Java访问权限修饰词 --> ( 难度等级: [0.2409, 0.2411) || 挂载数据: 无 ) 
│       │   │   ├── 包访问权限 --> ( 难度等级: [0.2409, 0.241) || 挂载数据: qa: 10 ) 
│       │   │   ├── public:接口访问权限 --> ( 难度等级: [0.241, 0.241) || 挂载数据: qa: 9 ) 
│       │   │   ├── private: 你无法访问 --> ( 难度等级: [0.241, 0.2411) || 挂载数据: qa: 9 ) 
│       │   │   └── protected：继承访问权限 --> ( 难度等级: [0.2411, 0.2411) || 挂载数据: qa: 2 ) 
│       │   └── 类的访问权限 --> ( 难度等级: [0.2411, 0.2412) || 挂载数据: 无 ) 
│       ├── 复用类 --> ( 难度等级: [0.2412, 0.2416) || 挂载数据: 无 ) 
│       │   ├── 组合语法 --> ( 难度等级: [0.2412, 0.2413) || 挂载数据: 无 ) 
│       │   ├── 继承语法 --> ( 难度等级: [0.2413, 0.2414) || 挂载数据: 无 ) 
│       │   │   └── 初始化基类 --> ( 难度等级: [0.2413, 0.2414) || 挂载数据: 无 ) 
│       │   ├── 代理 --> ( 难度等级: [0.2414, 0.2414) || 挂载数据: 无 ) 
│       │   │   ├── 创建代理对象 --> ( 难度等级: [0.2414, 0.2414) || 挂载数据: 无 ) 
│       │   │   └── 代理类的特性 --> ( 难度等级: [0.2414, 0.2414) || 挂载数据: qa: 2 ) 
│       │   ├── 在组合与继承之间选择 --> ( 难度等级: [0.2414, 0.2415) || 挂载数据: 无 ) 
│       │   └── protected关键字 --> ( 难度等级: [0.2415, 0.2416) || 挂载数据: qa: 1 ) 
│       ├── 持有对象 --> ( 难度等级: [0.2416, 0.2419) || 挂载数据: 无 ) 
│       │   ├── 基本概念 --> ( 难度等级: [0.2416, 0.2416) || 挂载数据: 无 ) 
│       │   ├── 添加一组元素 --> ( 难度等级: [0.2416, 0.2416) || 挂载数据: 无 ) 
│       │   ├── 容器的打印 --> ( 难度等级: [0.2416, 0.2416) || 挂载数据: 无 ) 
│       │   ├── List --> ( 难度等级: [0.2416, 0.2417) || 挂载数据: 无 ) 
│       │   ├── 迭代器 --> ( 难度等级: [0.2417, 0.2417) || 挂载数据: 无 ) 
│       │   │   └── ListIterator --> ( 难度等级: [0.2417, 0.2417) || 挂载数据: qa: 1 ) 
│       │   ├── LinkedList --> ( 难度等级: [0.2417, 0.2417) || 挂载数据: qa: 5 ) 
│       │   ├── Stack --> ( 难度等级: [0.2417, 0.2417) || 挂载数据: qa: 3 ) 
│       │   ├── Set --> ( 难度等级: [0.2417, 0.2418) || 挂载数据: 无 ) 
│       │   ├── Map --> ( 难度等级: [0.2418, 0.2418) || 挂载数据: 无 ) 
│       │   ├── Queue --> ( 难度等级: [0.2418, 0.2418) || 挂载数据: 无 ) 
│       │   │   └── PriorityQueue --> ( 难度等级: [0.2418, 0.2418) || 挂载数据: 无 ) 
│       │   ├── Collection和Iterator --> ( 难度等级: [0.2418, 0.2418) || 挂载数据: qa: 2 ) 
│       │   └── Foreach与迭代器 --> ( 难度等级: [0.2418, 0.2419) || 挂载数据: 无 ) 
│       │       └── 适配器方法惯用法 --> ( 难度等级: [0.2418, 0.2419) || 挂载数据: 无 ) 
│       ├── 通过异常处理错误 --> ( 难度等级: [0.2419, 0.2422) || 挂载数据: 无 ) 
│       │   ├── 概念 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: qa: 1 ) 
│       │   ├── 捕获异常 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: 无 ) 
│       │   │   ├── try块 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: qa: 1 ) 
│       │   │   ├── 异常处理程序 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: qa: 1 ) 
│       │   │   ├── f?inally子句 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: 无 ) 
│       │   │   ├── try-with-Resources语句 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: 无 ) 
│       │   │   └── 分析堆栈轨迹元素 --> ( 难度等级: [0.2419, 0.2419) || 挂载数据: 无 ) 
│       │   ├── 创建自定义异常 --> ( 难度等级: [0.2419, 0.242) || 挂载数据: 无 ) 
│       │   ├── 异常说明 --> ( 难度等级: [0.242, 0.242) || 挂载数据: 无 ) 
│       │   ├── 捕获所有异常 --> ( 难度等级: [0.242, 0.242) || 挂载数据: 无 ) 
│       │   │   ├── 栈轨迹 --> ( 难度等级: [0.242, 0.242) || 挂载数据: 无 ) 
│       │   │   ├── 重新抛出异常 --> ( 难度等级: [0.242, 0.242) || 挂载数据: qa: 10 ) 
│       │   │   └── 异常链 --> ( 难度等级: [0.242, 0.242) || 挂载数据: 无 ) 
│       │   ├── Java标准异常 --> ( 难度等级: [0.242, 0.242) || 挂载数据: 无 ) 
│       │   │   └── 特例: RuntimeException（运行时异常） --> ( 难度等级: [0.242, 0.242) || 挂载数据: qa: 2 ) 
│       │   ├── 使用finally进行清理 --> ( 难度等级: [0.242, 0.2421) || 挂载数据: 无 ) 
│       │   │   ├── finally用来做什么 --> ( 难度等级: [0.242, 0.2421) || 挂载数据: qa: 10 ) 
│       │   │   ├── 在return中使用finally --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: qa: 1 ) 
│       │   │   └── 缺憾：异常丢失 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: 无 ) 
│       │   ├── 构造器 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: 无 ) 
│       │   │   ├── 使用构造器执行初始化 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: qa: 5 ) 
│       │   │   └── 构造器重载 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: qa: 2 ) 
│       │   ├── 异常匹配 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: qa: 1 ) 
│       │   ├── 其他可选方式 --> ( 难度等级: [0.2421, 0.2422) || 挂载数据: qa: 2 ) 
│       │   │   ├── 历史 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: 无 ) 
│       │   │   ├── 观点 --> ( 难度等级: [0.2421, 0.2421) || 挂载数据: 无 ) 
│       │   │   ├── 把异常传递给控制台 --> ( 难度等级: [0.2421, 0.2422) || 挂载数据: 无 ) 
│       │   │   └── 把“受检查异常”转换为“不受检查的异常” --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       │   └── 异常使用指南 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       ├── 类型信息 --> ( 难度等级: [0.2422, 0.2425) || 挂载数据: 无 ) 
│       │   ├── Class对象 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       │   │   ├── 类字面常量 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       │   │   ├── 泛化的Class引用 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: qa: 10 ) 
│       │   │   └── 新的转型语法 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       │   ├── 类型转换前先做检查 --> ( 难度等级: [0.2422, 0.2423) || 挂载数据: 无 ) 
│       │   │   ├── 使用类字面常量 --> ( 难度等级: [0.2422, 0.2422) || 挂载数据: 无 ) 
│       │   │   ├── 动态instanceof --> ( 难度等级: [0.2422, 0.2423) || 挂载数据: qa: 1 ) 
│       │   │   └── 递归计数 --> ( 难度等级: [0.2423, 0.2423) || 挂载数据: 无 ) 
│       │   ├── 注册工厂 --> ( 难度等级: [0.2423, 0.2423) || 挂载数据: 无 ) 
│       │   ├── instanceof与Class的等价性 --> ( 难度等级: [0.2423, 0.2424) || 挂载数据: 无 ) 
│       │   ├── 反射：运行时类信息 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 类方法抽取器 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── Class类与Java反射 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问构造方法 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 访问成员变量 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 访问方法 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 使用Annotation功能 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 定义Annotation类型 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 5 ) 
│       │   │   │   └── 访问Annotation信息 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 10 ) 
│       │   │   ├── 声明异常入门 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 资源 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 利用反射分析类的能力 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 2 ) 
│       │   │   ├── 使用反射在运行时分析 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 使用反射编写泛型数组 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 访问字段 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: 无 ) 
│       │   │   ├── 调用方法 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 3 ) 
│       │   │   ├── 调用构造方法 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 3 ) 
│       │   │   └── 获取继承关系 --> ( 难度等级: [0.2424, 0.2424) || 挂载数据: qa: 2 ) 
│       │   ├── 动态代理 --> ( 难度等级: [0.2424, 0.2425) || 挂载数据: 无 ) 
│       │   └── 空对象 --> ( 难度等级: [0.2425, 0.2425) || 挂载数据: 无 ) 
│       │       └── 模拟对象与桩 --> ( 难度等级: [0.2425, 0.2425) || 挂载数据: 无 ) 
│       ├── 容器深入研究 --> ( 难度等级: [0.2425, 0.2428) || 挂载数据: 无 ) 
│       │   ├── 完整的容器分类法 --> ( 难度等级: [0.2425, 0.2425) || 挂载数据: 无 ) 
│       │   ├── 填充容器 --> ( 难度等级: [0.2425, 0.2426) || 挂载数据: qa: 1 ) 
│       │   │   ├── 一种Generator解决方案 --> ( 难度等级: [0.2425, 0.2425) || 挂载数据: qa: 1 ) 
│       │   │   ├── Map生成器 --> ( 难度等级: [0.2425, 0.2425) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用Abstract类 --> ( 难度等级: [0.2425, 0.2426) || 挂载数据: qa: 1 ) 
│       │   ├── Collection的功能方法 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   ├── 可选操作 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   │   └── 未获支持的操作 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   ├── List的功能方法 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   ├── 队列 --> ( 难度等级: [0.2426, 0.2427) || 挂载数据: qa: 1 ) 
│       │   │   ├── 优先级队列 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: qa: 7 ) 
│       │   │   └── 双向队列 --> ( 难度等级: [0.2426, 0.2427) || 挂载数据: 无 ) 
│       │   ├── 理解Map --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 性能 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: qa: 1 ) 
│       │   │   ├── SortedMap --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   └── LinkedHashMap --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: qa: 3 ) 
│       │   ├── 散列与散列码 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 理解hashCode（） --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为速度而散列 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: qa: 1 ) 
│       │   │   └── 覆盖hashCode（） --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   ├── 选择接口的不同实现 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 性能测试框架 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 对List的选择 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: qa: 7 ) 
│       │   │   ├── 微基准测试的危险 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 对Set的选择 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   └── 对Map的选择 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   ├── 实用方法 --> ( 难度等级: [0.2427, 0.2428) || 挂载数据: qa: 1 ) 
│       │   │   ├── List的排序和查询 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 设定Collection或Map为不可修改 --> ( 难度等级: [0.2427, 0.2428) || 挂载数据: 无 ) 
│       │   │   └── Collection或Map的同步控制 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   ├── 持有引用 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   │   └── WeakHashMap --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   └── Java 1.0/1.1 的容器 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │       ├── Vector和Enumeration --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 3 ) 
│       │       ├── Hashtable --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │       └── BitSet --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       ├── Java I/O系统 --> ( 难度等级: [0.2428, 0.2431) || 挂载数据: 无 ) 
│       │   ├── 输入和输出 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 1 ) 
│       │   │   ├── InputStream类型 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   │   ├── OutputStream类型 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   │   └── 读取输入 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 2 ) 
│       │   ├── 添加属性和有用的接口 --> ( 难度等级: [0.2428, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 通过FilterInputStream从InputStream读取 --> ( 难度等级: [0.2428, 0.2429) || 挂载数据: qa: 1 ) 
│       │   │   └── 通过FilterOutPutStream向OutputStream写入 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │   ├── Reader和Writer --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 数据的来源和去处 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 更改流的行为 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │   │   └── 未发生变化的类 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   ├── I/O流的典型使用方式 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 缓冲的输入文件 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │   │   ├── 从内存中输入 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 格式化的内存输入 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 基本文件输出 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 存储和恢复数据 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │   │   ├── 读取和写入随机访问文件 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │   │   └── 管道流 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │   ├── 文件读写的实用工具 --> ( 难度等级: [0.2429, 0.243) || 挂载数据: 无 ) 
│       │   │   └── 读取二进制文件 --> ( 难度等级: [0.2429, 0.243) || 挂载数据: qa: 10 ) 
│       │   ├── 标准I/O --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │   │   ├── 从标准输入中读取 --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │   │   ├── 将System.out转换成PrintWriter --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │   │   └── 标准I/O重定向 --> ( 难度等级: [0.243, 0.243) || 挂载数据: qa: 10 ) 
│       │   ├── 进程控制 --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │   ├── 压缩 --> ( 难度等级: [0.243, 0.2431) || 挂载数据: 无 ) 
│       │   │   ├── 用GZIP进行简单压缩 --> ( 难度等级: [0.243, 0.243) || 挂载数据: qa: 4 ) 
│       │   │   ├── 用Zip进行多文件存储 --> ( 难度等级: [0.243, 0.2431) || 挂载数据: 无 ) 
│       │   │   └── Java档案文件 --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   ├── XML --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   └── Preferences --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       ├── 注解 --> ( 难度等级: [0.2431, 0.2434) || 挂载数据: 无 ) 
│       │   ├── 基本语法 --> ( 难度等级: [0.2431, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── 定义注解 --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │   └── 元注解 --> ( 难度等级: [0.2431, 0.2432) || 挂载数据: 无 ) 
│       │   ├── 编写注解处理器 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── 注解元素 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 6 ) 
│       │   │   ├── 缺省值限制 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── 生成外部文件 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 9 ) 
│       │   │   ├── 注解不支持继承 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   │   └── 实现处理器 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   ├── 使用apt处理注解 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   ├── 将观察者模式用于apt --> ( 难度等级: [0.2432, 0.2433) || 挂载数据: qa: 1 ) 
│       │   ├── 基于注解的单元测试 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 将@Unit用于泛型 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 不需要任何“套件” --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 实现@Unit --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   └── 移除测试代码 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: qa: 2 ) 
│       │   ├── 限定重写父类方法：@Override --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   ├── Java 9增强的@Deprecated --> ( 难度等级: [0.2433, 0.2434) || 挂载数据: 无 ) 
│       │   ├── 抑制编译器警告：@SuppressWarnings --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: 无 ) 
│       │   └── “堆污染”警告与Java 9增强的@SafeVarargs --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: 无 ) 
│       ├── 并发 --> ( 难度等级: [0.2434, 0.2437) || 挂载数据: qa: 1 ) 
│       │   ├── 并发的多面性 --> ( 难度等级: [0.2434, 0.2435) || 挂载数据: qa: 1 ) 
│       │   │   ├── 更快的执行 --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: 无 ) 
│       │   │   └── 改进代码设计 --> ( 难度等级: [0.2434, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 基本的线程机制 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 定义任务让步 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 使用Executor --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 从任务产生返回值 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 休眠 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 让步 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 编码的变体 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 术语 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   └── 创建有响应的用户界面 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 共享受限资源 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 不正确地访问资源 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: qa: 2 ) 
│       │   │   ├── 解决共享资源竞争 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 原子性与易变性 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: qa: 1 ) 
│       │   │   ├── 原子类 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 临界资源 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 在其他对象上同步 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   └── 线程局部存储 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 终结任务 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 装饰性花园 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 在阻塞时终结 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 中断 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: qa: 1 ) 
│       │   │   └── 检查中断 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 线程之间的协作 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── wait（）与notifyAll（） --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── notify（）与notifyAll（） --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: qa: 1 ) 
│       │   │   ├── 生产者与消费者 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   └── 任务间使用管道进行输入/输出 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 死锁 --> ( 难度等级: [0.2435, 0.2436) || 挂载数据: 无 ) 
│       │   ├── 新类库中的构件 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 1 ) 
│       │   │   ├── CountDownLatch --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── DelayQueue --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── PriorityBlockingQueue --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 使用ScheduledExecutor的温室控制器 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── Semaphore --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   └── Exchange --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   ├── 仿真 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 银行出纳仿真 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 饭店仿真 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   └── 分发工作 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 2 ) 
│       │   ├── 性能调优 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 比较各类互斥技术 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 免锁容器 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 乐观锁 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   │   └── ReadWriteLock --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   ├── 活动对象 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   ├── 进阶读物 --> ( 难度等级: [0.2436, 0.2437) || 挂载数据: 无 ) 
│       │   ├── 线程状态 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 新建线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: qa: 2 ) 
│       │   │   ├── 可运行线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: qa: 4 ) 
│       │   │   ├── 阻塞和等待线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: qa: 4 ) 
│       │   │   └── 终止线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   ├── 线程属性 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 中断线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 守护线程 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 线程名 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: qa: 1 ) 
│       │   │   └── 未捕获异常的处理器 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   ├── 线程安全的集合 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 阻塞队列 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 映射条目的原子更新 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 对并发散列映射的批操作 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 并发集视图 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 写数组的拷贝 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   ├── 并行数组算法 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   │   └── 较早的线程安全集合 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │   └── 异步计算 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │       ├── 可完成Future --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │       ├── 组合可完成Future --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: 无 ) 
│       │       └── 用户界面回调中的长时间运行任务 --> ( 难度等级: [0.2437, 0.2437) || 挂载数据: qa: 1 ) 
│       ├── 图形化用户界面 --> ( 难度等级: [0.2437, 0.2441) || 挂载数据: 无 ) 
│       │   ├── Swing基础 --> ( 难度等级: [0.2437, 0.2438) || 挂载数据: 无 ) 
│       │   │   └── 一个显示框架 --> ( 难度等级: [0.2437, 0.2438) || 挂载数据: 无 ) 
│       │   ├── 创建按钮 --> ( 难度等级: [0.2438, 0.2438) || 挂载数据: 无 ) 
│       │   ├── 捕获事件 --> ( 难度等级: [0.2438, 0.2438) || 挂载数据: 无 ) 
│       │   ├── 文本区域 --> ( 难度等级: [0.2438, 0.2439) || 挂载数据: 无 ) 
│       │   ├── 控制布局 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── GridBagLayout --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   ├── 绝对定位 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   └── BoxLayout --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   ├── Swing事件模型 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 事件与监听器的类型 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   └── 跟踪多个事件 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   ├── Swing组件一览 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 按钮 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 图标 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   ├── 工具提示 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 10 ) 
│       │   │   ├── 文本域 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 边框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 滚动面板 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 一个迷你编辑器 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 复选框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 2 ) 
│       │   │   ├── 单选按钮 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 组合框（下拉列表） --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 列表框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 页签面板 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 6 ) 
│       │   │   ├── 菜单 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建菜单栏 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建弹出式菜单 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 定制个性化菜单 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 菜单构建 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 菜单项中的图标 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 弹出菜单 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 键盘助记符和加速器 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 启用和禁用菜单项 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 工具条 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 弹出式菜单 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 绘图 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 对话框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 选项对话框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建对话框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 数据交换 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 文件对话框 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │   ├── Swing组件上的HTML --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 滑块与进度条 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   ├── 选择外观 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │   └── 树、表格和剪贴板 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │       ├── 传递文本 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: qa: 1 ) 
│       │   │       ├── 使用系统剪贴板传递图像 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │       ├── 使用本地剪贴板传递对象引用 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   │       └── 通过系统剪贴板传递Java对象 --> ( 难度等级: [0.2439, 0.2439) || 挂载数据: 无 ) 
│       │   ├── JNLP与Java Web Start --> ( 难度等级: [0.2439, 0.244) || 挂载数据: 无 ) 
│       │   ├── 可视化编程与JavaBean --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── JavaBean是什么 --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 10 ) 
│       │   │   ├── 使用Introspector抽取出BeanInfo --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── 一个更复杂的Bean --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── 把Bean打包 --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 4 ) 
│       │   │   ├── 对更复杂的Bean的支持 --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 3 ) 
│       │   │   └── 更多有关Bean的读物 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   ├── Swing的可替换选择 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   ├── 用Flex构建Flash Web客户端 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── Hello, Flex --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 4 ) 
│       │   │   ├── 编译MXML --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 10 ) 
│       │   │   ├── MXML与ActionScript --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── 效果与风格 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── 事件 --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 1 ) 
│       │   │   ├── 连接到Java --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   │   ├── 数据模型与数据绑定 --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 1 ) 
│       │   │   └── 构建和部署 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │   └── 创建SWT应用 --> ( 难度等级: [0.244, 0.2441) || 挂载数据: 无 ) 
│       │       ├── 安装SWT --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │       ├── Hello, SWT --> ( 难度等级: [0.244, 0.244) || 挂载数据: qa: 2 ) 
│       │       ├── 根除冗余代码 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │       ├── 菜单 --> ( 难度等级: [0.244, 0.244) || 挂载数据: 无 ) 
│       │       ├── 页签面板、按钮和事件 --> ( 难度等级: [0.244, 0.2441) || 挂载数据: 无 ) 
│       │       ├── 图形 --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: qa: 1 ) 
│       │       ├── SWT中的并发 --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: 无 ) 
│       │       └── SWT还是Swing --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: 无 ) 
│       ├── 基础知识 --> ( 难度等级: [0.2441, 0.2444) || 挂载数据: qa: 1 ) 
│       │   ├── 熟悉Eclipse开发工具 --> ( 难度等级: [0.2441, 0.2442) || 挂载数据: 无 ) 
│       │   │   └── 熟悉Eclipse --> ( 难度等级: [0.2441, 0.2442) || 挂载数据: 无 ) 
│       │   │       ├── 安装Eclipse的中文语言包 --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: qa: 10 ) 
│       │   │       ├── 透视图与视图 --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: 无 ) 
│       │   │       ├── 菜单栏 --> ( 难度等级: [0.2441, 0.2441) || 挂载数据: 无 ) 
│       │   │       ├── 工具栏 --> ( 难度等级: [0.2441, 0.2442) || 挂载数据: 无 ) 
│       │   │       ├── “包资源管理器”视图 --> ( 难度等级: [0.2442, 0.2442) || 挂载数据: 无 ) 
│       │   │       └── “控制台”视图 --> ( 难度等级: [0.2442, 0.2442) || 挂载数据: 无 ) 
│       │   └── 数字处理类 --> ( 难度等级: [0.2442, 0.2444) || 挂载数据: 无 ) 
│       │       ├── 数字格式化 --> ( 难度等级: [0.2442, 0.2443) || 挂载数据: 无 ) 
│       │       ├── 数学运算 --> ( 难度等级: [0.2443, 0.2443) || 挂载数据: 无 ) 
│       │       ├── 随机数 --> ( 难度等级: [0.2443, 0.2443) || 挂载数据: qa: 6 ) 
│       │       │   └── Math.random方法 --> ( 难度等级: [0.2443, 0.2443) || 挂载数据: 无 ) 
│       │       └── 大数字运算 --> ( 难度等级: [0.2443, 0.2444) || 挂载数据: qa: 10 ) 
│       │           ├── BigInteger --> ( 难度等级: [0.2443, 0.2444) || 挂载数据: 无 ) 
│       │           └── BigDecimal --> ( 难度等级: [0.2444, 0.2444) || 挂载数据: qa: 2 ) 
│       ├── 核心技术 --> ( 难度等级: [0.2444, 0.2447) || 挂载数据: qa: 1 ) 
│       │   ├── 类的高级特性 --> ( 难度等级: [0.2444, 0.2445) || 挂载数据: 无 ) 
│       │   │   └── final变量 --> ( 难度等级: [0.2444, 0.2445) || 挂载数据: 无 ) 
│       │   ├── 集合类 --> ( 难度等级: [0.2445, 0.2446) || 挂载数据: qa: 1 ) 
│       │   │   ├── 集合类概述 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 1 ) 
│       │   │   ├── List集合 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── List接口的实现类 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 改进的List接口和ListIterator接口 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: 无 ) 
│       │   │   │   ├── ArrayList和Vector实现类 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 6 ) 
│       │   │   │   └── 固定长度的List --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: 无 ) 
│       │   │   ├── Set集合 --> ( 难度等级: [0.2445, 0.2446) || 挂载数据: 无 ) 
│       │   │   │   ├── HashSet类 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── LinkedHashSet类 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: 无 ) 
│       │   │   │   ├── TreeSet类 --> ( 难度等级: [0.2445, 0.2445) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── EnumSet类 --> ( 难度等级: [0.2445, 0.2446) || 挂载数据: 无 ) 
│       │   │   │   └── 各Set实现类的性能分析 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: qa: 10 ) 
│       │   │   └── Map集合 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: 无 ) 
│       │   │       └── Map接口的实现类 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: qa: 10 ) 
│       │   └── 网络通信 --> ( 难度等级: [0.2446, 0.2447) || 挂载数据: 无 ) 
│       │       ├── 网络程序设计基础 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: 无 ) 
│       │       │   ├── 局域网与因特网 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: qa: 1 ) 
│       │       │   ├── 网络协议 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: 无 ) 
│       │       │   └── 端口和套接字 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: 无 ) 
│       │       ├── TCP程序设计基础 --> ( 难度等级: [0.2446, 0.2447) || 挂载数据: 无 ) 
│       │       │   ├── InetAddress类 --> ( 难度等级: [0.2446, 0.2446) || 挂载数据: 无 ) 
│       │       │   └── ServerSocket类 --> ( 难度等级: [0.2446, 0.2447) || 挂载数据: qa: 1 ) 
│       │       └── UDP程序设计基础 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │           ├── DatagramPacket类 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │           └── DatagramSocket类 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       ├── 高级应用 --> ( 难度等级: [0.2447, 0.245) || 挂载数据: 无 ) 
│       │   ├── Swing表格组件 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   ├── 利用JTable类直接创建表格 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 创建表格 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   │   ├── 定制表格 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   │   └── 操纵表格 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   └── 提供行标题栏的表格 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: qa: 3 ) 
│       │   ├── Swing树组件 --> ( 难度等级: [0.2447, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 处理选中节点事件 --> ( 难度等级: [0.2447, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 遍历树节点 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: qa: 4 ) 
│       │   │   ├── 定制树 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 维护树模型 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   └── 处理展开节点事件 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   ├── Swing其他高级组件 --> ( 难度等级: [0.2448, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── 高级组件面板 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   │   ├── 分割面板 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 选项卡面板 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   │   └── 桌面面板和内部窗体 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 文件选择器 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件选择对话框 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 使用文件过滤器 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 系统托盘 --> ( 难度等级: [0.2448, 0.2449) || 挂载数据: 无 ) 
│       │   │   └── 桌面集成控件 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   ├── 高级事件处理 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── 选项事件 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   └── 表格模型事件 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   └── AWT绘图 --> ( 难度等级: [0.2449, 0.245) || 挂载数据: 无 ) 
│       │       ├── 绘制图形 --> ( 难度等级: [0.2449, 0.245) || 挂载数据: 无 ) 
│       │       ├── 绘图颜色与画笔属性 --> ( 难度等级: [0.245, 0.245) || 挂载数据: 无 ) 
│       │       │   └── 画笔属性 --> ( 难度等级: [0.245, 0.245) || 挂载数据: qa: 2 ) 
│       │       ├── 绘制文本 --> ( 难度等级: [0.245, 0.245) || 挂载数据: 无 ) 
│       │       │   ├── 设置字体 --> ( 难度等级: [0.245, 0.245) || 挂载数据: qa: 1 ) 
│       │       │   └── 显示文字 --> ( 难度等级: [0.245, 0.245) || 挂载数据: qa: 9 ) 
│       │       └── 绘制图片 --> ( 难度等级: [0.245, 0.245) || 挂载数据: qa: 1 ) 
│       ├── 理解面向对象 --> ( 难度等级: [0.245, 0.2453) || 挂载数据: 无 ) 
│       │   ├── UML（统一建模语言）介绍 --> ( 难度等级: [0.245, 0.2452) || 挂载数据: 无 ) 
│       │   │   ├── 用例图 --> ( 难度等级: [0.245, 0.245) || 挂载数据: 无 ) 
│       │   │   ├── 类图 --> ( 难度等级: [0.245, 0.245) || 挂载数据: 无 ) 
│       │   │   ├── 组件图 --> ( 难度等级: [0.245, 0.2451) || 挂载数据: 无 ) 
│       │   │   ├── 部署图 --> ( 难度等级: [0.2451, 0.2451) || 挂载数据: 无 ) 
│       │   │   ├── 顺序图 --> ( 难度等级: [0.2451, 0.2451) || 挂载数据: 无 ) 
│       │   │   ├── 活动图 --> ( 难度等级: [0.2451, 0.2451) || 挂载数据: qa: 8 ) 
│       │   │   └── 状态机图 --> ( 难度等级: [0.2451, 0.2452) || 挂载数据: 无 ) 
│       │   └── Java的面向对象特征 --> ( 难度等级: [0.2452, 0.2453) || 挂载数据: 无 ) 
│       ├── Java基础类库 --> ( 难度等级: [0.2453, 0.2456) || 挂载数据: 无 ) 
│       │   ├── 与用户互动 --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: qa: 4 ) 
│       │   │   ├── 运行Java程序的参数 --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: 无 ) 
│       │   │   └── 使用Scanner获取键盘输入 --> ( 难度等级: [0.2454, 0.2454) || 挂载数据: qa: 2 ) 
│       │   ├── 系统相关 --> ( 难度等级: [0.2454, 0.2455) || 挂载数据: qa: 5 ) 
│       │   ├── Java 11改进的国际化与格式化 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── Java国际化的思路 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: qa: 7 ) 
│       │   │   ├── Java支持的国家和语言 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: qa: 1 ) 
│       │   │   ├── 完成程序国际化 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── 使用MessageFormat处理包含占位符的字符串 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── 使用类文件代替资源文件 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── Java 9新增的日志API --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── 使用NumberFormat格式化数字 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── 使用DateFormat格式化日期、时间 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: 无 ) 
│       │   │   └── 使用SimpleDateFormat格式化日期 --> ( 难度等级: [0.2455, 0.2455) || 挂载数据: qa: 1 ) 
│       │   └── Java 8新增的日期、时间格式器 --> ( 难度等级: [0.2455, 0.2456) || 挂载数据: qa: 1 ) 
│       │       ├── 使用DateTimeFormatter完成格式化 --> ( 难度等级: [0.2455, 0.2456) || 挂载数据: 无 ) 
│       │       └── 使用DateTimeFormatter解析字符串 --> ( 难度等级: [0.2456, 0.2456) || 挂载数据: qa: 4 ) 
│       ├── Java集合 --> ( 难度等级: [0.2456, 0.2459) || 挂载数据: 无 ) 
│       │   ├── Java集合概述 --> ( 难度等级: [0.2456, 0.2457) || 挂载数据: 无 ) 
│       │   ├── Java 11增强的Collection和Iterator接口 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── 使用Lambda表达式遍历集合 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── 使用Iterator遍历集合元素 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: qa: 7 ) 
│       │   │   ├── 使用Lambda表达式遍历Iterator --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── 使用foreach循环遍历集合元素 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── 使用Predicate操作集合 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   └── 使用Stream操作集合 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   ├── Queue集合 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── PriorityQueue实现类 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── Deque接口与ArrayDeque实现类 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── LinkedList实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   └── 各种线性表的性能分析 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── 增强的Map集合 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── Java 8为Map新增的方法 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 改进的HashMap和Hashtable实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: qa: 1 ) 
│       │   │   ├── LinkedHashMap实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 使用Properties读写属性文件 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── SortedMap接口和TreeMap实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── WeakHashMap实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── IdentityHashMap实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── EnumMap实现类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   └── 各Map实现类的性能分析 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── HashSet和HashMap的性能选项 --> ( 难度等级: [0.2458, 0.2459) || 挂载数据: 无 ) 
│       │   └── 操作集合的工具类：Collections --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │       ├── 排序操作 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │       ├── 同步控制 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │       ├── 设置不可变集合 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │       └── Java 9新增的不可变集合 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       ├── AWT编程 --> ( 难度等级: [0.2459, 0.2462) || 挂载数据: 无 ) 
│       │   ├── AWT容器 --> ( 难度等级: [0.2459, 0.246) || 挂载数据: qa: 7 ) 
│       │   ├── AWT常用组件 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   │   ├── 基本组件 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   │   └── 对话框（Dialog） --> ( 难度等级: [0.246, 0.246) || 挂载数据: qa: 3 ) 
│       │   ├── AWT菜单 --> ( 难度等级: [0.246, 0.2461) || 挂载数据: 无 ) 
│       │   │   └── 右键菜单 --> ( 难度等级: [0.246, 0.2461) || 挂载数据: qa: 1 ) 
│       │   ├── 在AWT中绘图 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: 无 ) 
│       │   │   ├── 画图的实现原理 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用Graphics类 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: qa: 1 ) 
│       │   ├── 处理位图 --> ( 难度等级: [0.2461, 0.2462) || 挂载数据: 无 ) 
│       │   │   ├── Image抽象类和BufferedImage实现类 --> ( 难度等级: [0.2461, 0.2462) || 挂载数据: 无 ) 
│       │   │   └── Java 9增强的ImageIO --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: qa: 1 ) 
│       │   └── 拖放功能 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │       ├── 拖放目标 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │       └── 拖放源 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: qa: 1 ) 
│       ├── Swing编程 --> ( 难度等级: [0.2462, 0.2466) || 挂载数据: 无 ) 
│       │   ├── Swing基本组件的用法 --> ( 难度等级: [0.2462, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── AWT组件的Swing实现 --> ( 难度等级: [0.2462, 0.2463) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为组件设置边框 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── Swing组件的双缓冲和键盘驱动 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── 使用JToolBar创建工具条 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── 使用JFileChooser和JColorChooser --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用JOptionPane --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   ├── Swing中的特殊容器 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── 使用JSplitPane --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   ├── 使用JTabbedPane --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   └── 使用JLayeredPane、JDesktopPane和JInternalFrame --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   ├── Swing简化的拖放功能 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   ├── Java 7新增的Swing功能 --> ( 难度等级: [0.2463, 0.2464) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用JLayer装饰组件 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   │   └── 创建透明、不规则形状窗口 --> ( 难度等级: [0.2463, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 使用JProgressBar、ProgressMonitor和BoundedRangeModel创建进度条 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: 无 ) 
│       │   │   ├── 创建进度条 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: qa: 1 ) 
│       │   │   └── 创建进度对话框 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 使用JSlider和BoundedRangeModel创建滑动条 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 使用JSpinner和SpinnerModel创建微调控制器 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 使用JList、JComboBox创建列表框 --> ( 难度等级: [0.2464, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 不强制存储列表项的ListModel和ComboBoxModel --> ( 难度等级: [0.2464, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 强制存储列表项的DefaultListModel和DefaultComboBoxModel --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   └── 使用ListCellRenderer改变列表项外观 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   ├── 使用JTree和TreeModel创建树 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 创建树 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: qa: 7 ) 
│       │   │   ├── 拖动、编辑树节点 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 监听节点事件 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 使用DefaultTreeCellRenderer改变节点外观 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 扩展DefaultTreeCellRenderer改变节点外观 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   └── 实现TreeCellRenderer改变节点外观 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   ├── 使用JTable和TableModel创建表格 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── TableModel和监听器 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── TableColumnModel和监听器 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   ├── 实现排序 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: qa: 1 ) 
│       │   │   ├── 绘制单元格内容 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   │   └── 编辑单元格内容 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   └── 使用JFormattedTextField和JTextPane创建格式文本 --> ( 难度等级: [0.2465, 0.2466) || 挂载数据: 无 ) 
│       │       ├── 监听Document的变化 --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │       ├── 使用JPasswordField --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │       ├── 使用JFormattedTextField --> ( 难度等级: [0.2465, 0.2466) || 挂载数据: 无 ) 
│       │       ├── 使用JEditorPane --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: 无 ) 
│       │       └── 使用JTextPane --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: 无 ) 
│       ├── 注解（Annotation） --> ( 难度等级: [0.2466, 0.2469) || 挂载数据: 无 ) 
│       │   ├── JDK的元注解 --> ( 难度等级: [0.2466, 0.2467) || 挂载数据: 无 ) 
│       │   │   ├── 使用@Retention --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用@Target --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: 无 ) 
│       │   │   ├── 使用@Documented --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: 无 ) 
│       │   │   └── 使用@Inherited --> ( 难度等级: [0.2466, 0.2467) || 挂载数据: 无 ) 
│       │   ├── 自定义注解 --> ( 难度等级: [0.2467, 0.2468) || 挂载数据: 无 ) 
│       │   │   ├── 提取注解信息 --> ( 难度等级: [0.2467, 0.2467) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用注解的示例 --> ( 难度等级: [0.2467, 0.2468) || 挂载数据: qa: 6 ) 
│       │   └── 编译时处理注解 --> ( 难度等级: [0.2468, 0.2469) || 挂载数据: 无 ) 
│       ├── 输入/输出 --> ( 难度等级: [0.2469, 0.2472) || 挂载数据: 无 ) 
│       │   ├── 理解Java的IO流 --> ( 难度等级: [0.2469, 0.2469) || 挂载数据: 无 ) 
│       │   │   ├── 流的分类 --> ( 难度等级: [0.2469, 0.2469) || 挂载数据: qa: 10 ) 
│       │   │   └── 流的概念模型 --> ( 难度等级: [0.2469, 0.2469) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流体系 --> ( 难度等级: [0.2469, 0.247) || 挂载数据: 无 ) 
│       │   │   ├── 处理流的用法 --> ( 难度等级: [0.2469, 0.2469) || 挂载数据: qa: 3 ) 
│       │   │   ├── 输入/输出流体系 --> ( 难度等级: [0.2469, 0.247) || 挂载数据: 无 ) 
│       │   │   └── 推回输入流 --> ( 难度等级: [0.247, 0.247) || 挂载数据: 无 ) 
│       │   ├── 重定向标准输入/输出 --> ( 难度等级: [0.247, 0.247) || 挂载数据: 无 ) 
│       │   ├── Java虚拟机读写其他进程的数据 --> ( 难度等级: [0.247, 0.2471) || 挂载数据: 无 ) 
│       │   ├── Java 9改进的对象序列化 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: 无 ) 
│       │   │   ├── 序列化的含义和意义 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用对象流实现序列化 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: qa: 1 ) 
│       │   │   ├── 对象引用的序列化 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: qa: 2 ) 
│       │   │   ├── Java 9增加的过滤功能 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: qa: 1 ) 
│       │   │   ├── 自定义序列化 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: 无 ) 
│       │   │   ├── 另一种自定义序列化机制 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: 无 ) 
│       │   │   └── 版本 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: qa: 5 ) 
│       │   └── NIO.2的功能和用法 --> ( 难度等级: [0.2471, 0.2472) || 挂载数据: 无 ) 
│       │       ├── Path、Paths和Files核心API --> ( 难度等级: [0.2471, 0.2472) || 挂载数据: 无 ) 
│       │       ├── 使用WatchService监控文件变化 --> ( 难度等级: [0.2472, 0.2472) || 挂载数据: 无 ) 
│       │       └── 访问文件属性 --> ( 难度等级: [0.2472, 0.2472) || 挂载数据: 无 ) 
│       ├── Java程序设计概述 --> ( 难度等级: [0.2472, 0.2475) || 挂载数据: 无 ) 
│       │   ├── Java程序设计平台 --> ( 难度等级: [0.2472, 0.2473) || 挂载数据: qa: 9 ) 
│       │   ├── Java“白皮书”的关键术语 --> ( 难度等级: [0.2473, 0.2473) || 挂载数据: 无 ) 
│       │   │   └── 解释型 --> ( 难度等级: [0.2473, 0.2473) || 挂载数据: 无 ) 
│       │   ├── Java发展简史 --> ( 难度等级: [0.2473, 0.2474) || 挂载数据: 无 ) 
│       │   └── 关于Java的常见误解 --> ( 难度等级: [0.2474, 0.2475) || 挂载数据: 无 ) 
│       ├── Java程序设计环境 --> ( 难度等级: [0.2475, 0.2478) || 挂载数据: 无 ) 
│       │   ├── 安装Java开发工具包 --> ( 难度等级: [0.2475, 0.2476) || 挂载数据: 无 ) 
│       │   │   ├── 设置JDK --> ( 难度等级: [0.2475, 0.2475) || 挂载数据: 无 ) 
│       │   │   └── 安装库源文件和文档 --> ( 难度等级: [0.2475, 0.2476) || 挂载数据: 无 ) 
│       │   ├── 使用命令行工具 --> ( 难度等级: [0.2476, 0.2477) || 挂载数据: qa: 1 ) 
│       │   ├── 使用集成开发环境 --> ( 难度等级: [0.2477, 0.2477) || 挂载数据: 无 ) 
│       │   └── JShell --> ( 难度等级: [0.2477, 0.2478) || 挂载数据: 无 ) 
│       ├── Java的基本程序设计结构 --> ( 难度等级: [0.2478, 0.2481) || 挂载数据: 无 ) 
│       │   ├── 一个简单的Java应用程序 --> ( 难度等级: [0.2478, 0.248) || 挂载数据: 无 ) 
│       │   └── 大数 --> ( 难度等级: [0.248, 0.2481) || 挂载数据: 无 ) 
│       ├── 泛型程序设计 --> ( 难度等级: [0.2481, 0.2484) || 挂载数据: 无 ) 
│       │   ├── 定义简单泛型类 --> ( 难度等级: [0.2481, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 类型变量的限定 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 泛型代码和虚拟机 --> ( 难度等级: [0.2482, 0.2483) || 挂载数据: qa: 2 ) 
│       │   │   ├── 类型擦除 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: qa: 5 ) 
│       │   │   ├── 转换泛型表达式 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│       │   │   ├── 转换泛型方法 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: qa: 4 ) 
│       │   │   └── 调用遗留代码 --> ( 难度等级: [0.2482, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 限制与局限性 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   ├── 运行时类型查询只适用于原始类型 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   ├── 不能创建参数化类型的数组 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   ├── Varargs警告 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   ├── 不能构造泛型数组 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   ├── 泛型类的静态上下文中类型变量无效 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: qa: 1 ) 
│       │   │   ├── 可以取消对检查型异常的检查 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   │   └── 注意擦除后的冲突 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 泛型类型的继承规则 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 通配符类型 --> ( 难度等级: [0.2483, 0.2484) || 挂载数据: 无 ) 
│       │   │   ├── 通配符概念 --> ( 难度等级: [0.2483, 0.2484) || 挂载数据: 无 ) 
│       │   │   ├── 通配符的超类型限定 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: 无 ) 
│       │   │   ├── 无限定通配符 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: qa: 1 ) 
│       │   │   └── 通配符捕获 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: qa: 1 ) 
│       │   └── 反射和泛型 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: 无 ) 
│       │       ├── 泛型Class类 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: 无 ) 
│       │       ├── 使用Class<T>参数进行类型匹配 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: qa: 1 ) 
│       │       ├── 虚拟机中的泛型类型信息 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: 无 ) 
│       │       └── 类型字面量 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: qa: 1 ) 
│       ├── 图形用户界面程序设计 --> ( 难度等级: [0.2484, 0.2487) || 挂载数据: 无 ) 
│       │   ├── Java用户界面工具包简史 --> ( 难度等级: [0.2484, 0.2485) || 挂载数据: 无 ) 
│       │   ├── 显示窗体 --> ( 难度等级: [0.2485, 0.2486) || 挂载数据: 无 ) 
│       │   │   ├── 创建窗体 --> ( 难度等级: [0.2485, 0.2486) || 挂载数据: qa: 2 ) 
│       │   │   └── 窗体属性 --> ( 难度等级: [0.2486, 0.2486) || 挂载数据: 无 ) 
│       │   ├── 在组件中显示信息 --> ( 难度等级: [0.2486, 0.2487) || 挂载数据: 无 ) 
│       │   │   ├── 处理2D图形 --> ( 难度等级: [0.2486, 0.2486) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用颜色 --> ( 难度等级: [0.2486, 0.2486) || 挂载数据: 无 ) 
│       │   │   ├── 使用字体 --> ( 难度等级: [0.2486, 0.2487) || 挂载数据: 无 ) 
│       │   │   └── 显示图像 --> ( 难度等级: [0.2487, 0.2487) || 挂载数据: 无 ) 
│       │   └── 首选项API --> ( 难度等级: [0.2487, 0.2487) || 挂载数据: 无 ) 
│       ├── Swing用户界面组件 --> ( 难度等级: [0.2487, 0.2491) || 挂载数据: 无 ) 
│       │   ├── 布局管理概述 --> ( 难度等级: [0.2487, 0.2488) || 挂载数据: 无 ) 
│       │   │   ├── 边框布局 --> ( 难度等级: [0.2487, 0.2488) || 挂载数据: 无 ) 
│       │   │   └── 网格布局 --> ( 难度等级: [0.2488, 0.2488) || 挂载数据: 无 ) 
│       │   ├── 文本输入 --> ( 难度等级: [0.2488, 0.2489) || 挂载数据: 无 ) 
│       │   │   ├── 密码域 --> ( 难度等级: [0.2488, 0.2489) || 挂载数据: 无 ) 
│       │   │   ├── 文本区 --> ( 难度等级: [0.2489, 0.2489) || 挂载数据: qa: 3 ) 
│       │   │   └── 滚动窗格 --> ( 难度等级: [0.2489, 0.2489) || 挂载数据: 无 ) 
│       │   ├── 选择组件 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│       │   │   ├── 组合框 --> ( 难度等级: [0.2489, 0.2489) || 挂载数据: qa: 1 ) 
│       │   │   └── 滑动条 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│       │   └── 复杂的布局管理 --> ( 难度等级: [0.249, 0.2491) || 挂载数据: 无 ) 
│       │       ├── 网格包布局 --> ( 难度等级: [0.249, 0.249) || 挂载数据: 无 ) 
│       │       └── 定制布局管理器 --> ( 难度等级: [0.249, 0.2491) || 挂载数据: 无 ) 
│       ├── Java快速入门 --> ( 难度等级: [0.2491, 0.2494) || 挂载数据: 无 ) 
│       │   ├── Java程序基础 --> ( 难度等级: [0.2491, 0.2492) || 挂载数据: 无 ) 
│       │   │   ├── Java程序基本结构 --> ( 难度等级: [0.2491, 0.2491) || 挂载数据: 无 ) 
│       │   │   ├── 整数运算 --> ( 难度等级: [0.2491, 0.2491) || 挂载数据: qa: 8 ) 
│       │   │   ├── 浮点数运算 --> ( 难度等级: [0.2491, 0.2492) || 挂载数据: qa: 3 ) 
│       │   │   ├── 布尔运算 --> ( 难度等级: [0.2492, 0.2492) || 挂载数据: 无 ) 
│       │   │   └── 数组类型 --> ( 难度等级: [0.2492, 0.2492) || 挂载数据: qa: 2 ) 
│       │   └── 数组操作 --> ( 难度等级: [0.2492, 0.2494) || 挂载数据: 无 ) 
│       ├── IO --> ( 难度等级: [0.2494, 0.2497) || 挂载数据: qa: 5 ) 
│       │   ├── File对象 --> ( 难度等级: [0.2494, 0.2494) || 挂载数据: qa: 1 ) 
│       │   ├── InputStream --> ( 难度等级: [0.2494, 0.2494) || 挂载数据: qa: 1 ) 
│       │   ├── OutputStream --> ( 难度等级: [0.2494, 0.2495) || 挂载数据: 无 ) 
│       │   ├── Filter模式 --> ( 难度等级: [0.2495, 0.2495) || 挂载数据: 无 ) 
│       │   ├── 操作Zip --> ( 难度等级: [0.2495, 0.2495) || 挂载数据: qa: 1 ) 
│       │   ├── 读取classpath资源 --> ( 难度等级: [0.2495, 0.2496) || 挂载数据: qa: 1 ) 
│       │   ├── 序列化 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│       │   ├── PrintStream和PrintWriter --> ( 难度等级: [0.2496, 0.2497) || 挂载数据: qa: 2 ) 
│       │   └── 使用Files --> ( 难度等级: [0.2497, 0.2497) || 挂载数据: qa: 1 ) 
│       └── 单元测试 --> ( 难度等级: [0.2497, 0.25) || 挂载数据: 无 ) 
│           ├── 编写JUnit测试 --> ( 难度等级: [0.2497, 0.2498) || 挂载数据: 无 ) 
│           ├── 使用Fixture --> ( 难度等级: [0.2498, 0.2498) || 挂载数据: 无 ) 
│           ├── 异常测试 --> ( 难度等级: [0.2498, 0.2499) || 挂载数据: 无 ) 
│           └── 参数化测试 --> ( 难度等级: [0.2499, 0.25) || 挂载数据: 无 ) 
├── java中阶 --> ( 难度等级: [0.25, 0.5) || 挂载数据: 无 ) 
│   ├── 字符串处理 --> ( 难度等级: [0.25, 0.2656) || 挂载数据: 无 ) 
│   │   ├── String类的构造函数 --> ( 难度等级: [0.25, 0.2512) || 挂载数据: 无 ) 
│   │   ├── 字符串的长度 --> ( 难度等级: [0.2512, 0.2524) || 挂载数据: 无 ) 
│   │   ├── 特殊的字符串操作 --> ( 难度等级: [0.2524, 0.2536) || 挂载数据: 无 ) 
│   │   │   ├── 字符串字面值 --> ( 难度等级: [0.2524, 0.2527) || 挂载数据: 无 ) 
│   │   │   ├── 字符串连接 --> ( 难度等级: [0.2527, 0.253) || 挂载数据: 无 ) 
│   │   │   ├── 字符串和其他数据类型的连接 --> ( 难度等级: [0.253, 0.2533) || 挂载数据: 无 ) 
│   │   │   └── 字符串转换和toString方法 --> ( 难度等级: [0.2533, 0.2536) || 挂载数据: qa: 5 ) 
│   │   ├── 提取字符 --> ( 难度等级: [0.2536, 0.2548) || 挂载数据: qa: 1 ) 
│   │   │   ├── charAt --> ( 难度等级: [0.2536, 0.2539) || 挂载数据: qa: 1 ) 
│   │   │   ├── getChars --> ( 难度等级: [0.2539, 0.2542) || 挂载数据: 无 ) 
│   │   │   ├── getBytes --> ( 难度等级: [0.2542, 0.2545) || 挂载数据: 无 ) 
│   │   │   └── toCharArray --> ( 难度等级: [0.2545, 0.2548) || 挂载数据: qa: 1 ) 
│   │   ├── 比较字符串 --> ( 难度等级: [0.2548, 0.256) || 挂载数据: 无 ) 
│   │   │   ├── equals和equalsIgnoreCase --> ( 难度等级: [0.2548, 0.255) || 挂载数据: 无 ) 
│   │   │   ├── regionMatches --> ( 难度等级: [0.255, 0.2553) || 挂载数据: 无 ) 
│   │   │   ├── startsWith和endsWith --> ( 难度等级: [0.2553, 0.2555) || 挂载数据: 无 ) 
│   │   │   ├── equals与== --> ( 难度等级: [0.2555, 0.2558) || 挂载数据: qa: 5 ) 
│   │   │   └── compareTo --> ( 难度等级: [0.2558, 0.256) || 挂载数据: qa: 4 ) 
│   │   ├── 查找字符串 --> ( 难度等级: [0.256, 0.2572) || 挂载数据: 无 ) 
│   │   ├── 修改字符串 --> ( 难度等级: [0.2572, 0.2584) || 挂载数据: 无 ) 
│   │   │   ├── substring --> ( 难度等级: [0.2572, 0.2575) || 挂载数据: 无 ) 
│   │   │   ├── concat --> ( 难度等级: [0.2575, 0.2578) || 挂载数据: 无 ) 
│   │   │   ├── replace --> ( 难度等级: [0.2578, 0.2581) || 挂载数据: 无 ) 
│   │   │   └── trim --> ( 难度等级: [0.2581, 0.2584) || 挂载数据: qa: 1 ) 
│   │   ├── 使用valueOf转换数据 --> ( 难度等级: [0.2584, 0.2596) || 挂载数据: 无 ) 
│   │   ├── 改变字符串中字符的大小写 --> ( 难度等级: [0.2596, 0.2608) || 挂载数据: 无 ) 
│   │   ├── 连接字符串 --> ( 难度等级: [0.2608, 0.262) || 挂载数据: 无 ) 
│   │   ├── 其他String方法 --> ( 难度等级: [0.262, 0.2632) || 挂载数据: 无 ) 
│   │   ├── StringBuffer类 --> ( 难度等级: [0.2632, 0.2644) || 挂载数据: 无 ) 
│   │   │   ├── StringBuffer类的构造函数 --> ( 难度等级: [0.2632, 0.2633) || 挂载数据: 无 ) 
│   │   │   ├── length与capacity --> ( 难度等级: [0.2633, 0.2634) || 挂载数据: qa: 4 ) 
│   │   │   ├── ensureCapacity --> ( 难度等级: [0.2634, 0.2635) || 挂载数据: 无 ) 
│   │   │   ├── setLength --> ( 难度等级: [0.2635, 0.2636) || 挂载数据: 无 ) 
│   │   │   ├── charAt与setCharAt --> ( 难度等级: [0.2636, 0.2637) || 挂载数据: 无 ) 
│   │   │   ├── getChars --> ( 难度等级: [0.2637, 0.2638) || 挂载数据: 无 ) 
│   │   │   ├── append --> ( 难度等级: [0.2638, 0.2639) || 挂载数据: qa: 3 ) 
│   │   │   ├── insert --> ( 难度等级: [0.2639, 0.264) || 挂载数据: 无 ) 
│   │   │   ├── reverse --> ( 难度等级: [0.264, 0.2641) || 挂载数据: 无 ) 
│   │   │   ├── delete与deleteCharAt --> ( 难度等级: [0.2641, 0.2641) || 挂载数据: 无 ) 
│   │   │   ├── replace --> ( 难度等级: [0.2641, 0.2642) || 挂载数据: 无 ) 
│   │   │   ├── substring --> ( 难度等级: [0.2642, 0.2643) || 挂载数据: qa: 3 ) 
│   │   │   └── 其他StringBuffer方法 --> ( 难度等级: [0.2643, 0.2644) || 挂载数据: 无 ) 
│   │   └── StringBuilder类 --> ( 难度等级: [0.2644, 0.2656) || 挂载数据: 无 ) 
│   ├── 探究java.lang --> ( 难度等级: [0.2656, 0.2812) || 挂载数据: 无 ) 
│   │   ├── 基本类型封装器 --> ( 难度等级: [0.2656, 0.2661) || 挂载数据: 无 ) 
│   │   │   ├── Number --> ( 难度等级: [0.2656, 0.2657) || 挂载数据: 无 ) 
│   │   │   ├── Double与Float --> ( 难度等级: [0.2657, 0.2658) || 挂载数据: qa: 5 ) 
│   │   │   ├── 理解isInfinite与isNaN --> ( 难度等级: [0.2658, 0.2658) || 挂载数据: 无 ) 
│   │   │   ├── Byte、Short、Integer和Long --> ( 难度等级: [0.2658, 0.2659) || 挂载数据: qa: 1 ) 
│   │   │   ├── Character --> ( 难度等级: [0.2659, 0.266) || 挂载数据: 无 ) 
│   │   │   ├── 对Unicode代码点的附加支持 --> ( 难度等级: [0.266, 0.2661) || 挂载数据: qa: 1 ) 
│   │   │   └── Boolean --> ( 难度等级: [0.2661, 0.2661) || 挂载数据: 无 ) 
│   │   ├── Void类 --> ( 难度等级: [0.2661, 0.2667) || 挂载数据: qa: 2 ) 
│   │   ├── Process类 --> ( 难度等级: [0.2667, 0.2672) || 挂载数据: 无 ) 
│   │   ├── Runtime类 --> ( 难度等级: [0.2672, 0.2677) || 挂载数据: 无 ) 
│   │   │   ├── 内存管理 --> ( 难度等级: [0.2672, 0.2674) || 挂载数据: 无 ) 
│   │   │   └── 执行其他程序 --> ( 难度等级: [0.2674, 0.2677) || 挂载数据: qa: 3 ) 
│   │   ├── ProcessBuilder类 --> ( 难度等级: [0.2677, 0.2682) || 挂载数据: 无 ) 
│   │   ├── System类 --> ( 难度等级: [0.2682, 0.2687) || 挂载数据: 无 ) 
│   │   │   ├── 使用currentTimeMillis计时程序的执行 --> ( 难度等级: [0.2682, 0.2684) || 挂载数据: 无 ) 
│   │   │   ├── 使用arraycopy --> ( 难度等级: [0.2684, 0.2686) || 挂载数据: 无 ) 
│   │   │   └── 环境属性 --> ( 难度等级: [0.2686, 0.2687) || 挂载数据: 无 ) 
│   │   ├── Object类 --> ( 难度等级: [0.2687, 0.2693) || 挂载数据: 无 ) 
│   │   ├── 使用clone方法和Cloneable接口 --> ( 难度等级: [0.2693, 0.2698) || 挂载数据: qa: 1 ) 
│   │   ├── Class类 --> ( 难度等级: [0.2698, 0.2703) || 挂载数据: 无 ) 
│   │   ├── ClassLoader类 --> ( 难度等级: [0.2703, 0.2708) || 挂载数据: 无 ) 
│   │   ├── Math类 --> ( 难度等级: [0.2708, 0.2714) || 挂载数据: 无 ) 
│   │   │   ├── 三角函数 --> ( 难度等级: [0.2708, 0.271) || 挂载数据: 无 ) 
│   │   │   ├── 指数函数 --> ( 难度等级: [0.271, 0.2711) || 挂载数据: 无 ) 
│   │   │   ├── 舍入函数 --> ( 难度等级: [0.2711, 0.2712) || 挂载数据: 无 ) 
│   │   │   └── 其他数学方法 --> ( 难度等级: [0.2712, 0.2714) || 挂载数据: 无 ) 
│   │   ├── StrictMath类 --> ( 难度等级: [0.2714, 0.2719) || 挂载数据: 无 ) 
│   │   ├── Compiler类 --> ( 难度等级: [0.2719, 0.2724) || 挂载数据: qa: 1 ) 
│   │   ├── Thread类、ThreadGroup类和Runnable接口 --> ( 难度等级: [0.2724, 0.2729) || 挂载数据: 无 ) 
│   │   │   ├── Runnable接口 --> ( 难度等级: [0.2724, 0.2726) || 挂载数据: qa: 9 ) 
│   │   │   ├── Thread类 --> ( 难度等级: [0.2726, 0.2727) || 挂载数据: qa: 10 ) 
│   │   │   └── ThreadGroup类 --> ( 难度等级: [0.2727, 0.2729) || 挂载数据: 无 ) 
│   │   ├── ThreadLocal和InheritableThreadLocal类 --> ( 难度等级: [0.2729, 0.2734) || 挂载数据: 无 ) 
│   │   ├── Package类 --> ( 难度等级: [0.2734, 0.274) || 挂载数据: qa: 7 ) 
│   │   ├── RuntimePermission类 --> ( 难度等级: [0.274, 0.2745) || 挂载数据: 无 ) 
│   │   ├── Throwable类 --> ( 难度等级: [0.2745, 0.275) || 挂载数据: 无 ) 
│   │   ├── SecurityManager类 --> ( 难度等级: [0.275, 0.2755) || 挂载数据: 无 ) 
│   │   ├── StackTraceElement类 --> ( 难度等级: [0.2755, 0.276) || 挂载数据: qa: 1 ) 
│   │   ├── Enum类 --> ( 难度等级: [0.276, 0.2766) || 挂载数据: 无 ) 
│   │   ├── ClassValue类 --> ( 难度等级: [0.2766, 0.2771) || 挂载数据: 无 ) 
│   │   ├── CharSequence接口 --> ( 难度等级: [0.2771, 0.2776) || 挂载数据: 无 ) 
│   │   ├── Comparable接口 --> ( 难度等级: [0.2776, 0.2781) || 挂载数据: qa: 3 ) 
│   │   ├── Appendable接口 --> ( 难度等级: [0.2781, 0.2786) || 挂载数据: 无 ) 
│   │   ├── Iterable接口 --> ( 难度等级: [0.2786, 0.2792) || 挂载数据: 无 ) 
│   │   ├── Readable接口 --> ( 难度等级: [0.2792, 0.2797) || 挂载数据: 无 ) 
│   │   ├── AutoCloseable接口 --> ( 难度等级: [0.2797, 0.2802) || 挂载数据: 无 ) 
│   │   ├── Thread.UncaughtExceptionHandler接口 --> ( 难度等级: [0.2802, 0.2807) || 挂载数据: 无 ) 
│   │   └── java.lang子包 --> ( 难度等级: [0.2807, 0.2812) || 挂载数据: 无 ) 
│   │       ├── java.lang.annotation --> ( 难度等级: [0.2807, 0.2808) || 挂载数据: qa: 10 ) 
│   │       ├── java.lang.instrument --> ( 难度等级: [0.2808, 0.2809) || 挂载数据: 无 ) 
│   │       ├── java.lang.invoke --> ( 难度等级: [0.2809, 0.281) || 挂载数据: qa: 3 ) 
│   │       ├── java.lang.management --> ( 难度等级: [0.281, 0.2811) || 挂载数据: 无 ) 
│   │       ├── java.lang.ref --> ( 难度等级: [0.2811, 0.2812) || 挂载数据: 无 ) 
│   │       └── java.lang.reflect --> ( 难度等级: [0.2812, 0.2812) || 挂载数据: qa: 1 ) 
│   ├── java.util第1部分：集合框架 --> ( 难度等级: [0.2812, 0.2969) || 挂载数据: 无 ) 
│   │   ├── 集合概述 --> ( 难度等级: [0.2812, 0.2825) || 挂载数据: 无 ) 
│   │   ├── JDK 5对集合框架的修改 --> ( 难度等级: [0.2825, 0.2837) || 挂载数据: 无 ) 
│   │   │   ├── 泛型从根本上改变了集合框架 --> ( 难度等级: [0.2825, 0.2829) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱使得使用基本类型更加容易 --> ( 难度等级: [0.2829, 0.2833) || 挂载数据: 无 ) 
│   │   │   └── for-each风格的for循环 --> ( 难度等级: [0.2833, 0.2837) || 挂载数据: 无 ) 
│   │   ├── 集合接口 --> ( 难度等级: [0.2837, 0.2849) || 挂载数据: 无 ) 
│   │   │   ├── Collection接口 --> ( 难度等级: [0.2837, 0.2838) || 挂载数据: qa: 1 ) 
│   │   │   ├── List接口 --> ( 难度等级: [0.2838, 0.284) || 挂载数据: 无 ) 
│   │   │   ├── Set接口 --> ( 难度等级: [0.284, 0.2842) || 挂载数据: 无 ) 
│   │   │   ├── SortedSet接口 --> ( 难度等级: [0.2842, 0.2843) || 挂载数据: 无 ) 
│   │   │   ├── NavigableSet接口 --> ( 难度等级: [0.2843, 0.2845) || 挂载数据: 无 ) 
│   │   │   ├── Queue接口 --> ( 难度等级: [0.2845, 0.2847) || 挂载数据: 无 ) 
│   │   │   └── Deque接口 --> ( 难度等级: [0.2847, 0.2849) || 挂载数据: 无 ) 
│   │   ├── 集合类 --> ( 难度等级: [0.2849, 0.2861) || 挂载数据: 无 ) 
│   │   │   ├── ArrayList类 --> ( 难度等级: [0.2849, 0.285) || 挂载数据: qa: 2 ) 
│   │   │   ├── LinkedList类 --> ( 难度等级: [0.285, 0.2852) || 挂载数据: qa: 1 ) 
│   │   │   ├── HashSet类 --> ( 难度等级: [0.2852, 0.2853) || 挂载数据: 无 ) 
│   │   │   ├── LinkedHashSet类 --> ( 难度等级: [0.2853, 0.2855) || 挂载数据: 无 ) 
│   │   │   ├── TreeSet类 --> ( 难度等级: [0.2855, 0.2856) || 挂载数据: 无 ) 
│   │   │   ├── PriorityQueue类 --> ( 难度等级: [0.2856, 0.2858) || 挂载数据: 无 ) 
│   │   │   ├── ArrayDeque类 --> ( 难度等级: [0.2858, 0.2859) || 挂载数据: 无 ) 
│   │   │   └── EnumSet类 --> ( 难度等级: [0.2859, 0.2861) || 挂载数据: 无 ) 
│   │   ├── 通过迭代器访问集合 --> ( 难度等级: [0.2861, 0.2873) || 挂载数据: 无 ) 
│   │   │   ├── 使用迭代器 --> ( 难度等级: [0.2861, 0.2867) || 挂载数据: qa: 1 ) 
│   │   │   └── 使用for-each循环替代迭代器 --> ( 难度等级: [0.2867, 0.2873) || 挂载数据: qa: 1 ) 
│   │   ├── Spliterator --> ( 难度等级: [0.2873, 0.2885) || 挂载数据: 无 ) 
│   │   │   └── 拆分过程 --> ( 难度等级: [0.2873, 0.2885) || 挂载数据: 无 ) 
│   │   ├── 在集合中存储用户定义的类 --> ( 难度等级: [0.2885, 0.2897) || 挂载数据: 无 ) 
│   │   ├── RandomAccess接口 --> ( 难度等级: [0.2897, 0.2909) || 挂载数据: 无 ) 
│   │   ├── 使用映射 --> ( 难度等级: [0.2909, 0.2921) || 挂载数据: 无 ) 
│   │   │   ├── 映射接口 --> ( 难度等级: [0.2909, 0.2912) || 挂载数据: 无 ) 
│   │   │   ├── 映射类 --> ( 难度等级: [0.2912, 0.2915) || 挂载数据: 无 ) 
│   │   │   ├── 对流中每一个元素应用函数 --> ( 难度等级: [0.2915, 0.2918) || 挂载数据: 无 ) 
│   │   │   └── 流的扁平化 --> ( 难度等级: [0.2918, 0.2921) || 挂载数据: 无 ) 
│   │   ├── 比较器 --> ( 难度等级: [0.2921, 0.2933) || 挂载数据: 无 ) 
│   │   ├── 集合算法 --> ( 难度等级: [0.2933, 0.2945) || 挂载数据: 无 ) 
│   │   ├── Arrays类 --> ( 难度等级: [0.2945, 0.2957) || 挂载数据: 无 ) 
│   │   └── 遗留的类和接口 --> ( 难度等级: [0.2957, 0.2969) || 挂载数据: 无 ) 
│   │       ├── Enumeration接口 --> ( 难度等级: [0.2957, 0.2958) || 挂载数据: 无 ) 
│   │       ├── Vector类 --> ( 难度等级: [0.2958, 0.296) || 挂载数据: 无 ) 
│   │       ├── Stack类 --> ( 难度等级: [0.296, 0.2962) || 挂载数据: qa: 1 ) 
│   │       ├── Dictionary类 --> ( 难度等级: [0.2962, 0.2964) || 挂载数据: 无 ) 
│   │       ├── Hashtable类 --> ( 难度等级: [0.2964, 0.2965) || 挂载数据: 无 ) 
│   │       ├── Properties类 --> ( 难度等级: [0.2965, 0.2967) || 挂载数据: 无 ) 
│   │       └── 使用store和load --> ( 难度等级: [0.2967, 0.2969) || 挂载数据: qa: 1 ) 
│   ├── java.util第2部分：更多实用工具类 --> ( 难度等级: [0.2969, 0.3125) || 挂载数据: 无 ) 
│   │   ├── StringTokenizer类 --> ( 难度等级: [0.2969, 0.2977) || 挂载数据: 无 ) 
│   │   ├── BitSet类 --> ( 难度等级: [0.2977, 0.2986) || 挂载数据: 无 ) 
│   │   ├── Optional、OptionalDouble、OptionalInt和OptionalLong --> ( 难度等级: [0.2986, 0.2995) || 挂载数据: 无 ) 
│   │   ├── Date类 --> ( 难度等级: [0.2995, 0.3003) || 挂载数据: 无 ) 
│   │   ├── Calendar类 --> ( 难度等级: [0.3003, 0.3012) || 挂载数据: 无 ) 
│   │   ├── GregorianCalendar类 --> ( 难度等级: [0.3012, 0.3021) || 挂载数据: 无 ) 
│   │   ├── TimeZone类 --> ( 难度等级: [0.3021, 0.303) || 挂载数据: 无 ) 
│   │   ├── SimpleTimeZone类 --> ( 难度等级: [0.303, 0.3038) || 挂载数据: 无 ) 
│   │   ├── Locale类 --> ( 难度等级: [0.3038, 0.3047) || 挂载数据: 无 ) 
│   │   ├── Random类 --> ( 难度等级: [0.3047, 0.3056) || 挂载数据: 无 ) 
│   │   ├── Observable类 --> ( 难度等级: [0.3056, 0.3064) || 挂载数据: 无 ) 
│   │   │   ├── Observer接口 --> ( 难度等级: [0.3056, 0.306) || 挂载数据: 无 ) 
│   │   │   └── Observer示例 --> ( 难度等级: [0.306, 0.3064) || 挂载数据: 无 ) 
│   │   ├── Timer和TimerTask类 --> ( 难度等级: [0.3064, 0.3073) || 挂载数据: qa: 2 ) 
│   │   ├── Currency类 --> ( 难度等级: [0.3073, 0.3082) || 挂载数据: 无 ) 
│   │   ├── Formatter类 --> ( 难度等级: [0.3082, 0.309) || 挂载数据: 无 ) 
│   │   │   ├── Formatter类的构造函数 --> ( 难度等级: [0.3082, 0.3082) || 挂载数据: 无 ) 
│   │   │   ├── Formatter类的方法 --> ( 难度等级: [0.3082, 0.3083) || 挂载数据: 无 ) 
│   │   │   ├── 格式化的基础知识 --> ( 难度等级: [0.3083, 0.3083) || 挂载数据: 无 ) 
│   │   │   ├── 格式化字符串和字符 --> ( 难度等级: [0.3083, 0.3084) || 挂载数据: 无 ) 
│   │   │   ├── 格式化数字 --> ( 难度等级: [0.3084, 0.3084) || 挂载数据: 无 ) 
│   │   │   ├── 格式化时间和日期 --> ( 难度等级: [0.3084, 0.3084) || 挂载数据: 无 ) 
│   │   │   ├── %n和%%说明符 --> ( 难度等级: [0.3084, 0.3085) || 挂载数据: qa: 1 ) 
│   │   │   ├── 指定最小字段宽度 --> ( 难度等级: [0.3085, 0.3085) || 挂载数据: 无 ) 
│   │   │   ├── 指定精度 --> ( 难度等级: [0.3085, 0.3086) || 挂载数据: 无 ) 
│   │   │   ├── 使用格式标志 --> ( 难度等级: [0.3086, 0.3086) || 挂载数据: 无 ) 
│   │   │   ├── 对齐输出 --> ( 难度等级: [0.3086, 0.3087) || 挂载数据: 无 ) 
│   │   │   ├── 空格、“+”、“0”以及“(”标志 --> ( 难度等级: [0.3087, 0.3087) || 挂载数据: 无 ) 
│   │   │   ├── 逗号标志 --> ( 难度等级: [0.3087, 0.3088) || 挂载数据: 无 ) 
│   │   │   ├── “#”标志 --> ( 难度等级: [0.3088, 0.3088) || 挂载数据: 无 ) 
│   │   │   ├── 大写选项 --> ( 难度等级: [0.3088, 0.3089) || 挂载数据: 无 ) 
│   │   │   ├── 使用参数索引 --> ( 难度等级: [0.3089, 0.3089) || 挂载数据: 无 ) 
│   │   │   ├── 关闭Formatter对象 --> ( 难度等级: [0.3089, 0.309) || 挂载数据: 无 ) 
│   │   │   └── printf方法 --> ( 难度等级: [0.309, 0.309) || 挂载数据: 无 ) 
│   │   ├── Scanner类 --> ( 难度等级: [0.309, 0.3099) || 挂载数据: 无 ) 
│   │   │   ├── Scanner类的构造函数 --> ( 难度等级: [0.309, 0.3092) || 挂载数据: qa: 2 ) 
│   │   │   ├── 扫描的基础知识 --> ( 难度等级: [0.3092, 0.3094) || 挂载数据: 无 ) 
│   │   │   ├── 一些Scanner示例 --> ( 难度等级: [0.3094, 0.3095) || 挂载数据: qa: 10 ) 
│   │   │   ├── 设置定界符 --> ( 难度等级: [0.3095, 0.3097) || 挂载数据: 无 ) 
│   │   │   └── 其他Scanner特性 --> ( 难度等级: [0.3097, 0.3099) || 挂载数据: 无 ) 
│   │   ├── ResourceBundle、ListResourceBundle和 --> ( 难度等级: [0.3099, 0.3108) || 挂载数据: 无 ) 
│   │   ├── 其他实用工具类和接口 --> ( 难度等级: [0.3108, 0.3116) || 挂载数据: 无 ) 
│   │   └── java.util子包 --> ( 难度等级: [0.3116, 0.3125) || 挂载数据: 无 ) 
│   │       ├── java.util.concurrent、java.util.concurrent.atomic和java.util.concurrent.locks --> ( 难度等级: [0.3116, 0.3117) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.function --> ( 难度等级: [0.3117, 0.3118) || 挂载数据: qa: 5 ) 
│   │       ├── java.util.jar --> ( 难度等级: [0.3118, 0.3119) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.logging --> ( 难度等级: [0.3119, 0.312) || 挂载数据: 无 ) 
│   │       ├── java.util.prefs --> ( 难度等级: [0.312, 0.3121) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.regex --> ( 难度等级: [0.3121, 0.3122) || 挂载数据: 无 ) 
│   │       ├── java.util.spi --> ( 难度等级: [0.3122, 0.3123) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.stream --> ( 难度等级: [0.3123, 0.3124) || 挂载数据: 无 ) 
│   │       └── java.util.zip --> ( 难度等级: [0.3124, 0.3125) || 挂载数据: 无 ) 
│   ├── 输入/输出：探究java.io --> ( 难度等级: [0.3125, 0.3281) || 挂载数据: 无 ) 
│   │   ├── I/O类和接口 --> ( 难度等级: [0.3125, 0.3139) || 挂载数据: 无 ) 
│   │   ├── File类 --> ( 难度等级: [0.3139, 0.3153) || 挂载数据: 无 ) 
│   │   │   ├── 目录 --> ( 难度等级: [0.3139, 0.3143) || 挂载数据: qa: 2 ) 
│   │   │   ├── 使用FilenameFilter接口 --> ( 难度等级: [0.3143, 0.3146) || 挂载数据: 无 ) 
│   │   │   ├── listFiles方法 --> ( 难度等级: [0.3146, 0.315) || 挂载数据: qa: 1 ) 
│   │   │   └── 创建目录 --> ( 难度等级: [0.315, 0.3153) || 挂载数据: 无 ) 
│   │   ├── AutoCloseable、Closeable和Flushable接口 --> ( 难度等级: [0.3153, 0.3168) || 挂载数据: 无 ) 
│   │   ├── I/O异常 --> ( 难度等级: [0.3168, 0.3182) || 挂载数据: 无 ) 
│   │   ├── 关闭流的两种方式 --> ( 难度等级: [0.3182, 0.3196) || 挂载数据: 无 ) 
│   │   ├── 流类 --> ( 难度等级: [0.3196, 0.321) || 挂载数据: 无 ) 
│   │   ├── 字节流 --> ( 难度等级: [0.321, 0.3224) || 挂载数据: 无 ) 
│   │   │   ├── InputStream类 --> ( 难度等级: [0.321, 0.3211) || 挂载数据: 无 ) 
│   │   │   ├── OutputStream类 --> ( 难度等级: [0.3211, 0.3213) || 挂载数据: 无 ) 
│   │   │   ├── FileInputStream类 --> ( 难度等级: [0.3213, 0.3214) || 挂载数据: qa: 2 ) 
│   │   │   ├── FileOutputStream类 --> ( 难度等级: [0.3214, 0.3215) || 挂载数据: qa: 1 ) 
│   │   │   ├── ByteArrayInputStream类 --> ( 难度等级: [0.3215, 0.3216) || 挂载数据: 无 ) 
│   │   │   ├── ByteArrayOutputStream类 --> ( 难度等级: [0.3216, 0.3217) || 挂载数据: 无 ) 
│   │   │   ├── 过滤的字节流 --> ( 难度等级: [0.3217, 0.3219) || 挂载数据: 无 ) 
│   │   │   ├── 缓冲的字节流 --> ( 难度等级: [0.3219, 0.322) || 挂载数据: 无 ) 
│   │   │   ├── SequenceInputStream类 --> ( 难度等级: [0.322, 0.3221) || 挂载数据: 无 ) 
│   │   │   ├── PrintStream类 --> ( 难度等级: [0.3221, 0.3222) || 挂载数据: 无 ) 
│   │   │   ├── DataOutputStream和DataInputStream类 --> ( 难度等级: [0.3222, 0.3223) || 挂载数据: 无 ) 
│   │   │   └── RandomAccessFile类 --> ( 难度等级: [0.3223, 0.3224) || 挂载数据: 无 ) 
│   │   ├── 字符流 --> ( 难度等级: [0.3224, 0.3239) || 挂载数据: 无 ) 
│   │   │   ├── Reader类 --> ( 难度等级: [0.3224, 0.3226) || 挂载数据: 无 ) 
│   │   │   ├── Writer类 --> ( 难度等级: [0.3226, 0.3227) || 挂载数据: 无 ) 
│   │   │   ├── FileReader类 --> ( 难度等级: [0.3227, 0.3229) || 挂载数据: qa: 2 ) 
│   │   │   ├── FileWriter类 --> ( 难度等级: [0.3229, 0.323) || 挂载数据: 无 ) 
│   │   │   ├── CharArrayReader类 --> ( 难度等级: [0.323, 0.3232) || 挂载数据: qa: 1 ) 
│   │   │   ├── CharArrayWriter类 --> ( 难度等级: [0.3232, 0.3233) || 挂载数据: 无 ) 
│   │   │   ├── BufferedReader类 --> ( 难度等级: [0.3233, 0.3234) || 挂载数据: qa: 1 ) 
│   │   │   ├── BufferedWriter类 --> ( 难度等级: [0.3234, 0.3236) || 挂载数据: qa: 6 ) 
│   │   │   ├── PushbackReader类 --> ( 难度等级: [0.3236, 0.3237) || 挂载数据: 无 ) 
│   │   │   └── PrintWriter类 --> ( 难度等级: [0.3237, 0.3239) || 挂载数据: 无 ) 
│   │   ├── Console类 --> ( 难度等级: [0.3239, 0.3253) || 挂载数据: qa: 1 ) 
│   │   ├── 串行化 --> ( 难度等级: [0.3253, 0.3267) || 挂载数据: 无 ) 
│   │   │   ├── Serializable接口 --> ( 难度等级: [0.3253, 0.3255) || 挂载数据: qa: 2 ) 
│   │   │   ├── Externalizable接口 --> ( 难度等级: [0.3255, 0.3257) || 挂载数据: 无 ) 
│   │   │   ├── ObjectOutput接口 --> ( 难度等级: [0.3257, 0.3259) || 挂载数据: 无 ) 
│   │   │   ├── ObjectOutputStream类 --> ( 难度等级: [0.3259, 0.3261) || 挂载数据: qa: 2 ) 
│   │   │   ├── ObjectInput接口 --> ( 难度等级: [0.3261, 0.3263) || 挂载数据: 无 ) 
│   │   │   ├── ObjectInputStream类 --> ( 难度等级: [0.3263, 0.3265) || 挂载数据: 无 ) 
│   │   │   └── 串行化示例 --> ( 难度等级: [0.3265, 0.3267) || 挂载数据: 无 ) 
│   │   └── 流的优点 --> ( 难度等级: [0.3267, 0.3281) || 挂载数据: 无 ) 
│   ├── 探究NIO --> ( 难度等级: [0.3281, 0.3438) || 挂载数据: 无 ) 
│   │   ├── NIO类 --> ( 难度等级: [0.3281, 0.3312) || 挂载数据: 无 ) 
│   │   ├── NIO的基础知识 --> ( 难度等级: [0.3312, 0.3344) || 挂载数据: 无 ) 
│   │   │   ├── 缓冲区 --> ( 难度等级: [0.3312, 0.3323) || 挂载数据: 无 ) 
│   │   │   ├── 通道 --> ( 难度等级: [0.3323, 0.3333) || 挂载数据: 无 ) 
│   │   │   └── 字符集和选择器 --> ( 难度等级: [0.3333, 0.3344) || 挂载数据: 无 ) 
│   │   ├── JDK 7对NIO的增强 --> ( 难度等级: [0.3344, 0.3375) || 挂载数据: 无 ) 
│   │   │   ├── Path接口 --> ( 难度等级: [0.3344, 0.335) || 挂载数据: 无 ) 
│   │   │   ├── Files类 --> ( 难度等级: [0.335, 0.3356) || 挂载数据: 无 ) 
│   │   │   ├── Path接口 --> ( 难度等级: [0.3356, 0.3362) || 挂载数据: 无 ) 
│   │   │   ├── 文件属性接口 --> ( 难度等级: [0.3362, 0.3369) || 挂载数据: 无 ) 
│   │   │   └── FileSystem、FileSystems和FileStore类 --> ( 难度等级: [0.3369, 0.3375) || 挂载数据: 无 ) 
│   │   ├── 使用NIO系统 --> ( 难度等级: [0.3375, 0.3406) || 挂载数据: 无 ) 
│   │   │   ├── 为基于通道的I/O使用NIO --> ( 难度等级: [0.3375, 0.3385) || 挂载数据: 无 ) 
│   │   │   ├── 为基于流的I/O使用NIO --> ( 难度等级: [0.3385, 0.3396) || 挂载数据: 无 ) 
│   │   │   └── 为路径和文件系统操作使用NIO --> ( 难度等级: [0.3396, 0.3406) || 挂载数据: 无 ) 
│   │   └── JDK 7之前基于通道的例子 --> ( 难度等级: [0.3406, 0.3438) || 挂载数据: 无 ) 
│   │       ├── 读文件(JDK 7之前) --> ( 难度等级: [0.3406, 0.3422) || 挂载数据: qa: 1 ) 
│   │       └── 写文件(JDK 7之前) --> ( 难度等级: [0.3422, 0.3438) || 挂载数据: qa: 3 ) 
│   ├── 联网 --> ( 难度等级: [0.3438, 0.3594) || 挂载数据: 无 ) 
│   │   ├── 联网的基础知识 --> ( 难度等级: [0.3438, 0.3451) || 挂载数据: 无 ) 
│   │   ├── 联网类和接口 --> ( 难度等级: [0.3451, 0.3464) || 挂载数据: 无 ) 
│   │   ├── InetAddress类 --> ( 难度等级: [0.3464, 0.3477) || 挂载数据: 无 ) 
│   │   │   └── 工厂方法 --> ( 难度等级: [0.3464, 0.3477) || 挂载数据: 无 ) 
│   │   ├── Inet4Address类和Inet6Address类 --> ( 难度等级: [0.3477, 0.349) || 挂载数据: 无 ) 
│   │   ├── TCP/IP客户端套接字 --> ( 难度等级: [0.349, 0.3503) || 挂载数据: qa: 10 ) 
│   │   ├── URL类 --> ( 难度等级: [0.3503, 0.3516) || 挂载数据: 无 ) 
│   │   ├── URLConnection类 --> ( 难度等级: [0.3516, 0.3529) || 挂载数据: 无 ) 
│   │   ├── HttpURLConnection类 --> ( 难度等级: [0.3529, 0.3542) || 挂载数据: qa: 2 ) 
│   │   ├── URI类 --> ( 难度等级: [0.3542, 0.3555) || 挂载数据: 无 ) 
│   │   ├── cookie --> ( 难度等级: [0.3555, 0.3568) || 挂载数据: qa: 3 ) 
│   │   ├── TCP/IP服务器套接字 --> ( 难度等级: [0.3568, 0.3581) || 挂载数据: 无 ) 
│   │   └── 数据报 --> ( 难度等级: [0.3581, 0.3594) || 挂载数据: 无 ) 
│   │       ├── DatagramSocket类 --> ( 难度等级: [0.3581, 0.3585) || 挂载数据: 无 ) 
│   │       ├── DatagramPacket类 --> ( 难度等级: [0.3585, 0.3589) || 挂载数据: 无 ) 
│   │       └── 数据报示例 --> ( 难度等级: [0.3589, 0.3594) || 挂载数据: qa: 8 ) 
│   ├── Applet类 --> ( 难度等级: [0.3594, 0.375) || 挂载数据: 无 ) 
│   │   ├── applet的两种类型 --> ( 难度等级: [0.3594, 0.3605) || 挂载数据: 无 ) 
│   │   ├── applet的基础知识 --> ( 难度等级: [0.3605, 0.3616) || 挂载数据: 无 ) 
│   │   ├── applet的架构 --> ( 难度等级: [0.3616, 0.3627) || 挂载数据: 无 ) 
│   │   ├── applet的骨架 --> ( 难度等级: [0.3627, 0.3638) || 挂载数据: 无 ) 
│   │   │   ├── applet的初始化和终止 --> ( 难度等级: [0.3627, 0.3633) || 挂载数据: qa: 6 ) 
│   │   │   └── 重写update方法 --> ( 难度等级: [0.3633, 0.3638) || 挂载数据: 无 ) 
│   │   ├── 简单的applet显示方法 --> ( 难度等级: [0.3638, 0.365) || 挂载数据: 无 ) 
│   │   ├── 请求重画 --> ( 难度等级: [0.365, 0.3661) || 挂载数据: 无 ) 
│   │   ├── 使用状态栏窗口 --> ( 难度等级: [0.3661, 0.3672) || 挂载数据: 无 ) 
│   │   ├── HTML APPLET标记 --> ( 难度等级: [0.3672, 0.3683) || 挂载数据: 无 ) 
│   │   ├── 向applet传递参数 --> ( 难度等级: [0.3683, 0.3694) || 挂载数据: 无 ) 
│   │   ├── getDocumentBase和getCodeBase --> ( 难度等级: [0.3694, 0.3705) || 挂载数据: 无 ) 
│   │   ├── AppletContext接口和showDocument方法 --> ( 难度等级: [0.3705, 0.3717) || 挂载数据: 无 ) 
│   │   ├── AudioClip接口 --> ( 难度等级: [0.3717, 0.3728) || 挂载数据: 无 ) 
│   │   ├── AppletStub接口 --> ( 难度等级: [0.3728, 0.3739) || 挂载数据: 无 ) 
│   │   └── 向控制台输出 --> ( 难度等级: [0.3739, 0.375) || 挂载数据: qa: 1 ) 
│   ├── 事件处理 --> ( 难度等级: [0.375, 0.3906) || 挂载数据: 无 ) 
│   │   ├── 两种事件处理机制 --> ( 难度等级: [0.375, 0.377) || 挂载数据: 无 ) 
│   │   ├── 委托事件模型 --> ( 难度等级: [0.377, 0.3789) || 挂载数据: 无 ) 
│   │   │   ├── 事件 --> ( 难度等级: [0.377, 0.3776) || 挂载数据: 无 ) 
│   │   │   ├── 事件源 --> ( 难度等级: [0.3776, 0.3783) || 挂载数据: 无 ) 
│   │   │   └── 事件监听器 --> ( 难度等级: [0.3783, 0.3789) || 挂载数据: 无 ) 
│   │   ├── 事件类 --> ( 难度等级: [0.3789, 0.3809) || 挂载数据: 无 ) 
│   │   │   ├── ActionEvent类 --> ( 难度等级: [0.3789, 0.3791) || 挂载数据: 无 ) 
│   │   │   ├── AdjustmentEvent类 --> ( 难度等级: [0.3791, 0.3792) || 挂载数据: 无 ) 
│   │   │   ├── ComponentEvent类 --> ( 难度等级: [0.3792, 0.3794) || 挂载数据: 无 ) 
│   │   │   ├── ContainerEvent类 --> ( 难度等级: [0.3794, 0.3796) || 挂载数据: 无 ) 
│   │   │   ├── FocusEvent类 --> ( 难度等级: [0.3796, 0.3797) || 挂载数据: 无 ) 
│   │   │   ├── InputEvent类 --> ( 难度等级: [0.3797, 0.3799) || 挂载数据: 无 ) 
│   │   │   ├── ItemEvent类 --> ( 难度等级: [0.3799, 0.38) || 挂载数据: 无 ) 
│   │   │   ├── KeyEvent类 --> ( 难度等级: [0.38, 0.3802) || 挂载数据: 无 ) 
│   │   │   ├── MouseEvent类 --> ( 难度等级: [0.3802, 0.3804) || 挂载数据: qa: 1 ) 
│   │   │   ├── MouseWheelEvent类 --> ( 难度等级: [0.3804, 0.3805) || 挂载数据: 无 ) 
│   │   │   ├── TextEvent类 --> ( 难度等级: [0.3805, 0.3807) || 挂载数据: 无 ) 
│   │   │   └── WindowEvent类 --> ( 难度等级: [0.3807, 0.3809) || 挂载数据: 无 ) 
│   │   ├── 事件源 --> ( 难度等级: [0.3809, 0.3828) || 挂载数据: 无 ) 
│   │   ├── 事件监听器接口 --> ( 难度等级: [0.3828, 0.3848) || 挂载数据: 无 ) 
│   │   │   ├── ActionListener接口 --> ( 难度等级: [0.3828, 0.383) || 挂载数据: qa: 2 ) 
│   │   │   ├── AdjustmentListener接口 --> ( 难度等级: [0.383, 0.3831) || 挂载数据: 无 ) 
│   │   │   ├── ComponentListener接口 --> ( 难度等级: [0.3831, 0.3833) || 挂载数据: 无 ) 
│   │   │   ├── ContainerListener接口 --> ( 难度等级: [0.3833, 0.3834) || 挂载数据: 无 ) 
│   │   │   ├── FocusListener接口 --> ( 难度等级: [0.3834, 0.3836) || 挂载数据: 无 ) 
│   │   │   ├── ItemListener接口 --> ( 难度等级: [0.3836, 0.3837) || 挂载数据: 无 ) 
│   │   │   ├── KeyListener接口 --> ( 难度等级: [0.3837, 0.3839) || 挂载数据: qa: 1 ) 
│   │   │   ├── MouseListener接口 --> ( 难度等级: [0.3839, 0.384) || 挂载数据: 无 ) 
│   │   │   ├── MouseMotionListener接口 --> ( 难度等级: [0.384, 0.3842) || 挂载数据: 无 ) 
│   │   │   ├── MouseWheelListener接口 --> ( 难度等级: [0.3842, 0.3843) || 挂载数据: 无 ) 
│   │   │   ├── TextListener接口 --> ( 难度等级: [0.3843, 0.3845) || 挂载数据: 无 ) 
│   │   │   ├── WindowFocusListener接口 --> ( 难度等级: [0.3845, 0.3846) || 挂载数据: 无 ) 
│   │   │   └── WindowListener接口 --> ( 难度等级: [0.3846, 0.3848) || 挂载数据: 无 ) 
│   │   ├── 使用委托事件模型 --> ( 难度等级: [0.3848, 0.3867) || 挂载数据: 无 ) 
│   │   │   ├── 处理鼠标事件 --> ( 难度等级: [0.3848, 0.3857) || 挂载数据: 无 ) 
│   │   │   └── 处理键盘事件 --> ( 难度等级: [0.3857, 0.3867) || 挂载数据: 无 ) 
│   │   ├── 适配器类 --> ( 难度等级: [0.3867, 0.3887) || 挂载数据: 无 ) 
│   │   └── 内部类 --> ( 难度等级: [0.3887, 0.3906) || 挂载数据: qa: 1 ) 
│   ├── AWT介绍：使用窗口、图形和文本 --> ( 难度等级: [0.3906, 0.4062) || 挂载数据: 无 ) 
│   │   ├── AWT类 --> ( 难度等级: [0.3906, 0.392) || 挂载数据: 无 ) 
│   │   ├── 窗口基本元素 --> ( 难度等级: [0.392, 0.3935) || 挂载数据: 无 ) 
│   │   │   ├── Component类 --> ( 难度等级: [0.392, 0.3923) || 挂载数据: qa: 2 ) 
│   │   │   ├── Container类 --> ( 难度等级: [0.3923, 0.3925) || 挂载数据: 无 ) 
│   │   │   ├── Panel类 --> ( 难度等级: [0.3925, 0.3928) || 挂载数据: qa: 2 ) 
│   │   │   ├── Window类 --> ( 难度等级: [0.3928, 0.393) || 挂载数据: qa: 3 ) 
│   │   │   ├── Frame类 --> ( 难度等级: [0.393, 0.3932) || 挂载数据: qa: 2 ) 
│   │   │   └── Canvas类 --> ( 难度等级: [0.3932, 0.3935) || 挂载数据: 无 ) 
│   │   ├── 使用框架窗口 --> ( 难度等级: [0.3935, 0.3949) || 挂载数据: 无 ) 
│   │   │   ├── 设置窗口的尺寸 --> ( 难度等级: [0.3935, 0.3938) || 挂载数据: qa: 5 ) 
│   │   │   ├── 隐藏和显示窗口 --> ( 难度等级: [0.3938, 0.3942) || 挂载数据: qa: 6 ) 
│   │   │   ├── 设置窗口的标题 --> ( 难度等级: [0.3942, 0.3945) || 挂载数据: 无 ) 
│   │   │   └── 关闭框架窗口 --> ( 难度等级: [0.3945, 0.3949) || 挂载数据: qa: 1 ) 
│   │   ├── 在基于AWT的applet中创建框架窗口 --> ( 难度等级: [0.3949, 0.3963) || 挂载数据: 无 ) 
│   │   ├── 创建基于窗口的程序 --> ( 难度等级: [0.3963, 0.3977) || 挂载数据: qa: 1 ) 
│   │   ├── 在窗口中显示信息 --> ( 难度等级: [0.3977, 0.3991) || 挂载数据: 无 ) 
│   │   ├── 使用图形 --> ( 难度等级: [0.3991, 0.4006) || 挂载数据: 无 ) 
│   │   │   ├── 绘制直线 --> ( 难度等级: [0.3991, 0.3994) || 挂载数据: 无 ) 
│   │   │   ├── 绘制矩形 --> ( 难度等级: [0.3994, 0.3996) || 挂载数据: 无 ) 
│   │   │   ├── 绘制椭圆和圆 --> ( 难度等级: [0.3996, 0.3998) || 挂载数据: 无 ) 
│   │   │   ├── 绘制弧形 --> ( 难度等级: [0.3998, 0.4) || 挂载数据: 无 ) 
│   │   │   ├── 绘制多边形 --> ( 难度等级: [0.4, 0.4002) || 挂载数据: 无 ) 
│   │   │   ├── 演示绘制方法 --> ( 难度等级: [0.4002, 0.4004) || 挂载数据: 无 ) 
│   │   │   └── 改变图形的大小 --> ( 难度等级: [0.4004, 0.4006) || 挂载数据: qa: 8 ) 
│   │   ├── 使用颜色 --> ( 难度等级: [0.4006, 0.402) || 挂载数据: 无 ) 
│   │   │   ├── Color类的方法 --> ( 难度等级: [0.4006, 0.401) || 挂载数据: 无 ) 
│   │   │   ├── 设置当前图形的颜色 --> ( 难度等级: [0.401, 0.4015) || 挂载数据: 无 ) 
│   │   │   └── 一个演示颜色的applet --> ( 难度等级: [0.4015, 0.402) || 挂载数据: qa: 1 ) 
│   │   ├── 设置绘图模式 --> ( 难度等级: [0.402, 0.4034) || 挂载数据: 无 ) 
│   │   ├── 使用字体 --> ( 难度等级: [0.4034, 0.4048) || 挂载数据: 无 ) 
│   │   │   ├── 确定可用字体 --> ( 难度等级: [0.4034, 0.4039) || 挂载数据: 无 ) 
│   │   │   ├── 创建和选择字体 --> ( 难度等级: [0.4039, 0.4044) || 挂载数据: 无 ) 
│   │   │   └── 获取字体信息 --> ( 难度等级: [0.4044, 0.4048) || 挂载数据: 无 ) 
│   │   └── 使用FontMetrics管理文本输出 --> ( 难度等级: [0.4048, 0.4062) || 挂载数据: 无 ) 
│   │       ├── 显示多行文本 --> ( 难度等级: [0.4048, 0.4053) || 挂载数据: 无 ) 
│   │       ├── 居中显示文本 --> ( 难度等级: [0.4053, 0.4058) || 挂载数据: qa: 1 ) 
│   │       └── 对齐多行文本 --> ( 难度等级: [0.4058, 0.4062) || 挂载数据: qa: 8 ) 
│   ├── 使用AWT控件、布局管理器和菜单 --> ( 难度等级: [0.4062, 0.4219) || 挂载数据: 无 ) 
│   │   ├── AWT控件的基础知识 --> ( 难度等级: [0.4062, 0.4073) || 挂载数据: 无 ) 
│   │   │   ├── 添加和移除控件 --> ( 难度等级: [0.4062, 0.4066) || 挂载数据: 无 ) 
│   │   │   ├── 响应控件 --> ( 难度等级: [0.4066, 0.4069) || 挂载数据: qa: 4 ) 
│   │   │   └── HeadlessException异常 --> ( 难度等级: [0.4069, 0.4073) || 挂载数据: 无 ) 
│   │   ├── 使用标签 --> ( 难度等级: [0.4073, 0.4083) || 挂载数据: qa: 7 ) 
│   │   ├── 使用命令按钮 --> ( 难度等级: [0.4083, 0.4094) || 挂载数据: 无 ) 
│   │   ├── 使用复选框 --> ( 难度等级: [0.4094, 0.4104) || 挂载数据: 无 ) 
│   │   ├── 使用复选框组 --> ( 难度等级: [0.4104, 0.4115) || 挂载数据: 无 ) 
│   │   ├── 使用下拉列表 --> ( 难度等级: [0.4115, 0.4125) || 挂载数据: 无 ) 
│   │   ├── 使用列表框 --> ( 难度等级: [0.4125, 0.4135) || 挂载数据: 无 ) 
│   │   ├── 管理滚动条 --> ( 难度等级: [0.4135, 0.4146) || 挂载数据: 无 ) 
│   │   ├── 使用TextField --> ( 难度等级: [0.4146, 0.4156) || 挂载数据: qa: 1 ) 
│   │   ├── 使用TextArea --> ( 难度等级: [0.4156, 0.4167) || 挂载数据: 无 ) 
│   │   ├── 理解布局管理器 --> ( 难度等级: [0.4167, 0.4177) || 挂载数据: 无 ) 
│   │   │   ├── FlowLayout布局管理器 --> ( 难度等级: [0.4167, 0.4168) || 挂载数据: 无 ) 
│   │   │   ├── BorderLayout布局管理器 --> ( 难度等级: [0.4168, 0.417) || 挂载数据: 无 ) 
│   │   │   ├── 使用Insets --> ( 难度等级: [0.417, 0.4172) || 挂载数据: 无 ) 
│   │   │   ├── GridLayout布局管理器 --> ( 难度等级: [0.4172, 0.4174) || 挂载数据: 无 ) 
│   │   │   ├── CardLayout布局管理器 --> ( 难度等级: [0.4174, 0.4175) || 挂载数据: 无 ) 
│   │   │   └── GridBagLayout布局管理器 --> ( 难度等级: [0.4175, 0.4177) || 挂载数据: 无 ) 
│   │   ├── 菜单栏和菜单 --> ( 难度等级: [0.4177, 0.4188) || 挂载数据: 无 ) 
│   │   ├── 对话框 --> ( 难度等级: [0.4188, 0.4198) || 挂载数据: 无 ) 
│   │   ├── FileDialog类 --> ( 难度等级: [0.4198, 0.4208) || 挂载数据: 无 ) 
│   │   └── 关于重写paint方法 --> ( 难度等级: [0.4208, 0.4219) || 挂载数据: qa: 3 ) 
│   ├── 图像 --> ( 难度等级: [0.4219, 0.4375) || 挂载数据: 无 ) 
│   │   ├── 文件格式 --> ( 难度等级: [0.4219, 0.4236) || 挂载数据: 无 ) 
│   │   ├── 图像基础：创建、加载与显示 --> ( 难度等级: [0.4236, 0.4253) || 挂载数据: 无 ) 
│   │   │   ├── 创建Image对象 --> ( 难度等级: [0.4236, 0.4242) || 挂载数据: qa: 1 ) 
│   │   │   ├── 加载图像 --> ( 难度等级: [0.4242, 0.4248) || 挂载数据: qa: 5 ) 
│   │   │   └── 显示图像 --> ( 难度等级: [0.4248, 0.4253) || 挂载数据: qa: 10 ) 
│   │   ├── ImageObserver接口 --> ( 难度等级: [0.4253, 0.4271) || 挂载数据: 无 ) 
│   │   ├── 双缓冲 --> ( 难度等级: [0.4271, 0.4288) || 挂载数据: 无 ) 
│   │   ├── MediaTracker类 --> ( 难度等级: [0.4288, 0.4306) || 挂载数据: 无 ) 
│   │   ├── ImageProducer接口 --> ( 难度等级: [0.4306, 0.4323) || 挂载数据: 无 ) 
│   │   ├── ImageConsumer接口 --> ( 难度等级: [0.4323, 0.434) || 挂载数据: 无 ) 
│   │   ├── ImageFilter类 --> ( 难度等级: [0.434, 0.4358) || 挂载数据: 无 ) 
│   │   │   ├── CropImageFilter类 --> ( 难度等级: [0.434, 0.4349) || 挂载数据: 无 ) 
│   │   │   └── RGBImageFilter类 --> ( 难度等级: [0.4349, 0.4358) || 挂载数据: 无 ) 
│   │   └── 其他图像类 --> ( 难度等级: [0.4358, 0.4375) || 挂载数据: 无 ) 
│   ├── 并发实用工具 --> ( 难度等级: [0.4375, 0.4531) || 挂载数据: 无 ) 
│   │   ├── 并发API包 --> ( 难度等级: [0.4375, 0.4392) || 挂载数据: 无 ) 
│   │   │   ├── java.util.concurrent包 --> ( 难度等级: [0.4375, 0.4381) || 挂载数据: 无 ) 
│   │   │   ├── java.util.concurrent.atomic包 --> ( 难度等级: [0.4381, 0.4387) || 挂载数据: 无 ) 
│   │   │   └── java.util.concurrent.locks包 --> ( 难度等级: [0.4387, 0.4392) || 挂载数据: 无 ) 
│   │   ├── 使用同步对象 --> ( 难度等级: [0.4392, 0.441) || 挂载数据: 无 ) 
│   │   │   ├── Semaphore类 --> ( 难度等级: [0.4392, 0.4396) || 挂载数据: 无 ) 
│   │   │   ├── CountDownLatch类 --> ( 难度等级: [0.4396, 0.4399) || 挂载数据: 无 ) 
│   │   │   ├── CyclicBarrier类 --> ( 难度等级: [0.4399, 0.4403) || 挂载数据: 无 ) 
│   │   │   ├── Exchanger类 --> ( 难度等级: [0.4403, 0.4406) || 挂载数据: 无 ) 
│   │   │   └── Phaser类 --> ( 难度等级: [0.4406, 0.441) || 挂载数据: 无 ) 
│   │   ├── 使用执行器 --> ( 难度等级: [0.441, 0.4427) || 挂载数据: 无 ) 
│   │   │   ├── 一个简单的执行器示例 --> ( 难度等级: [0.441, 0.4418) || 挂载数据: 无 ) 
│   │   │   └── 使用Callable和Future接口 --> ( 难度等级: [0.4418, 0.4427) || 挂载数据: 无 ) 
│   │   │       ├── Future接口的局限性 --> ( 难度等级: [0.4418, 0.4423) || 挂载数据: qa: 2 ) 
│   │   │       └── 使用CompletableFuture构建异步应用 --> ( 难度等级: [0.4423, 0.4427) || 挂载数据: 无 ) 
│   │   ├── TimeUnit枚举 --> ( 难度等级: [0.4427, 0.4444) || 挂载数据: qa: 1 ) 
│   │   ├── 并发集合 --> ( 难度等级: [0.4444, 0.4462) || 挂载数据: 无 ) 
│   │   ├── 锁 --> ( 难度等级: [0.4462, 0.4479) || 挂载数据: 无 ) 
│   │   ├── 原子操作 --> ( 难度等级: [0.4479, 0.4497) || 挂载数据: 无 ) 
│   │   ├── 通过Fork/Join框架进行并行编程 --> ( 难度等级: [0.4497, 0.4514) || 挂载数据: 无 ) 
│   │   │   ├── 主要的Fork/Join类 --> ( 难度等级: [0.4497, 0.4498) || 挂载数据: 无 ) 
│   │   │   ├── 分而治之的策略 --> ( 难度等级: [0.4498, 0.45) || 挂载数据: 无 ) 
│   │   │   ├── 一个简单的Fork/Join示例 --> ( 难度等级: [0.45, 0.4501) || 挂载数据: 无 ) 
│   │   │   ├── 理解并行级别带来的影响 --> ( 难度等级: [0.4501, 0.4503) || 挂载数据: 无 ) 
│   │   │   ├── 一个使用RecursiveTask[V]的例子 --> ( 难度等级: [0.4503, 0.4504) || 挂载数据: 无 ) 
│   │   │   ├── 异步执行任务 --> ( 难度等级: [0.4504, 0.4506) || 挂载数据: 无 ) 
│   │   │   ├── 取消任务 --> ( 难度等级: [0.4506, 0.4508) || 挂载数据: 无 ) 
│   │   │   ├── 确定任务的完成状态 --> ( 难度等级: [0.4508, 0.4509) || 挂载数据: 无 ) 
│   │   │   ├── 重新启动任务 --> ( 难度等级: [0.4509, 0.4511) || 挂载数据: 无 ) 
│   │   │   ├── 深入研究 --> ( 难度等级: [0.4511, 0.4512) || 挂载数据: 无 ) 
│   │   │   └── 关于Fork/Join框架的一些提示 --> ( 难度等级: [0.4512, 0.4514) || 挂载数据: 无 ) 
│   │   └── 并发实用工具与Java传统方式的比较 --> ( 难度等级: [0.4514, 0.4531) || 挂载数据: 无 ) 
│   ├── 流API --> ( 难度等级: [0.4531, 0.4688) || 挂载数据: 无 ) 
│   │   ├── 流的基础知识 --> ( 难度等级: [0.4531, 0.4554) || 挂载数据: 无 ) 
│   │   │   ├── 流接口 --> ( 难度等级: [0.4531, 0.4539) || 挂载数据: 无 ) 
│   │   │   ├── 如何获得流 --> ( 难度等级: [0.4539, 0.4546) || 挂载数据: 无 ) 
│   │   │   └── 一个简单的流示例 --> ( 难度等级: [0.4546, 0.4554) || 挂载数据: 无 ) 
│   │   ├── 缩减操作 --> ( 难度等级: [0.4554, 0.4576) || 挂载数据: 无 ) 
│   │   ├── 使用并行流 --> ( 难度等级: [0.4576, 0.4598) || 挂载数据: 无 ) 
│   │   │   ├── 将顺序流转换为并行流 --> ( 难度等级: [0.4576, 0.4583) || 挂载数据: 无 ) 
│   │   │   ├── 测量流性能 --> ( 难度等级: [0.4583, 0.4591) || 挂载数据: 无 ) 
│   │   │   └── 高效使用并行流 --> ( 难度等级: [0.4591, 0.4598) || 挂载数据: qa: 1 ) 
│   │   ├── 映射 --> ( 难度等级: [0.4598, 0.4621) || 挂载数据: 无 ) 
│   │   ├── 收集 --> ( 难度等级: [0.4621, 0.4643) || 挂载数据: 无 ) 
│   │   ├── 迭代器和流 --> ( 难度等级: [0.4643, 0.4665) || 挂载数据: 无 ) 
│   │   │   ├── 对流使用迭代器 --> ( 难度等级: [0.4643, 0.4645) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spliterator --> ( 难度等级: [0.4645, 0.4647) || 挂载数据: 无 ) 
│   │   │   ├── 筛选 --> ( 难度等级: [0.4647, 0.465) || 挂载数据: 无 ) 
│   │   │   │   ├── 用谓词筛选 --> ( 难度等级: [0.4647, 0.4648) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 筛选各异的元素 --> ( 难度等级: [0.4648, 0.465) || 挂载数据: 无 ) 
│   │   │   ├── 流的切片 --> ( 难度等级: [0.465, 0.4652) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用谓词对流进行切片 --> ( 难度等级: [0.465, 0.465) || 挂载数据: 无 ) 
│   │   │   │   ├── 截短流 --> ( 难度等级: [0.465, 0.4651) || 挂载数据: qa: 8 ) 
│   │   │   │   └── 跳过元素 --> ( 难度等级: [0.4651, 0.4652) || 挂载数据: qa: 3 ) 
│   │   │   ├── 查找和匹配 --> ( 难度等级: [0.4652, 0.4654) || 挂载数据: 无 ) 
│   │   │   │   ├── 检查谓词是否至少匹配一个元素 --> ( 难度等级: [0.4652, 0.4652) || 挂载数据: 无 ) 
│   │   │   │   ├── 检查谓词是否匹配所有元素 --> ( 难度等级: [0.4652, 0.4653) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 查找元素 --> ( 难度等级: [0.4653, 0.4653) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 查找第一个元素 --> ( 难度等级: [0.4653, 0.4654) || 挂载数据: 无 ) 
│   │   │   ├── 归约 --> ( 难度等级: [0.4654, 0.4656) || 挂载数据: 无 ) 
│   │   │   │   ├── 元素求和 --> ( 难度等级: [0.4654, 0.4655) || 挂载数据: 无 ) 
│   │   │   │   └── 最大值和最小值 --> ( 难度等级: [0.4655, 0.4656) || 挂载数据: qa: 1 ) 
│   │   │   ├── 付诸实践 --> ( 难度等级: [0.4656, 0.4658) || 挂载数据: 无 ) 
│   │   │   │   ├── 领域：交易员和交易 --> ( 难度等级: [0.4656, 0.4657) || 挂载数据: 无 ) 
│   │   │   │   └── 解答 --> ( 难度等级: [0.4657, 0.4658) || 挂载数据: 无 ) 
│   │   │   ├── 数值流 --> ( 难度等级: [0.4658, 0.4661) || 挂载数据: 无 ) 
│   │   │   │   ├── 原始类型流特化 --> ( 难度等级: [0.4658, 0.4659) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值范围 --> ( 难度等级: [0.4659, 0.466) || 挂载数据: qa: 5 ) 
│   │   │   │   └── 数值流应用：勾股数 --> ( 难度等级: [0.466, 0.4661) || 挂载数据: 无 ) 
│   │   │   ├── 构建流 --> ( 难度等级: [0.4661, 0.4663) || 挂载数据: 无 ) 
│   │   │   │   ├── 由值创建流 --> ( 难度等级: [0.4661, 0.4661) || 挂载数据: 无 ) 
│   │   │   │   ├── 由可空对象创建流 --> ( 难度等级: [0.4661, 0.4662) || 挂载数据: 无 ) 
│   │   │   │   ├── 由数组创建流 --> ( 难度等级: [0.4662, 0.4662) || 挂载数据: 无 ) 
│   │   │   │   ├── 由文件生成流 --> ( 难度等级: [0.4662, 0.4662) || 挂载数据: qa: 5 ) 
│   │   │   │   └── 由函数生成流：创建无限流 --> ( 难度等级: [0.4662, 0.4663) || 挂载数据: 无 ) 
│   │   │   └── 概述 --> ( 难度等级: [0.4663, 0.4665) || 挂载数据: 无 ) 
│   │   └── 流API中更多值得探究的地方 --> ( 难度等级: [0.4665, 0.4688) || 挂载数据: qa: 1 ) 
│   ├── 正则表达式和其他包 --> ( 难度等级: [0.4688, 0.4844) || 挂载数据: 无 ) 
│   │   ├── 核心Java API包 --> ( 难度等级: [0.4688, 0.4697) || 挂载数据: 无 ) 
│   │   ├── 正则表达式处理 --> ( 难度等级: [0.4697, 0.4707) || 挂载数据: 无 ) 
│   │   │   ├── Pattern类 --> ( 难度等级: [0.4697, 0.4699) || 挂载数据: 无 ) 
│   │   │   ├── Matcher类 --> ( 难度等级: [0.4699, 0.4701) || 挂载数据: 无 ) 
│   │   │   ├── 正则表达式的语法 --> ( 难度等级: [0.4701, 0.4702) || 挂载数据: 无 ) 
│   │   │   ├── 演示模式匹配 --> ( 难度等级: [0.4702, 0.4704) || 挂载数据: 无 ) 
│   │   │   ├── 模式匹配的两个选项 --> ( 难度等级: [0.4704, 0.4705) || 挂载数据: 无 ) 
│   │   │   └── 探究正则表达式 --> ( 难度等级: [0.4705, 0.4707) || 挂载数据: qa: 10 ) 
│   │   ├── 反射 --> ( 难度等级: [0.4707, 0.4717) || 挂载数据: qa: 1 ) 
│   │   ├── 远程方法调用 --> ( 难度等级: [0.4717, 0.4727) || 挂载数据: 无 ) 
│   │   ├── 使用java.text格式化日期和时间 --> ( 难度等级: [0.4727, 0.4736) || 挂载数据: qa: 1 ) 
│   │   │   ├── DateFormat类 --> ( 难度等级: [0.4727, 0.4731) || 挂载数据: 无 ) 
│   │   │   └── SimpleDateFormat类 --> ( 难度等级: [0.4731, 0.4736) || 挂载数据: 无 ) 
│   │   ├── JDK 8新增的时间和日期API --> ( 难度等级: [0.4736, 0.4746) || 挂载数据: 无 ) 
│   │   │   ├── 时间和日期的基础知识 --> ( 难度等级: [0.4736, 0.474) || 挂载数据: 无 ) 
│   │   │   ├── 格式化日期和时间 --> ( 难度等级: [0.474, 0.4743) || 挂载数据: 无 ) 
│   │   │   └── 解析日期和时间字符串 --> ( 难度等级: [0.4743, 0.4746) || 挂载数据: 无 ) 
│   │   ├── 探究java.time包的其他方面 --> ( 难度等级: [0.4746, 0.4756) || 挂载数据: 无 ) 
│   │   ├── 匹配字符串 --> ( 难度等级: [0.4756, 0.4766) || 挂载数据: 无 ) 
│   │   ├── 找出多个匹配 --> ( 难度等级: [0.4766, 0.4775) || 挂载数据: 无 ) 
│   │   ├── 用分隔符来分割 --> ( 难度等级: [0.4775, 0.4785) || 挂载数据: 无 ) 
│   │   ├── 替换匹配 --> ( 难度等级: [0.4785, 0.4795) || 挂载数据: qa: 1 ) 
│   │   ├── 正则表达式简介 --> ( 难度等级: [0.4795, 0.4805) || 挂载数据: 无 ) 
│   │   ├── 匹配规则 --> ( 难度等级: [0.4805, 0.4814) || 挂载数据: 无 ) 
│   │   ├── 分组匹配 --> ( 难度等级: [0.4814, 0.4824) || 挂载数据: 无 ) 
│   │   ├── 非贪婪匹配 --> ( 难度等级: [0.4824, 0.4834) || 挂载数据: 无 ) 
│   │   └── 搜索和替换 --> ( 难度等级: [0.4834, 0.4844) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.4844, 0.5) || 挂载数据: 无 ) 
│       ├── 并发编程的挑战 --> ( 难度等级: [0.4844, 0.4849) || 挂载数据: 无 ) 
│       │   ├── 上下文切换 --> ( 难度等级: [0.4844, 0.4846) || 挂载数据: 无 ) 
│       │   │   ├── 多线程一定快吗 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 多线程基础 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 创建新线程 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 中断线程 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 守护线程 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 线程同步 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 同步方法 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用wait和notify --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 使用ReentrantLock --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 使用Condition --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用ReadWriteLock --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用StampedLock --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Concurrent集合 --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Atomic --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 使用ForkJoin --> ( 难度等级: [0.4844, 0.4844) || 挂载数据: 无 ) 
│       │   │   ├── 测试上下文切换次数和时长 --> ( 难度等级: [0.4844, 0.4845) || 挂载数据: 无 ) 
│       │   │   └── 如何减少上下文切换 --> ( 难度等级: [0.4845, 0.4846) || 挂载数据: qa: 2 ) 
│       │   ├── 死锁 --> ( 难度等级: [0.4846, 0.4847) || 挂载数据: 无 ) 
│       │   └── 资源限制的挑战 --> ( 难度等级: [0.4847, 0.4849) || 挂载数据: 无 ) 
│       ├── Java并发机制的底层实现原理 --> ( 难度等级: [0.4849, 0.4855) || 挂载数据: 无 ) 
│       │   ├── volatile的应用 --> ( 难度等级: [0.4849, 0.4851) || 挂载数据: qa: 1 ) 
│       │   ├── synchronized的实现原理与应用 --> ( 难度等级: [0.4851, 0.4853) || 挂载数据: qa: 9 ) 
│       │   │   ├── Java对象头 --> ( 难度等级: [0.4851, 0.4852) || 挂载数据: qa: 1 ) 
│       │   │   └── 锁的升级与对比 --> ( 难度等级: [0.4852, 0.4853) || 挂载数据: qa: 2 ) 
│       │   └── 原子操作的实现原理 --> ( 难度等级: [0.4853, 0.4855) || 挂载数据: 无 ) 
│       ├── Java内存模型 --> ( 难度等级: [0.4855, 0.486) || 挂载数据: 无 ) 
│       │   ├── Java内存模型的基础 --> ( 难度等级: [0.4855, 0.4856) || 挂载数据: 无 ) 
│       │   │   ├── Java内存模型的抽象结构 --> ( 难度等级: [0.4855, 0.4855) || 挂载数据: qa: 1 ) 
│       │   │   ├── 从源代码到指令序列的重排序 --> ( 难度等级: [0.4855, 0.4855) || 挂载数据: qa: 1 ) 
│       │   │   ├── 并发编程模型的分类 --> ( 难度等级: [0.4855, 0.4855) || 挂载数据: 无 ) 
│       │   │   └── happens-before简介 --> ( 难度等级: [0.4855, 0.4856) || 挂载数据: 无 ) 
│       │   ├── 重排序 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: 无 ) 
│       │   │   ├── 数据依赖性 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: qa: 1 ) 
│       │   │   ├── as-if-serial语义 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: qa: 1 ) 
│       │   │   ├── 程序顺序规则 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: 无 ) 
│       │   │   └── 重排序对多线程的影响 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: qa: 10 ) 
│       │   ├── 顺序一致性 --> ( 难度等级: [0.4856, 0.4857) || 挂载数据: 无 ) 
│       │   │   ├── 数据竞争与顺序一致性 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: qa: 4 ) 
│       │   │   ├── 顺序一致性内存模型 --> ( 难度等级: [0.4856, 0.4856) || 挂载数据: 无 ) 
│       │   │   ├── 同步程序的顺序一致性效果 --> ( 难度等级: [0.4856, 0.4857) || 挂载数据: 无 ) 
│       │   │   └── 未同步程序的执行特性 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: 无 ) 
│       │   ├── volatile的内存语义 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: 无 ) 
│       │   │   ├── volatile的特性 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: qa: 10 ) 
│       │   │   ├── volatile写-读建立的happens-before关系 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: 无 ) 
│       │   │   ├── volatile写-读的内存语义 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: 无 ) 
│       │   │   └── volatile内存语义的实现 --> ( 难度等级: [0.4857, 0.4857) || 挂载数据: qa: 10 ) 
│       │   ├── 锁的内存语义 --> ( 难度等级: [0.4857, 0.4858) || 挂载数据: 无 ) 
│       │   │   ├── 锁的释放-获取建立的 --> ( 难度等级: [0.4857, 0.4858) || 挂载数据: 无 ) 
│       │   │   ├── 锁的释放和获取的内存语义 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: qa: 3 ) 
│       │   │   ├── 锁内存语义的实现 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: 无 ) 
│       │   │   └── concurrent包的实现 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: 无 ) 
│       │   ├── final域的内存语义 --> ( 难度等级: [0.4858, 0.4859) || 挂载数据: 无 ) 
│       │   │   ├── final域的重排序规则 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: 无 ) 
│       │   │   ├── 写final域的重排序规则 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: 无 ) 
│       │   │   ├── 读final域的重排序规则 --> ( 难度等级: [0.4858, 0.4858) || 挂载数据: 无 ) 
│       │   │   ├── final域为引用类型 --> ( 难度等级: [0.4858, 0.4859) || 挂载数据: 无 ) 
│       │   │   └── final语义在处理器中的实现 --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: 无 ) 
│       │   ├── happens-before --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: 无 ) 
│       │   │   ├── JMM的设计 --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: 无 ) 
│       │   │   ├── happens-before的定义 --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: qa: 10 ) 
│       │   │   └── happens-before规则 --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: 无 ) 
│       │   ├── 双重检查锁定与延迟初始化 --> ( 难度等级: [0.4859, 0.486) || 挂载数据: 无 ) 
│       │   │   ├── 双重检查锁定的由来 --> ( 难度等级: [0.4859, 0.4859) || 挂载数据: 无 ) 
│       │   │   ├── 基于volatile的解决方案 --> ( 难度等级: [0.4859, 0.486) || 挂载数据: 无 ) 
│       │   │   └── 基于类初始化的解决方案 --> ( 难度等级: [0.486, 0.486) || 挂载数据: 无 ) 
│       │   └── Java内存模型综述 --> ( 难度等级: [0.486, 0.486) || 挂载数据: 无 ) 
│       │       ├── 处理器的内存模型 --> ( 难度等级: [0.486, 0.486) || 挂载数据: 无 ) 
│       │       ├── 各种内存模型之间的关系 --> ( 难度等级: [0.486, 0.486) || 挂载数据: qa: 7 ) 
│       │       ├── JMM的内存可见性保证 --> ( 难度等级: [0.486, 0.486) || 挂载数据: 无 ) 
│       │       └── JSR-133对旧内存模型的修补 --> ( 难度等级: [0.486, 0.486) || 挂载数据: 无 ) 
│       ├── Java并发编程基础 --> ( 难度等级: [0.486, 0.4866) || 挂载数据: 无 ) 
│       │   ├── 线程简介 --> ( 难度等级: [0.486, 0.4862) || 挂载数据: 无 ) 
│       │   │   ├── 什么是线程 --> ( 难度等级: [0.486, 0.4861) || 挂载数据: qa: 3 ) 
│       │   │   ├── 线程优先级 --> ( 难度等级: [0.4861, 0.4861) || 挂载数据: 无 ) 
│       │   │   ├── 线程的状态 --> ( 难度等级: [0.4861, 0.4862) || 挂载数据: 无 ) 
│       │   │   └── Daemon线程 --> ( 难度等级: [0.4862, 0.4862) || 挂载数据: 无 ) 
│       │   ├── 启动和终止线程 --> ( 难度等级: [0.4862, 0.4864) || 挂载数据: 无 ) 
│       │   │   ├── 构造线程 --> ( 难度等级: [0.4862, 0.4863) || 挂载数据: 无 ) 
│       │   │   ├── 启动线程 --> ( 难度等级: [0.4863, 0.4863) || 挂载数据: qa: 10 ) 
│       │   │   ├── 理解中断 --> ( 难度等级: [0.4863, 0.4863) || 挂载数据: 无 ) 
│       │   │   ├── 过期的suspend、resume和stop --> ( 难度等级: [0.4863, 0.4864) || 挂载数据: 无 ) 
│       │   │   └── 安全地终止线程 --> ( 难度等级: [0.4864, 0.4864) || 挂载数据: qa: 5 ) 
│       │   └── 线程间通信 --> ( 难度等级: [0.4864, 0.4866) || 挂载数据: 无 ) 
│       │       ├── 等待/通知机制 --> ( 难度等级: [0.4864, 0.4865) || 挂载数据: 无 ) 
│       │       ├── 等待/通知的经典范式 --> ( 难度等级: [0.4865, 0.4865) || 挂载数据: 无 ) 
│       │       ├── 管道输入/输出流 --> ( 难度等级: [0.4865, 0.4866) || 挂载数据: 无 ) 
│       │       └── Thread.join的使用 --> ( 难度等级: [0.4866, 0.4866) || 挂载数据: 无 ) 
│       ├── Java中的锁 --> ( 难度等级: [0.4866, 0.4872) || 挂载数据: 无 ) 
│       │   ├── Lock接口 --> ( 难度等级: [0.4866, 0.4867) || 挂载数据: qa: 1 ) 
│       │   ├── 队列同步器 --> ( 难度等级: [0.4867, 0.4868) || 挂载数据: 无 ) 
│       │   │   ├── 队列同步器的接口与示例 --> ( 难度等级: [0.4867, 0.4867) || 挂载数据: 无 ) 
│       │   │   │   ├── Windows注册表概述 --> ( 难度等级: [0.4867, 0.4867) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问注册表的Java平台接口 --> ( 难度等级: [0.4867, 0.4867) || 挂载数据: 无 ) 
│       │   │   │   └── 以本地方法实现注册表访问函数 --> ( 难度等级: [0.4867, 0.4867) || 挂载数据: 无 ) 
│       │   │   └── 队列同步器的实现分析 --> ( 难度等级: [0.4867, 0.4868) || 挂载数据: qa: 1 ) 
│       │   ├── 重入锁 --> ( 难度等级: [0.4868, 0.4869) || 挂载数据: qa: 1 ) 
│       │   ├── 读写锁 --> ( 难度等级: [0.4869, 0.487) || 挂载数据: 无 ) 
│       │   │   ├── 读写锁的接口与示例 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: 无 ) 
│       │   │   └── 读写锁的实现分析 --> ( 难度等级: [0.4869, 0.487) || 挂载数据: qa: 2 ) 
│       │   ├── LockSupport工具 --> ( 难度等级: [0.487, 0.4871) || 挂载数据: 无 ) 
│       │   └── Condition接口 --> ( 难度等级: [0.4871, 0.4872) || 挂载数据: 无 ) 
│       │       ├── Condition接口与示例 --> ( 难度等级: [0.4871, 0.4871) || 挂载数据: 无 ) 
│       │       └── Condition的实现分析 --> ( 难度等级: [0.4871, 0.4872) || 挂载数据: qa: 1 ) 
│       ├── Java并发容器和框架 --> ( 难度等级: [0.4872, 0.4877) || 挂载数据: 无 ) 
│       │   ├── ConcurrentHashMap的实现原理与使用 --> ( 难度等级: [0.4872, 0.4873) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentHashMap的结构 --> ( 难度等级: [0.4872, 0.4872) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentHashMap的初始化 --> ( 难度等级: [0.4872, 0.4872) || 挂载数据: 无 ) 
│       │   │   ├── 定位Segment --> ( 难度等级: [0.4872, 0.4873) || 挂载数据: 无 ) 
│       │   │   └── ConcurrentHashMap的操作 --> ( 难度等级: [0.4873, 0.4873) || 挂载数据: qa: 1 ) 
│       │   ├── ConcurrentLinkedQueue --> ( 难度等级: [0.4873, 0.4874) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentLinkedQueue的结构 --> ( 难度等级: [0.4873, 0.4874) || 挂载数据: 无 ) 
│       │   │   ├── 入队列 --> ( 难度等级: [0.4874, 0.4874) || 挂载数据: qa: 1 ) 
│       │   │   └── 出队列 --> ( 难度等级: [0.4874, 0.4874) || 挂载数据: qa: 5 ) 
│       │   ├── Java中的阻塞队列 --> ( 难度等级: [0.4874, 0.4876) || 挂载数据: 无 ) 
│       │   │   ├── 什么是阻塞队列 --> ( 难度等级: [0.4874, 0.4875) || 挂载数据: 无 ) 
│       │   │   ├── Java里的阻塞队列 --> ( 难度等级: [0.4875, 0.4875) || 挂载数据: 无 ) 
│       │   │   └── 阻塞队列的实现原理 --> ( 难度等级: [0.4875, 0.4876) || 挂载数据: 无 ) 
│       │   └── Fork/Join框架 --> ( 难度等级: [0.4876, 0.4877) || 挂载数据: 无 ) 
│       │       ├── 什么是Fork/Join框架 --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: qa: 3 ) 
│       │       ├── 工作窃取算法 --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: 无 ) 
│       │       ├── Fork/Join框架的设计 --> ( 难度等级: [0.4876, 0.4877) || 挂载数据: 无 ) 
│       │       ├── 使用Fork/Join框架 --> ( 难度等级: [0.4877, 0.4877) || 挂载数据: 无 ) 
│       │       ├── Fork/Join框架的异常处理 --> ( 难度等级: [0.4877, 0.4877) || 挂载数据: qa: 2 ) 
│       │       └── Fork/Join框架的实现原理 --> ( 难度等级: [0.4877, 0.4877) || 挂载数据: qa: 1 ) 
│       ├── Java中的13个原子操作类 --> ( 难度等级: [0.4877, 0.4883) || 挂载数据: 无 ) 
│       │   ├── 原子更新基本类型类 --> ( 难度等级: [0.4877, 0.4879) || 挂载数据: 无 ) 
│       │   ├── 原子更新数组 --> ( 难度等级: [0.4879, 0.488) || 挂载数据: 无 ) 
│       │   ├── 原子更新引用类型 --> ( 难度等级: [0.488, 0.4881) || 挂载数据: 无 ) 
│       │   └── 原子更新字段类 --> ( 难度等级: [0.4881, 0.4883) || 挂载数据: 无 ) 
│       ├── Java中的并发工具类 --> ( 难度等级: [0.4883, 0.4888) || 挂载数据: 无 ) 
│       │   ├── 等待多线程完成的CountDownLatch --> ( 难度等级: [0.4883, 0.4884) || 挂载数据: 无 ) 
│       │   ├── 同步屏障CyclicBarrier --> ( 难度等级: [0.4884, 0.4886) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier简介 --> ( 难度等级: [0.4884, 0.4885) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier的应用场景 --> ( 难度等级: [0.4885, 0.4885) || 挂载数据: 无 ) 
│       │   │   └── CyclicBarrier和CountDownLatch的区别 --> ( 难度等级: [0.4885, 0.4886) || 挂载数据: qa: 1 ) 
│       │   ├── 控制并发线程数的Semaphore --> ( 难度等级: [0.4886, 0.4887) || 挂载数据: qa: 2 ) 
│       │   └── 线程间交换数据的Exchanger --> ( 难度等级: [0.4887, 0.4888) || 挂载数据: qa: 1 ) 
│       ├── Java中的线程池 --> ( 难度等级: [0.4888, 0.4894) || 挂载数据: 无 ) 
│       │   ├── 线程池的实现原理 --> ( 难度等级: [0.4888, 0.4891) || 挂载数据: 无 ) 
│       │   └── 线程池的使用 --> ( 难度等级: [0.4891, 0.4894) || 挂载数据: 无 ) 
│       │       ├── 线程池的创建 --> ( 难度等级: [0.4891, 0.4892) || 挂载数据: qa: 2 ) 
│       │       ├── 向线程池提交任务 --> ( 难度等级: [0.4892, 0.4892) || 挂载数据: 无 ) 
│       │       ├── 关闭线程池 --> ( 难度等级: [0.4892, 0.4893) || 挂载数据: qa: 10 ) 
│       │       ├── 合理地配置线程池 --> ( 难度等级: [0.4893, 0.4893) || 挂载数据: 无 ) 
│       │       └── 线程池的监控 --> ( 难度等级: [0.4893, 0.4894) || 挂载数据: 无 ) 
│       ├── Executor框架 --> ( 难度等级: [0.4894, 0.49) || 挂载数据: 无 ) 
│       │   ├── Executor框架简介 --> ( 难度等级: [0.4894, 0.4895) || 挂载数据: 无 ) 
│       │   │   ├── Executor框架的两级调度模型 --> ( 难度等级: [0.4894, 0.4895) || 挂载数据: 无 ) 
│       │   │   └── Executor框架的结构与成员 --> ( 难度等级: [0.4895, 0.4895) || 挂载数据: qa: 10 ) 
│       │   ├── ThreadPoolExecutor详解 --> ( 难度等级: [0.4895, 0.4897) || 挂载数据: 无 ) 
│       │   │   ├── FixedThreadPool详解 --> ( 难度等级: [0.4895, 0.4896) || 挂载数据: 无 ) 
│       │   │   ├── SingleThreadExecutor详解 --> ( 难度等级: [0.4896, 0.4896) || 挂载数据: 无 ) 
│       │   │   └── CachedThreadPool详解 --> ( 难度等级: [0.4896, 0.4897) || 挂载数据: 无 ) 
│       │   ├── ScheduledThreadPoolExecutor详解 --> ( 难度等级: [0.4897, 0.4898) || 挂载数据: 无 ) 
│       │   │   ├── ScheduledThreadPoolExecutor的运行机制 --> ( 难度等级: [0.4897, 0.4897) || 挂载数据: 无 ) 
│       │   │   └── ScheduledThreadPoolExecutor的实现 --> ( 难度等级: [0.4897, 0.4898) || 挂载数据: 无 ) 
│       │   └── FutureTask详解 --> ( 难度等级: [0.4898, 0.49) || 挂载数据: 无 ) 
│       │       ├── FutureTask简介 --> ( 难度等级: [0.4898, 0.4899) || 挂载数据: 无 ) 
│       │       ├── FutureTask的使用 --> ( 难度等级: [0.4899, 0.4899) || 挂载数据: 无 ) 
│       │       └── FutureTask的实现 --> ( 难度等级: [0.4899, 0.49) || 挂载数据: 无 ) 
│       ├── Java并发编程实践 --> ( 难度等级: [0.49, 0.4905) || 挂载数据: 无 ) 
│       │   ├── 生产者和消费者模式 --> ( 难度等级: [0.49, 0.4901) || 挂载数据: 无 ) 
│       │   │   └── 多生产者和多消费者场景 --> ( 难度等级: [0.49, 0.4901) || 挂载数据: qa: 7 ) 
│       │   ├── 性能测试 --> ( 难度等级: [0.4901, 0.4903) || 挂载数据: 无 ) 
│       │   └── 异步任务池 --> ( 难度等级: [0.4903, 0.4905) || 挂载数据: 无 ) 
│       ├── 基础知识 --> ( 难度等级: [0.4905, 0.4911) || 挂载数据: 无 ) 
│       │   ├── Java 8、9、10以及11的变化 --> ( 难度等级: [0.4905, 0.4907) || 挂载数据: 无 ) 
│       │   │   ├── Java怎么还在变 --> ( 难度等级: [0.4905, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   ├── Java在编程语言生态系统中的位置 --> ( 难度等级: [0.4905, 0.4905) || 挂载数据: 无 ) 
│       │   │   │   ├── 用行为参数化把代码传递给方法 --> ( 难度等级: [0.4905, 0.4905) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 并行与共享的可变数据 --> ( 难度等级: [0.4905, 0.4905) || 挂载数据: 无 ) 
│       │   │   │   └── Java需要演变 --> ( 难度等级: [0.4905, 0.4906) || 挂载数据: 无 ) 
│       │   │   ├── Java中的函数 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   ├── 方法和Lambda作为一等值 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 从Java程序中调用C函数 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 数值参数与返回值 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 字符串参数 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 访问域 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   │   └── 访问静态域 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 5 ) 
│       │   │   │   │   ├── 编码签名 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 5 ) 
│       │   │   │   │   ├── 调用Java方法 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   │   ├── 静态方法 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 4 ) 
│       │   │   │   │   │   ├── 构造器 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   │   └── 另一种方法调用 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 访问数组元素 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 1 ) 
│       │   │   │   │   └── 使用调用API --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递代码：一个例子 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   └── 从传递方法到Lambda --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   ├── 默认方法及Java模块 --> ( 难度等级: [0.4906, 0.4907) || 挂载数据: 无 ) 
│       │   │   │   ├── 不断演进的API --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 初始版本的API --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   └── 第二版API --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 概述默认方法 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 默认方法的使用模式 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   │   └── 行为的多继承 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │   └── 解决冲突的规则 --> ( 难度等级: [0.4906, 0.4907) || 挂载数据: qa: 3 ) 
│       │   │   │       ├── 选择提供了最具体实现的默认方法的接口 --> ( 难度等级: [0.4906, 0.4906) || 挂载数据: 无 ) 
│       │   │   │       └── 冲突及如何显式地消除歧义 --> ( 难度等级: [0.4906, 0.4907) || 挂载数据: qa: 1 ) 
│       │   │   └── 来自函数式编程的其他好思想 --> ( 难度等级: [0.4907, 0.4907) || 挂载数据: 无 ) 
│       │   ├── 通过行为参数化传递代码 --> ( 难度等级: [0.4907, 0.4909) || 挂载数据: 无 ) 
│       │   │   ├── 应对不断变化的需求 --> ( 难度等级: [0.4907, 0.4907) || 挂载数据: 无 ) 
│       │   │   │   ├── 初试牛刀：筛选绿苹果 --> ( 难度等级: [0.4907, 0.4907) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 再展身手：把颜色作为参数 --> ( 难度等级: [0.4907, 0.4907) || 挂载数据: 无 ) 
│       │   │   │   └── 第三次尝试：对你能想到的每个属性做筛选 --> ( 难度等级: [0.4907, 0.4907) || 挂载数据: qa: 1 ) 
│       │   │   ├── 行为参数化 --> ( 难度等级: [0.4907, 0.4908) || 挂载数据: qa: 3 ) 
│       │   │   ├── 对付啰唆 --> ( 难度等级: [0.4908, 0.4908) || 挂载数据: 无 ) 
│       │   │   │   ├── 匿名类 --> ( 难度等级: [0.4908, 0.4908) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 第五次尝试：使用匿名类 --> ( 难度等级: [0.4908, 0.4908) || 挂载数据: 无 ) 
│       │   │   │   ├── 第六次尝试：使用Lambda表达式 --> ( 难度等级: [0.4908, 0.4908) || 挂载数据: 无 ) 
│       │   │   │   └── 第七次尝试：将List类型抽象化 --> ( 难度等级: [0.4908, 0.4908) || 挂载数据: 无 ) 
│       │   │   └── 真实的例子 --> ( 难度等级: [0.4908, 0.4909) || 挂载数据: 无 ) 
│       │   │       ├── 用Comparator来排序 --> ( 难度等级: [0.4908, 0.4909) || 挂载数据: qa: 4 ) 
│       │   │       ├── 用Runnable执行代码块 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │   │       ├── 通过Callable返回结果 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 4 ) 
│       │   │       └── GUI事件处理 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 10 ) 
│       │   └── Lambda表达式 --> ( 难度等级: [0.4909, 0.4911) || 挂载数据: 无 ) 
│       │       ├── Lambda管中窥豹 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       ├── 在哪里以及如何使用Lambda --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   ├── 函数式接口 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   └── 函数描述符 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       ├── 把Lambda付诸实践：环绕执行模式 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   ├── 第 1 步：记得行为参数化 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 1 ) 
│       │       │   ├── 第 2 步：使用函数式接口来传递行为 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   ├── 第 3 步：执行一个行为 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 10 ) 
│       │       │   └── 第 4 步：传递Lambda --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 9 ) 
│       │       ├── 使用函数式接口 --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   ├── Predicate --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: 无 ) 
│       │       │   ├── Consumer --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 1 ) 
│       │       │   └── Function --> ( 难度等级: [0.4909, 0.4909) || 挂载数据: qa: 3 ) 
│       │       ├── 类型检查、类型推断以及限制 --> ( 难度等级: [0.4909, 0.491) || 挂载数据: 无 ) 
│       │       │   ├── 类型检查 --> ( 难度等级: [0.4909, 0.491) || 挂载数据: qa: 2 ) 
│       │       │   ├── 同样的Lambda，不同的函数式接口 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   ├── 类型推断 --> ( 难度等级: [0.491, 0.491) || 挂载数据: qa: 10 ) 
│       │       │   └── 使用局部变量 --> ( 难度等级: [0.491, 0.491) || 挂载数据: qa: 3 ) 
│       │       ├── 方法引用 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   ├── 管中窥豹 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   └── 构造函数引用 --> ( 难度等级: [0.491, 0.491) || 挂载数据: qa: 10 ) 
│       │       ├── 复合Lambda表达式的有用方法 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   ├── 比较器复合 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   ├── 谓词复合 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   └── 函数复合 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       ├── 数学中的类似思想 --> ( 难度等级: [0.491, 0.491) || 挂载数据: qa: 1 ) 
│       │       │   ├── 积分 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       │   └── 与Java 8的Lambda联系起来 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       ├── 测试可见Lambda函数的行为 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       ├── 测试使用Lambda的方法的行为 --> ( 难度等级: [0.491, 0.491) || 挂载数据: 无 ) 
│       │       ├── 将复杂的Lambda表达式分为不同的方法 --> ( 难度等级: [0.491, 0.4911) || 挂载数据: qa: 1 ) 
│       │       └── 高阶函数的测试 --> ( 难度等级: [0.4911, 0.4911) || 挂载数据: 无 ) 
│       ├── 使用流进行函数式数据处理 --> ( 难度等级: [0.4911, 0.4916) || 挂载数据: 无 ) 
│       │   ├── 引入流 --> ( 难度等级: [0.4911, 0.4914) || 挂载数据: 无 ) 
│       │   │   ├── 流简介 --> ( 难度等级: [0.4911, 0.4912) || 挂载数据: 无 ) 
│       │   │   ├── 流操作 --> ( 难度等级: [0.4912, 0.4913) || 挂载数据: 无 ) 
│       │   │   │   ├── 中间操作 --> ( 难度等级: [0.4912, 0.4912) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 终端操作 --> ( 难度等级: [0.4912, 0.4913) || 挂载数据: 无 ) 
│       │   │   └── 路线图 --> ( 难度等级: [0.4913, 0.4914) || 挂载数据: 无 ) 
│       │   └── 用流收集数据 --> ( 难度等级: [0.4914, 0.4916) || 挂载数据: 无 ) 
│       │       ├── 收集器简介 --> ( 难度等级: [0.4914, 0.4914) || 挂载数据: 无 ) 
│       │       │   ├── 收集器用作高级归约 --> ( 难度等级: [0.4914, 0.4914) || 挂载数据: qa: 1 ) 
│       │       │   └── 预定义收集器 --> ( 难度等级: [0.4914, 0.4914) || 挂载数据: 无 ) 
│       │       ├── 分组 --> ( 难度等级: [0.4914, 0.4915) || 挂载数据: 无 ) 
│       │       │   ├── 操作分组的元素 --> ( 难度等级: [0.4914, 0.4914) || 挂载数据: 无 ) 
│       │       │   ├── 多级分组 --> ( 难度等级: [0.4914, 0.4914) || 挂载数据: qa: 8 ) 
│       │       │   └── 按子组收集数据 --> ( 难度等级: [0.4914, 0.4915) || 挂载数据: 无 ) 
│       │       ├── 分区 --> ( 难度等级: [0.4915, 0.4915) || 挂载数据: 无 ) 
│       │       │   ├── 分区的优势 --> ( 难度等级: [0.4915, 0.4915) || 挂载数据: qa: 3 ) 
│       │       │   └── 将数字按质数和非质数分区 --> ( 难度等级: [0.4915, 0.4915) || 挂载数据: 无 ) 
│       │       ├── 收集器接口 --> ( 难度等级: [0.4915, 0.4916) || 挂载数据: 无 ) 
│       │       │   ├── 理解Collector接口声明的方法 --> ( 难度等级: [0.4915, 0.4915) || 挂载数据: qa: 1 ) 
│       │       │   └── 全部融合到一起 --> ( 难度等级: [0.4915, 0.4916) || 挂载数据: 无 ) 
│       │       └── 开发你自己的收集器以获得更好的性能 --> ( 难度等级: [0.4916, 0.4916) || 挂载数据: 无 ) 
│       │           ├── 仅用质数做除数 --> ( 难度等级: [0.4916, 0.4916) || 挂载数据: 无 ) 
│       │           └── 比较收集器的性能 --> ( 难度等级: [0.4916, 0.4916) || 挂载数据: qa: 3 ) 
│       ├── 无所不在的Java --> ( 难度等级: [0.4916, 0.4922) || 挂载数据: 无 ) 
│       │   ├── 用Optional取代null --> ( 难度等级: [0.4916, 0.4919) || 挂载数据: 无 ) 
│       │   │   ├── 如何为缺失的值建模 --> ( 难度等级: [0.4916, 0.4917) || 挂载数据: 无 ) 
│       │   │   │   ├── 采用防御式检查减少NullPointerException --> ( 难度等级: [0.4916, 0.4917) || 挂载数据: 无 ) 
│       │   │   │   └── 其他语言中null的替代品 --> ( 难度等级: [0.4917, 0.4917) || 挂载数据: qa: 10 ) 
│       │   │   ├── Optional类入门 --> ( 难度等级: [0.4917, 0.4918) || 挂载数据: 无 ) 
│       │   │   └── 应用Optional的几种模式 --> ( 难度等级: [0.4918, 0.4919) || 挂载数据: 无 ) 
│       │   │       ├── 创建Optional对象 --> ( 难度等级: [0.4918, 0.4918) || 挂载数据: 无 ) 
│       │   │       ├── 使用map从Optional对象中提取和转换值 --> ( 难度等级: [0.4918, 0.4918) || 挂载数据: 无 ) 
│       │   │       ├── 使用flatMap链接Optional对象 --> ( 难度等级: [0.4918, 0.4919) || 挂载数据: 无 ) 
│       │   │       ├── 操纵由Optional对象构成的Stream --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: 无 ) 
│       │   │       ├── 默认行为及解引用Optional对象 --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: 无 ) 
│       │   │       ├── 两个Optional对象的组合 --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: qa: 1 ) 
│       │   │       └── 使用filter剔除特定的值 --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: qa: 1 ) 
│       │   └── Java模块系统 --> ( 难度等级: [0.4919, 0.4922) || 挂载数据: 无 ) 
│       │       ├── 模块化的驱动力：软件的推理 --> ( 难度等级: [0.4919, 0.492) || 挂载数据: 无 ) 
│       │       │   ├── 关注点分离 --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: qa: 2 ) 
│       │       │   ├── 信息隐藏 --> ( 难度等级: [0.4919, 0.4919) || 挂载数据: 无 ) 
│       │       │   └── Java软件 --> ( 难度等级: [0.4919, 0.492) || 挂载数据: qa: 8 ) 
│       │       ├── 使用Java模块系统开发应用 --> ( 难度等级: [0.492, 0.492) || 挂载数据: 无 ) 
│       │       │   ├── 从头开始搭建一个应用 --> ( 难度等级: [0.492, 0.492) || 挂载数据: 无 ) 
│       │       │   ├── 细粒度和粗粒度的模块化 --> ( 难度等级: [0.492, 0.492) || 挂载数据: 无 ) 
│       │       │   └── Java模块系统基础 --> ( 难度等级: [0.492, 0.492) || 挂载数据: qa: 10 ) 
│       │       ├── 使用多个模块 --> ( 难度等级: [0.492, 0.492) || 挂载数据: qa: 1 ) 
│       │       │   ├── exports子句 --> ( 难度等级: [0.492, 0.492) || 挂载数据: 无 ) 
│       │       │   ├── requires子句 --> ( 难度等级: [0.492, 0.492) || 挂载数据: 无 ) 
│       │       │   └── 命名 --> ( 难度等级: [0.492, 0.492) || 挂载数据: qa: 1 ) 
│       │       ├── 编译及打包 --> ( 难度等级: [0.492, 0.4921) || 挂载数据: 无 ) 
│       │       ├── 自动模块 --> ( 难度等级: [0.4921, 0.4921) || 挂载数据: qa: 1 ) 
│       │       └── 模块声明及子句 --> ( 难度等级: [0.4921, 0.4922) || 挂载数据: 无 ) 
│       │           ├── requires --> ( 难度等级: [0.4921, 0.4921) || 挂载数据: 无 ) 
│       │           ├── exports --> ( 难度等级: [0.4921, 0.4922) || 挂载数据: 无 ) 
│       │           ├── requires的传递 --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │           ├── exports to --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: qa: 4 ) 
│       │           ├── open和opens --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: qa: 4 ) 
│       │           └── uses和provides --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       ├── 提升Java的并发性 --> ( 难度等级: [0.4922, 0.4927) || 挂载数据: 无 ) 
│       │   ├── CompletableFuture及反应式编程背后的概念 --> ( 难度等级: [0.4922, 0.4924) || 挂载数据: 无 ) 
│       │   │   ├── 为支持并发而不断演进的Java --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   │   ├── 其他的线程抽象：非嵌套方法调用 --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   │   └── 你希望线程为你带来什么 --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: qa: 10 ) 
│       │   │   ├── 同步及异步API --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   │   ├── Future风格的API --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 反应式风格的API --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   │   ├── 有害的睡眠及其他阻塞式操作 --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   │   └── 如何使用异步API进行异常处理 --> ( 难度等级: [0.4922, 0.4922) || 挂载数据: 无 ) 
│       │   │   ├── “线框–管道”模型 --> ( 难度等级: [0.4922, 0.4923) || 挂载数据: 无 ) 
│       │   │   ├── 为并发而生的CompletableFuture和结合器 --> ( 难度等级: [0.4923, 0.4923) || 挂载数据: qa: 1 ) 
│       │   │   ├── “发布–订阅”以及反应式编程 --> ( 难度等级: [0.4923, 0.4923) || 挂载数据: 无 ) 
│       │   │   │   ├── 背压 --> ( 难度等级: [0.4923, 0.4923) || 挂载数据: 无 ) 
│       │   │   │   └── 一种简单的真实背压 --> ( 难度等级: [0.4923, 0.4923) || 挂载数据: 无 ) 
│       │   │   └── 反应式系统和反应式编程 --> ( 难度等级: [0.4923, 0.4924) || 挂载数据: 无 ) 
│       │   ├── CompletableFuture：组合式异步编程 --> ( 难度等级: [0.4924, 0.4926) || 挂载数据: 无 ) 
│       │   │   ├── 实现异步API --> ( 难度等级: [0.4924, 0.4924) || 挂载数据: 无 ) 
│       │   │   │   ├── 将同步方法转换为异步方法 --> ( 难度等级: [0.4924, 0.4924) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 错误处理 --> ( 难度等级: [0.4924, 0.4924) || 挂载数据: 无 ) 
│       │   │   ├── 让你的代码免受阻塞之苦 --> ( 难度等级: [0.4924, 0.4925) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用并行流对请求进行并行操作 --> ( 难度等级: [0.4924, 0.4924) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用CompletableFuture发起异步请求 --> ( 难度等级: [0.4924, 0.4924) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 寻找更好的方案 --> ( 难度等级: [0.4924, 0.4925) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 使用定制的执行器 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   ├── 对多个异步任务进行流水线操作 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   │   ├── 实现折扣服务 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Discount服务 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 构造同步和异步操作 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 将两个CompletableFuture对象整合起来，无论它们是否存在依赖 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   │   ├── 对Future和Completable-Future的回顾 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   │   └── 高效地使用超时机制 --> ( 难度等级: [0.4925, 0.4925) || 挂载数据: 无 ) 
│       │   │   └── 响应CompletableFuture的completion事件 --> ( 难度等级: [0.4925, 0.4926) || 挂载数据: 无 ) 
│       │   │       └── 对最佳价格查询器应用的优化 --> ( 难度等级: [0.4925, 0.4926) || 挂载数据: qa: 1 ) 
│       │   └── 反应式编程 --> ( 难度等级: [0.4926, 0.4927) || 挂载数据: 无 ) 
│       │       ├── 反应式宣言 --> ( 难度等级: [0.4926, 0.4926) || 挂载数据: 无 ) 
│       │       │   ├── 应用层的反应式编程 --> ( 难度等级: [0.4926, 0.4926) || 挂载数据: 无 ) 
│       │       │   └── 反应式系统 --> ( 难度等级: [0.4926, 0.4926) || 挂载数据: 无 ) 
│       │       ├── 反应式流以及Flow API --> ( 难度等级: [0.4926, 0.4927) || 挂载数据: 无 ) 
│       │       │   ├── Flow类 --> ( 难度等级: [0.4926, 0.4926) || 挂载数据: 无 ) 
│       │       │   ├── 创建你的第一个反应式应用 --> ( 难度等级: [0.4926, 0.4927) || 挂载数据: 无 ) 
│       │       │   └── 使用Processor转换数据 --> ( 难度等级: [0.4927, 0.4927) || 挂载数据: qa: 1 ) 
│       │       └── 使用反应式库RxJava --> ( 难度等级: [0.4927, 0.4927) || 挂载数据: qa: 3 ) 
│       │           └── 转换及整合多个Observable --> ( 难度等级: [0.4927, 0.4927) || 挂载数据: qa: 3 ) 
│       ├── 函数式编程以及Java未来的演进 --> ( 难度等级: [0.4927, 0.4933) || 挂载数据: 无 ) 
│       │   ├── 函数式的思考 --> ( 难度等级: [0.4927, 0.4929) || 挂载数据: qa: 1 ) 
│       │   │   ├── 实现和维护系统 --> ( 难度等级: [0.4927, 0.4928) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 声明式编程 --> ( 难度等级: [0.4927, 0.4928) || 挂载数据: 无 ) 
│       │   │   ├── 什么是函数式编程 --> ( 难度等级: [0.4928, 0.4928) || 挂载数据: 无 ) 
│       │   │   │   ├── 函数式Java编程 --> ( 难度等级: [0.4928, 0.4928) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 引用透明性 --> ( 难度等级: [0.4928, 0.4928) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 面向对象的编程和函数式编程的对比 --> ( 难度等级: [0.4928, 0.4928) || 挂载数据: qa: 1 ) 
│       │   │   └── 递归和迭代 --> ( 难度等级: [0.4928, 0.4929) || 挂载数据: 无 ) 
│       │   ├── 函数式编程的技巧 --> ( 难度等级: [0.4929, 0.493) || 挂载数据: 无 ) 
│       │   │   ├── 无处不在的函数 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   └── 柯里化 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   ├── 持久化数据结构 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   ├── 破坏式更新和函数式更新的比较 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   ├── 另一个使用Tree的例子 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: qa: 4 ) 
│       │   │   │   └── 采用函数式的方法 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: qa: 1 ) 
│       │   │   ├── Stream的延迟计算 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义的Stream --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: qa: 8 ) 
│       │   │   │   └── 创建你自己的延迟列表 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   ├── 模式匹配 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问者模式 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   │   └── 用模式匹配力挽狂澜 --> ( 难度等级: [0.4929, 0.4929) || 挂载数据: 无 ) 
│       │   │   └── 杂项 --> ( 难度等级: [0.4929, 0.493) || 挂载数据: 无 ) 
│       │   │       ├── 缓存或记忆表 --> ( 难度等级: [0.4929, 0.493) || 挂载数据: qa: 4 ) 
│       │   │       └── “返回同样的对象”意味着什么 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   ├── 结论以及Java的未来 --> ( 难度等级: [0.493, 0.4931) || 挂载数据: 无 ) 
│       │   │   ├── 回顾Java 8的语言特性 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   ├── Java 10的局部变量类型推断 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   ├── Java的未来 --> ( 难度等级: [0.493, 0.493) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 声明处型变 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   │   ├── 模式匹配 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   │   ├── 更加丰富的泛型形式 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   │   ├── 对不变性的更深层支持 --> ( 难度等级: [0.493, 0.493) || 挂载数据: 无 ) 
│       │   │   │   └── 值类型 --> ( 难度等级: [0.493, 0.493) || 挂载数据: qa: 10 ) 
│       │   │   ├── 让Java发展得更快 --> ( 难度等级: [0.493, 0.4931) || 挂载数据: 无 ) 
│       │   │   └── 写在最后的话 --> ( 难度等级: [0.4931, 0.4931) || 挂载数据: qa: 10 ) 
│       │   ├── Lambda基础 --> ( 难度等级: [0.4931, 0.4932) || 挂载数据: 无 ) 
│       │   └── 使用Stream --> ( 难度等级: [0.4932, 0.4933) || 挂载数据: qa: 1 ) 
│       │       ├── 创建Stream --> ( 难度等级: [0.4932, 0.4932) || 挂载数据: qa: 3 ) 
│       │       ├── 使用filter --> ( 难度等级: [0.4932, 0.4932) || 挂载数据: qa: 4 ) 
│       │       ├── 使用reduce --> ( 难度等级: [0.4932, 0.4933) || 挂载数据: 无 ) 
│       │       └── 输出集合 --> ( 难度等级: [0.4933, 0.4933) || 挂载数据: qa: 2 ) 
│       ├── Java 8的流库 --> ( 难度等级: [0.4933, 0.4939) || 挂载数据: 无 ) 
│       │   ├── 从迭代到流的操作 --> ( 难度等级: [0.4933, 0.4934) || 挂载数据: 无 ) 
│       │   ├── 流的创建 --> ( 难度等级: [0.4934, 0.4934) || 挂载数据: 无 ) 
│       │   ├── f?ilter、map和f?latMap方法 --> ( 难度等级: [0.4934, 0.4935) || 挂载数据: 无 ) 
│       │   ├── 抽取子流和组合流 --> ( 难度等级: [0.4935, 0.4935) || 挂载数据: 无 ) 
│       │   ├── 其他的流转换 --> ( 难度等级: [0.4935, 0.4936) || 挂载数据: 无 ) 
│       │   ├── 简单约简 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: 无 ) 
│       │   ├── Optional类型 --> ( 难度等级: [0.4936, 0.4937) || 挂载数据: 无 ) 
│       │   │   ├── 获取Optional值 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: qa: 6 ) 
│       │   │   ├── 消费Optional值 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: 无 ) 
│       │   │   ├── 管道化Optional值 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: 无 ) 
│       │   │   ├── 不适合使用Optional值的方式 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: 无 ) 
│       │   │   ├── 创建Optional值 --> ( 难度等级: [0.4936, 0.4936) || 挂载数据: 无 ) 
│       │   │   ├── 用f?latMap构建Optional值的函数 --> ( 难度等级: [0.4936, 0.4937) || 挂载数据: 无 ) 
│       │   │   └── 将Optional转换为流 --> ( 难度等级: [0.4937, 0.4937) || 挂载数据: 无 ) 
│       │   ├── 收集到映射表中 --> ( 难度等级: [0.4937, 0.4937) || 挂载数据: 无 ) 
│       │   ├── 下游收集器 --> ( 难度等级: [0.4937, 0.4938) || 挂载数据: 无 ) 
│       │   ├── 约简操作 --> ( 难度等级: [0.4938, 0.4938) || 挂载数据: 无 ) 
│       │   └── 基本类型流 --> ( 难度等级: [0.4938, 0.4939) || 挂载数据: 无 ) 
│       ├── 输入与输出 --> ( 难度等级: [0.4939, 0.4944) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流 --> ( 难度等级: [0.4939, 0.494) || 挂载数据: 无 ) 
│       │   │   ├── 读写字节 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   ├── 完整的流家族 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   ├── 组合输入/输出流过滤器 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   ├── 文本输入与输出 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: qa: 10 ) 
│       │   │   ├── 如何写出文本输出 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   ├── 如何读入文本输入 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   ├── 以文本格式存储对象 --> ( 难度等级: [0.4939, 0.4939) || 挂载数据: 无 ) 
│       │   │   └── 字符编码方式 --> ( 难度等级: [0.4939, 0.494) || 挂载数据: 无 ) 
│       │   ├── 读写二进制数据 --> ( 难度等级: [0.494, 0.494) || 挂载数据: qa: 1 ) 
│       │   │   ├── DataInput和DataOutput接口 --> ( 难度等级: [0.494, 0.494) || 挂载数据: 无 ) 
│       │   │   ├── 随机访问文件 --> ( 难度等级: [0.494, 0.494) || 挂载数据: qa: 1 ) 
│       │   │   └── ZIP文档 --> ( 难度等级: [0.494, 0.494) || 挂载数据: 无 ) 
│       │   ├── 对象输入/输出流与序列化 --> ( 难度等级: [0.494, 0.4941) || 挂载数据: 无 ) 
│       │   │   ├── 保存和加载序列化对象 --> ( 难度等级: [0.494, 0.4941) || 挂载数据: qa: 2 ) 
│       │   │   ├── 理解对象序列化的文件格式 --> ( 难度等级: [0.4941, 0.4941) || 挂载数据: 无 ) 
│       │   │   ├── 修改默认的序列化机制 --> ( 难度等级: [0.4941, 0.4941) || 挂载数据: 无 ) 
│       │   │   ├── 序列化单例和类型安全的枚举 --> ( 难度等级: [0.4941, 0.4941) || 挂载数据: 无 ) 
│       │   │   ├── 版本管理 --> ( 难度等级: [0.4941, 0.4941) || 挂载数据: qa: 1 ) 
│       │   │   └── 为克隆使用序列化 --> ( 难度等级: [0.4941, 0.4941) || 挂载数据: 无 ) 
│       │   ├── 操作文件 --> ( 难度等级: [0.4941, 0.4942) || 挂载数据: 无 ) 
│       │   │   ├── Path --> ( 难度等级: [0.4941, 0.4942) || 挂载数据: qa: 2 ) 
│       │   │   ├── 读写文件 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: qa: 10 ) 
│       │   │   ├── 复制、移动和删除文件 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: qa: 1 ) 
│       │   │   ├── 获取文件信息 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: qa: 10 ) 
│       │   │   ├── 访问目录中的项 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: 无 ) 
│       │   │   ├── 使用目录流 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: 无 ) 
│       │   │   └── ZIP文件系统 --> ( 难度等级: [0.4942, 0.4942) || 挂载数据: 无 ) 
│       │   ├── 内存映射文件 --> ( 难度等级: [0.4942, 0.4943) || 挂载数据: 无 ) 
│       │   │   ├── 内存映射文件的性能 --> ( 难度等级: [0.4942, 0.4943) || 挂载数据: 无 ) 
│       │   │   └── 缓冲区数据结构 --> ( 难度等级: [0.4943, 0.4943) || 挂载数据: 无 ) 
│       │   └── 文件加锁机制 --> ( 难度等级: [0.4943, 0.4944) || 挂载数据: 无 ) 
│       ├── XML --> ( 难度等级: [0.4944, 0.495) || 挂载数据: 无 ) 
│       │   ├── XML概述 --> ( 难度等级: [0.4944, 0.4945) || 挂载数据: 无 ) 
│       │   ├── XML文档的结构 --> ( 难度等级: [0.4945, 0.4945) || 挂载数据: 无 ) 
│       │   ├── 解析XML文档 --> ( 难度等级: [0.4945, 0.4946) || 挂载数据: 无 ) 
│       │   ├── 验证XML文档 --> ( 难度等级: [0.4946, 0.4947) || 挂载数据: 无 ) 
│       │   │   ├── 文档类型定义 --> ( 难度等级: [0.4946, 0.4946) || 挂载数据: 无 ) 
│       │   │   ├── XML Schema --> ( 难度等级: [0.4946, 0.4946) || 挂载数据: qa: 10 ) 
│       │   │   └── 一个实践示例 --> ( 难度等级: [0.4946, 0.4947) || 挂载数据: 无 ) 
│       │   ├── 使用XPath来定位信息 --> ( 难度等级: [0.4947, 0.4947) || 挂载数据: qa: 1 ) 
│       │   ├── 使用命名空间 --> ( 难度等级: [0.4947, 0.4948) || 挂载数据: qa: 1 ) 
│       │   ├── 流机制解析器 --> ( 难度等级: [0.4948, 0.4949) || 挂载数据: 无 ) 
│       │   │   ├── 使用SAX解析器 --> ( 难度等级: [0.4948, 0.4948) || 挂载数据: 无 ) 
│       │   │   └── 使用StAX解析器 --> ( 难度等级: [0.4948, 0.4949) || 挂载数据: 无 ) 
│       │   ├── 生成XML文档 --> ( 难度等级: [0.4949, 0.4949) || 挂载数据: 无 ) 
│       │   │   ├── 不带命名空间的文档 --> ( 难度等级: [0.4949, 0.4949) || 挂载数据: 无 ) 
│       │   │   ├── 带命名空间的文档 --> ( 难度等级: [0.4949, 0.4949) || 挂载数据: 无 ) 
│       │   │   ├── 写出文档 --> ( 难度等级: [0.4949, 0.4949) || 挂载数据: qa: 10 ) 
│       │   │   └── 使用StAX写出XML文档 --> ( 难度等级: [0.4949, 0.4949) || 挂载数据: qa: 2 ) 
│       │   └── XSL转换 --> ( 难度等级: [0.4949, 0.495) || 挂载数据: 无 ) 
│       ├── 网络 --> ( 难度等级: [0.495, 0.4955) || 挂载数据: 无 ) 
│       │   ├── 连接到服务器 --> ( 难度等级: [0.495, 0.4951) || 挂载数据: 无 ) 
│       │   │   ├── 使用telnet --> ( 难度等级: [0.495, 0.495) || 挂载数据: qa: 1 ) 
│       │   │   ├── 用Java连接到服务器 --> ( 难度等级: [0.495, 0.495) || 挂载数据: qa: 5 ) 
│       │   │   ├── 套接字超时 --> ( 难度等级: [0.495, 0.4951) || 挂载数据: 无 ) 
│       │   │   └── 因特网地址 --> ( 难度等级: [0.4951, 0.4951) || 挂载数据: qa: 1 ) 
│       │   ├── 实现服务器 --> ( 难度等级: [0.4951, 0.4952) || 挂载数据: 无 ) 
│       │   │   ├── 服务器套接字 --> ( 难度等级: [0.4951, 0.4951) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为多个客户端服务 --> ( 难度等级: [0.4951, 0.4951) || 挂载数据: qa: 3 ) 
│       │   │   ├── 半关闭 --> ( 难度等级: [0.4951, 0.4952) || 挂载数据: qa: 3 ) 
│       │   │   └── 可中断套接字 --> ( 难度等级: [0.4952, 0.4952) || 挂载数据: 无 ) 
│       │   ├── 获取Web数据 --> ( 难度等级: [0.4952, 0.4953) || 挂载数据: 无 ) 
│       │   │   ├── URL和URI --> ( 难度等级: [0.4952, 0.4952) || 挂载数据: qa: 2 ) 
│       │   │   ├── 使用URLConnection获取信息 --> ( 难度等级: [0.4952, 0.4953) || 挂载数据: qa: 1 ) 
│       │   │   └── 提交表单数据 --> ( 难度等级: [0.4953, 0.4953) || 挂载数据: qa: 10 ) 
│       │   ├── HTTP客户端 --> ( 难度等级: [0.4953, 0.4954) || 挂载数据: 无 ) 
│       │   └── 发送E-mail --> ( 难度等级: [0.4954, 0.4955) || 挂载数据: qa: 5 ) 
│       ├── 数据库编程 --> ( 难度等级: [0.4955, 0.4961) || 挂载数据: 无 ) 
│       │   ├── JDBC的设计 --> ( 难度等级: [0.4955, 0.4956) || 挂载数据: 无 ) 
│       │   │   ├── JDBC驱动程序类型 --> ( 难度等级: [0.4955, 0.4956) || 挂载数据: 无 ) 
│       │   │   └── JDBC的典型用法 --> ( 难度等级: [0.4956, 0.4956) || 挂载数据: 无 ) 
│       │   ├── 结构化查询语言 --> ( 难度等级: [0.4956, 0.4956) || 挂载数据: 无 ) 
│       │   ├── JDBC配置 --> ( 难度等级: [0.4956, 0.4957) || 挂载数据: 无 ) 
│       │   │   ├── 数据库URL --> ( 难度等级: [0.4956, 0.4957) || 挂载数据: 无 ) 
│       │   │   ├── 驱动程序JAR文件 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: 无 ) 
│       │   │   ├── 启动数据库 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: 无 ) 
│       │   │   ├── 注册驱动器类 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: 无 ) 
│       │   │   └── 连接到数据库 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: qa: 9 ) 
│       │   ├── 使用JDBC语句 --> ( 难度等级: [0.4957, 0.4958) || 挂载数据: 无 ) 
│       │   │   ├── 执行SQL语句 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: qa: 10 ) 
│       │   │   ├── 管理连接、语句和结果集 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: qa: 1 ) 
│       │   │   ├── 分析SQL异常 --> ( 难度等级: [0.4957, 0.4957) || 挂载数据: qa: 1 ) 
│       │   │   └── 组装数据库 --> ( 难度等级: [0.4957, 0.4958) || 挂载数据: 无 ) 
│       │   ├── 执行查询操作 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: qa: 1 ) 
│       │   │   ├── 预备语句 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: 无 ) 
│       │   │   ├── 读写LOB --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: 无 ) 
│       │   │   ├── SQL转义 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: qa: 5 ) 
│       │   │   ├── 多结果集 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: 无 ) 
│       │   │   └── 获取自动生成的键 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: qa: 5 ) 
│       │   ├── 可滚动和可更新的结果集 --> ( 难度等级: [0.4958, 0.4959) || 挂载数据: 无 ) 
│       │   │   ├── 可滚动的结果集 --> ( 难度等级: [0.4958, 0.4958) || 挂载数据: 无 ) 
│       │   │   └── 可更新的结果集 --> ( 难度等级: [0.4958, 0.4959) || 挂载数据: qa: 9 ) 
│       │   ├── 行集 --> ( 难度等级: [0.4959, 0.4959) || 挂载数据: 无 ) 
│       │   │   ├── 构建行集 --> ( 难度等级: [0.4959, 0.4959) || 挂载数据: 无 ) 
│       │   │   └── 被缓存的行集 --> ( 难度等级: [0.4959, 0.4959) || 挂载数据: 无 ) 
│       │   ├── 元数据 --> ( 难度等级: [0.4959, 0.496) || 挂载数据: qa: 3 ) 
│       │   ├── 事务 --> ( 难度等级: [0.496, 0.496) || 挂载数据: 无 ) 
│       │   │   ├── 用JDBC对事务编程 --> ( 难度等级: [0.496, 0.496) || 挂载数据: qa: 3 ) 
│       │   │   ├── 批量更新 --> ( 难度等级: [0.496, 0.496) || 挂载数据: qa: 1 ) 
│       │   │   └── 高级SQL类型 --> ( 难度等级: [0.496, 0.496) || 挂载数据: qa: 2 ) 
│       │   └── Web与企业应用中的连接管理 --> ( 难度等级: [0.496, 0.4961) || 挂载数据: 无 ) 
│       ├── 国际化 --> ( 难度等级: [0.4961, 0.4967) || 挂载数据: 无 ) 
│       │   ├── locale --> ( 难度等级: [0.4961, 0.4962) || 挂载数据: 无 ) 
│       │   │   ├── 指定locale --> ( 难度等级: [0.4961, 0.4961) || 挂载数据: 无 ) 
│       │   │   ├── 默认locale --> ( 难度等级: [0.4961, 0.4962) || 挂载数据: 无 ) 
│       │   │   └── 显示名字 --> ( 难度等级: [0.4962, 0.4962) || 挂载数据: qa: 1 ) 
│       │   ├── 数字格式 --> ( 难度等级: [0.4962, 0.4963) || 挂载数据: 无 ) 
│       │   │   ├── 格式化数字值 --> ( 难度等级: [0.4962, 0.4963) || 挂载数据: qa: 1 ) 
│       │   │   └── 货币 --> ( 难度等级: [0.4963, 0.4963) || 挂载数据: 无 ) 
│       │   ├── 排序和规范化 --> ( 难度等级: [0.4963, 0.4964) || 挂载数据: 无 ) 
│       │   ├── 消息格式化 --> ( 难度等级: [0.4964, 0.4965) || 挂载数据: 无 ) 
│       │   │   └── 选择格式 --> ( 难度等级: [0.4964, 0.4965) || 挂载数据: qa: 2 ) 
│       │   └── 资源包 --> ( 难度等级: [0.4965, 0.4967) || 挂载数据: 无 ) 
│       │       ├── 定位资源包 --> ( 难度等级: [0.4965, 0.4966) || 挂载数据: qa: 1 ) 
│       │       ├── 属性文件 --> ( 难度等级: [0.4966, 0.4966) || 挂载数据: 无 ) 
│       │       └── 包类 --> ( 难度等级: [0.4966, 0.4967) || 挂载数据: 无 ) 
│       ├── Java平台模块系统 --> ( 难度等级: [0.4967, 0.4972) || 挂载数据: 无 ) 
│       │   ├── 模块的概念 --> ( 难度等级: [0.4967, 0.4967) || 挂载数据: 无 ) 
│       │   ├── 对模块命名 --> ( 难度等级: [0.4967, 0.4967) || 挂载数据: 无 ) 
│       │   ├── 模块化的“Hello, World!”程序 --> ( 难度等级: [0.4967, 0.4968) || 挂载数据: qa: 3 ) 
│       │   ├── 对模块的需求 --> ( 难度等级: [0.4968, 0.4968) || 挂载数据: qa: 2 ) 
│       │   ├── 导出包 --> ( 难度等级: [0.4968, 0.4969) || 挂载数据: qa: 3 ) 
│       │   ├── 模块化的JAR --> ( 难度等级: [0.4969, 0.4969) || 挂载数据: qa: 1 ) 
│       │   ├── 不具名模块 --> ( 难度等级: [0.4969, 0.497) || 挂载数据: 无 ) 
│       │   ├── 用于迁移的命令行标识 --> ( 难度等级: [0.497, 0.497) || 挂载数据: 无 ) 
│       │   ├── 传递的需求和静态的需求 --> ( 难度等级: [0.497, 0.4971) || 挂载数据: 无 ) 
│       │   ├── 限定导出和开放 --> ( 难度等级: [0.4971, 0.4971) || 挂载数据: 无 ) 
│       │   ├── 服务加载 --> ( 难度等级: [0.4971, 0.4972) || 挂载数据: 无 ) 
│       │   └── 操作模块的工具 --> ( 难度等级: [0.4972, 0.4972) || 挂载数据: 无 ) 
│       ├── 安全 --> ( 难度等级: [0.4972, 0.4978) || 挂载数据: 无 ) 
│       │   ├── 类加载器 --> ( 难度等级: [0.4972, 0.4973) || 挂载数据: 无 ) 
│       │   │   ├── 类加载过程 --> ( 难度等级: [0.4972, 0.4972) || 挂载数据: qa: 10 ) 
│       │   │   ├── 类加载器的层次结构 --> ( 难度等级: [0.4972, 0.4973) || 挂载数据: qa: 1 ) 
│       │   │   ├── 将类加载器用作命名空间 --> ( 难度等级: [0.4973, 0.4973) || 挂载数据: 无 ) 
│       │   │   ├── 编写你自己的类加载器 --> ( 难度等级: [0.4973, 0.4973) || 挂载数据: 无 ) 
│       │   │   └── 字节码校验 --> ( 难度等级: [0.4973, 0.4973) || 挂载数据: qa: 1 ) 
│       │   ├── 安全管理器与访问权限 --> ( 难度等级: [0.4973, 0.4974) || 挂载数据: 无 ) 
│       │   │   ├── 权限检查 --> ( 难度等级: [0.4973, 0.4973) || 挂载数据: 无 ) 
│       │   │   ├── Java平台安全性 --> ( 难度等级: [0.4973, 0.4974) || 挂载数据: qa: 1 ) 
│       │   │   ├── 安全策略文件 --> ( 难度等级: [0.4974, 0.4974) || 挂载数据: 无 ) 
│       │   │   ├── 定制权限 --> ( 难度等级: [0.4974, 0.4974) || 挂载数据: qa: 1 ) 
│       │   │   └── 实现权限类 --> ( 难度等级: [0.4974, 0.4974) || 挂载数据: 无 ) 
│       │   ├── 用户认证 --> ( 难度等级: [0.4974, 0.4975) || 挂载数据: qa: 1 ) 
│       │   │   ├── JAAS框架 --> ( 难度等级: [0.4974, 0.4975) || 挂载数据: 无 ) 
│       │   │   └── JAAS登录模块 --> ( 难度等级: [0.4975, 0.4975) || 挂载数据: qa: 5 ) 
│       │   ├── 数字签名 --> ( 难度等级: [0.4975, 0.4977) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息摘要 --> ( 难度等级: [0.4975, 0.4976) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息签名 --> ( 难度等级: [0.4976, 0.4976) || 挂载数据: 无 ) 
│       │   │   ├── 校验签名 --> ( 难度等级: [0.4976, 0.4976) || 挂载数据: qa: 4 ) 
│       │   │   ├── 证书签名 --> ( 难度等级: [0.4976, 0.4976) || 挂载数据: qa: 1 ) 
│       │   │   ├── 证书请求 --> ( 难度等级: [0.4976, 0.4976) || 挂载数据: qa: 1 ) 
│       │   │   └── 代码签名 --> ( 难度等级: [0.4976, 0.4977) || 挂载数据: qa: 2 ) 
│       │   └── 加密 --> ( 难度等级: [0.4977, 0.4978) || 挂载数据: qa: 8 ) 
│       │       ├── 对称密码 --> ( 难度等级: [0.4977, 0.4977) || 挂载数据: 无 ) 
│       │       ├── 密钥生成 --> ( 难度等级: [0.4977, 0.4977) || 挂载数据: qa: 9 ) 
│       │       ├── 密码流 --> ( 难度等级: [0.4977, 0.4977) || 挂载数据: 无 ) 
│       │       └── 公共密钥密码 --> ( 难度等级: [0.4977, 0.4978) || 挂载数据: 无 ) 
│       ├── 高级Swing和图形化编程 --> ( 难度等级: [0.4978, 0.4983) || 挂载数据: 无 ) 
│       │   ├── 表格 --> ( 难度等级: [0.4978, 0.4979) || 挂载数据: 无 ) 
│       │   │   ├── 一个简单表格 --> ( 难度等级: [0.4978, 0.4978) || 挂载数据: qa: 10 ) 
│       │   │   ├── 表格模型 --> ( 难度等级: [0.4978, 0.4978) || 挂载数据: 无 ) 
│       │   │   ├── 对行和列的操作 --> ( 难度等级: [0.4978, 0.4979) || 挂载数据: qa: 1 ) 
│       │   │   └── 单元格的绘制和编辑 --> ( 难度等级: [0.4979, 0.4979) || 挂载数据: qa: 1 ) 
│       │   ├── 树 --> ( 难度等级: [0.4979, 0.498) || 挂载数据: 无 ) 
│       │   │   ├── 简单的树 --> ( 难度等级: [0.4979, 0.4979) || 挂载数据: qa: 2 ) 
│       │   │   ├── 节点枚举 --> ( 难度等级: [0.4979, 0.4979) || 挂载数据: 无 ) 
│       │   │   ├── 绘制节点 --> ( 难度等级: [0.4979, 0.4979) || 挂载数据: 无 ) 
│       │   │   ├── 监听树事件 --> ( 难度等级: [0.4979, 0.498) || 挂载数据: 无 ) 
│       │   │   └── 定制树模型 --> ( 难度等级: [0.498, 0.498) || 挂载数据: 无 ) 
│       │   ├── 高级AWT --> ( 难度等级: [0.498, 0.4981) || 挂载数据: 无 ) 
│       │   │   ├── 绘图操作流程 --> ( 难度等级: [0.498, 0.498) || 挂载数据: 无 ) 
│       │   │   ├── 形状 --> ( 难度等级: [0.498, 0.498) || 挂载数据: 无 ) 
│       │   │   ├── 区域 --> ( 难度等级: [0.498, 0.498) || 挂载数据: 无 ) 
│       │   │   ├── 笔画 --> ( 难度等级: [0.498, 0.498) || 挂载数据: 无 ) 
│       │   │   ├── 着色 --> ( 难度等级: [0.498, 0.4981) || 挂载数据: 无 ) 
│       │   │   ├── 坐标变换 --> ( 难度等级: [0.4981, 0.4981) || 挂载数据: qa: 1 ) 
│       │   │   ├── 剪切 --> ( 难度等级: [0.4981, 0.4981) || 挂载数据: 无 ) 
│       │   │   └── 透明与组合 --> ( 难度等级: [0.4981, 0.4981) || 挂载数据: qa: 2 ) 
│       │   ├── 像素图 --> ( 难度等级: [0.4981, 0.4982) || 挂载数据: 无 ) 
│       │   │   ├── 图像的读取器和写入器 --> ( 难度等级: [0.4981, 0.4982) || 挂载数据: 无 ) 
│       │   │   └── 图像处理 --> ( 难度等级: [0.4982, 0.4982) || 挂载数据: 无 ) 
│       │   └── 打印 --> ( 难度等级: [0.4982, 0.4983) || 挂载数据: qa: 1 ) 
│       │       ├── 图形打印 --> ( 难度等级: [0.4982, 0.4982) || 挂载数据: qa: 10 ) 
│       │       ├── 打印多页文件 --> ( 难度等级: [0.4982, 0.4983) || 挂载数据: qa: 1 ) 
│       │       ├── 打印服务程序 --> ( 难度等级: [0.4983, 0.4983) || 挂载数据: 无 ) 
│       │       ├── 流打印服务程序 --> ( 难度等级: [0.4983, 0.4983) || 挂载数据: 无 ) 
│       │       └── 打印属性 --> ( 难度等级: [0.4983, 0.4983) || 挂载数据: qa: 1 ) 
│       ├── Maven基础 --> ( 难度等级: [0.4983, 0.4989) || 挂载数据: 无 ) 
│       │   ├── Maven介绍 --> ( 难度等级: [0.4983, 0.4984) || 挂载数据: 无 ) 
│       │   ├── 依赖管理 --> ( 难度等级: [0.4984, 0.4985) || 挂载数据: 无 ) 
│       │   ├── 构建流程 --> ( 难度等级: [0.4985, 0.4986) || 挂载数据: 无 ) 
│       │   ├── 使用插件 --> ( 难度等级: [0.4986, 0.4986) || 挂载数据: 无 ) 
│       │   ├── 模块管理 --> ( 难度等级: [0.4986, 0.4987) || 挂载数据: 无 ) 
│       │   ├── 使用mvnw --> ( 难度等级: [0.4987, 0.4988) || 挂载数据: 无 ) 
│       │   └── 发布Artifact --> ( 难度等级: [0.4988, 0.4989) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.4989, 0.4994) || 挂载数据: 无 ) 
│       │   ├── 网络编程基础 --> ( 难度等级: [0.4989, 0.499) || 挂载数据: 无 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.499, 0.499) || 挂载数据: 无 ) 
│       │   ├── UDP编程 --> ( 难度等级: [0.499, 0.4991) || 挂载数据: 无 ) 
│       │   ├── 发送Email --> ( 难度等级: [0.4991, 0.4992) || 挂载数据: qa: 2 ) 
│       │   ├── 接收Email --> ( 难度等级: [0.4992, 0.4993) || 挂载数据: 无 ) 
│       │   ├── HTTP编程 --> ( 难度等级: [0.4993, 0.4994) || 挂载数据: qa: 2 ) 
│       │   └── RMI远程调用 --> ( 难度等级: [0.4994, 0.4994) || 挂载数据: qa: 4 ) 
│       └── JDBC编程 --> ( 难度等级: [0.4994, 0.5) || 挂载数据: 无 ) 
│           ├── JDBC简介 --> ( 难度等级: [0.4994, 0.4995) || 挂载数据: 无 ) 
│           ├── JDBC查询 --> ( 难度等级: [0.4995, 0.4996) || 挂载数据: 无 ) 
│           ├── JDBC更新 --> ( 难度等级: [0.4996, 0.4997) || 挂载数据: 无 ) 
│           ├── JDBC事务 --> ( 难度等级: [0.4997, 0.4998) || 挂载数据: 无 ) 
│           ├── JDBC Batch --> ( 难度等级: [0.4998, 0.4999) || 挂载数据: 无 ) 
│           └── JDBC连接池 --> ( 难度等级: [0.4999, 0.5) || 挂载数据: qa: 3 ) 
├── java高阶 --> ( 难度等级: [0.5, 0.75) || 挂载数据: 无 ) 
│   ├── Swing简介 --> ( 难度等级: [0.5, 0.5278) || 挂载数据: 无 ) 
│   │   ├── Swing的起源 --> ( 难度等级: [0.5, 0.5028) || 挂载数据: 无 ) 
│   │   ├── Swing以AWT为基础 --> ( 难度等级: [0.5028, 0.5056) || 挂载数据: 无 ) 
│   │   ├── 两个关键的Swing特性 --> ( 难度等级: [0.5056, 0.5083) || 挂载数据: 无 ) 
│   │   │   ├── Swing组件是轻量级的 --> ( 难度等级: [0.5056, 0.5069) || 挂载数据: 无 ) 
│   │   │   └── Swing支持可插入外观 --> ( 难度等级: [0.5069, 0.5083) || 挂载数据: 无 ) 
│   │   ├── MVC连接 --> ( 难度等级: [0.5083, 0.5111) || 挂载数据: 无 ) 
│   │   ├── 组件与容器 --> ( 难度等级: [0.5111, 0.5139) || 挂载数据: 无 ) 
│   │   │   ├── 组件 --> ( 难度等级: [0.5111, 0.512) || 挂载数据: 无 ) 
│   │   │   ├── 容器 --> ( 难度等级: [0.512, 0.513) || 挂载数据: qa: 4 ) 
│   │   │   └── 顶级容器窗格 --> ( 难度等级: [0.513, 0.5139) || 挂载数据: 无 ) 
│   │   ├── Swing包 --> ( 难度等级: [0.5139, 0.5167) || 挂载数据: 无 ) 
│   │   ├── 一个简单的Swing应用程序 --> ( 难度等级: [0.5167, 0.5194) || 挂载数据: 无 ) 
│   │   ├── 事件处理 --> ( 难度等级: [0.5194, 0.5222) || 挂载数据: 无 ) 
│   │   ├── 创建Swing applet --> ( 难度等级: [0.5222, 0.525) || 挂载数据: 无 ) 
│   │   └── 在Swing中绘图 --> ( 难度等级: [0.525, 0.5278) || 挂载数据: 无 ) 
│   │       ├── 绘图的基础知识 --> ( 难度等级: [0.525, 0.5259) || 挂载数据: 无 ) 
│   │       ├── 计算可绘制区域 --> ( 难度等级: [0.5259, 0.5269) || 挂载数据: 无 ) 
│   │       └── 一个绘图示例 --> ( 难度等级: [0.5269, 0.5278) || 挂载数据: 无 ) 
│   ├── 探究Swing --> ( 难度等级: [0.5278, 0.5556) || 挂载数据: 无 ) 
│   │   ├── JLabel与ImageIcon --> ( 难度等级: [0.5278, 0.5309) || 挂载数据: qa: 2 ) 
│   │   ├── JTextField --> ( 难度等级: [0.5309, 0.534) || 挂载数据: 无 ) 
│   │   ├── Swing按钮 --> ( 难度等级: [0.534, 0.537) || 挂载数据: 无 ) 
│   │   │   ├── JButton --> ( 难度等级: [0.534, 0.5347) || 挂载数据: qa: 3 ) 
│   │   │   ├── JToggleButton --> ( 难度等级: [0.5347, 0.5355) || 挂载数据: 无 ) 
│   │   │   ├── 复选框 --> ( 难度等级: [0.5355, 0.5363) || 挂载数据: 无 ) 
│   │   │   └── 单选按钮 --> ( 难度等级: [0.5363, 0.537) || 挂载数据: qa: 10 ) 
│   │   ├── JTabbedPane --> ( 难度等级: [0.537, 0.5401) || 挂载数据: 无 ) 
│   │   ├── JScrollPane --> ( 难度等级: [0.5401, 0.5432) || 挂载数据: 无 ) 
│   │   ├── JList --> ( 难度等级: [0.5432, 0.5463) || 挂载数据: 无 ) 
│   │   ├── JComboBox --> ( 难度等级: [0.5463, 0.5494) || 挂载数据: qa: 1 ) 
│   │   ├── 树 --> ( 难度等级: [0.5494, 0.5525) || 挂载数据: 无 ) 
│   │   └── JTable --> ( 难度等级: [0.5525, 0.5556) || 挂载数据: qa: 6 ) 
│   ├── Swing菜单简介 --> ( 难度等级: [0.5556, 0.5833) || 挂载数据: 无 ) 
│   │   ├── 菜单的基础知识 --> ( 难度等级: [0.5556, 0.5581) || 挂载数据: 无 ) 
│   │   ├── JMenuBar、JMenu和JMenuItem概述 --> ( 难度等级: [0.5581, 0.5606) || 挂载数据: 无 ) 
│   │   │   ├── JMenuBar --> ( 难度等级: [0.5581, 0.5589) || 挂载数据: 无 ) 
│   │   │   ├── JMenu --> ( 难度等级: [0.5589, 0.5598) || 挂载数据: 无 ) 
│   │   │   └── JMenuItem --> ( 难度等级: [0.5598, 0.5606) || 挂载数据: 无 ) 
│   │   ├── 创建主菜单 --> ( 难度等级: [0.5606, 0.5631) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加助记符和加速键 --> ( 难度等级: [0.5631, 0.5657) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加图片和工具提示 --> ( 难度等级: [0.5657, 0.5682) || 挂载数据: 无 ) 
│   │   ├── 使用JRadioButtonMenuItem和JCheckBoxMenuItem --> ( 难度等级: [0.5682, 0.5707) || 挂载数据: 无 ) 
│   │   ├── 创建弹出菜单 --> ( 难度等级: [0.5707, 0.5732) || 挂载数据: 无 ) 
│   │   ├── 创建工具栏 --> ( 难度等级: [0.5732, 0.5758) || 挂载数据: 无 ) 
│   │   ├── 使用动作 --> ( 难度等级: [0.5758, 0.5783) || 挂载数据: 无 ) 
│   │   ├── 完整演示MenuDemo程序 --> ( 难度等级: [0.5783, 0.5808) || 挂载数据: 无 ) 
│   │   └── 继续探究Swing --> ( 难度等级: [0.5808, 0.5833) || 挂载数据: 无 ) 
│   ├── JavaFX GUI编程简介 --> ( 难度等级: [0.5833, 0.6111) || 挂载数据: 无 ) 
│   │   ├── JavaFX的基础概念 --> ( 难度等级: [0.5833, 0.5873) || 挂载数据: 无 ) 
│   │   │   ├── JavaFX包 --> ( 难度等级: [0.5833, 0.584) || 挂载数据: qa: 10 ) 
│   │   │   ├── Stage和Scene类 --> ( 难度等级: [0.584, 0.5847) || 挂载数据: 无 ) 
│   │   │   ├── 节点和场景图 --> ( 难度等级: [0.5847, 0.5853) || 挂载数据: 无 ) 
│   │   │   ├── 布局 --> ( 难度等级: [0.5853, 0.586) || 挂载数据: 无 ) 
│   │   │   ├── Application类和生命周期方法 --> ( 难度等级: [0.586, 0.5866) || 挂载数据: 无 ) 
│   │   │   └── 启动JavaFX应用程序 --> ( 难度等级: [0.5866, 0.5873) || 挂载数据: 无 ) 
│   │   ├── JavaFX应用程序的骨架 --> ( 难度等级: [0.5873, 0.5913) || 挂载数据: 无 ) 
│   │   ├── 编译和运行JavaFX程序 --> ( 难度等级: [0.5913, 0.5952) || 挂载数据: qa: 1 ) 
│   │   ├── 应用程序线程 --> ( 难度等级: [0.5952, 0.5992) || 挂载数据: 无 ) 
│   │   ├── 一个简单的JavaFX控件：Label --> ( 难度等级: [0.5992, 0.6032) || 挂载数据: 无 ) 
│   │   ├── 使用按钮和事件 --> ( 难度等级: [0.6032, 0.6071) || 挂载数据: 无 ) 
│   │   │   ├── 事件的基础知识 --> ( 难度等级: [0.6032, 0.6045) || 挂载数据: qa: 2 ) 
│   │   │   ├── 按钮控件简介 --> ( 难度等级: [0.6045, 0.6058) || 挂载数据: qa: 1 ) 
│   │   │   └── 演示事件处理和按钮 --> ( 难度等级: [0.6058, 0.6071) || 挂载数据: 无 ) 
│   │   └── 直接在画布上绘制 --> ( 难度等级: [0.6071, 0.6111) || 挂载数据: 无 ) 
│   ├── 探究JavaFX控件 --> ( 难度等级: [0.6111, 0.6389) || 挂载数据: 无 ) 
│   │   ├── 使用Image和ImageView --> ( 难度等级: [0.6111, 0.6134) || 挂载数据: qa: 2 ) 
│   │   │   ├── 向标签添加图片 --> ( 难度等级: [0.6111, 0.6123) || 挂载数据: qa: 2 ) 
│   │   │   └── 在按钮中使用图片 --> ( 难度等级: [0.6123, 0.6134) || 挂载数据: qa: 10 ) 
│   │   ├── ToggleButton --> ( 难度等级: [0.6134, 0.6157) || 挂载数据: 无 ) 
│   │   ├── RadioButton --> ( 难度等级: [0.6157, 0.6181) || 挂载数据: 无 ) 
│   │   │   ├── 处理开关组中的变化事件 --> ( 难度等级: [0.6157, 0.6169) || 挂载数据: 无 ) 
│   │   │   └── 处理单选按钮的另一种方式 --> ( 难度等级: [0.6169, 0.6181) || 挂载数据: 无 ) 
│   │   ├── CheckBox --> ( 难度等级: [0.6181, 0.6204) || 挂载数据: qa: 2 ) 
│   │   ├── ListView --> ( 难度等级: [0.6204, 0.6227) || 挂载数据: 无 ) 
│   │   │   ├── ListView的滚动条 --> ( 难度等级: [0.6204, 0.6215) || 挂载数据: qa: 5 ) 
│   │   │   └── 启用多项选择 --> ( 难度等级: [0.6215, 0.6227) || 挂载数据: 无 ) 
│   │   ├── ComboBox --> ( 难度等级: [0.6227, 0.625) || 挂载数据: qa: 2 ) 
│   │   ├── TextField --> ( 难度等级: [0.625, 0.6273) || 挂载数据: 无 ) 
│   │   ├── ScrollPane --> ( 难度等级: [0.6273, 0.6296) || 挂载数据: 无 ) 
│   │   ├── TreeView --> ( 难度等级: [0.6296, 0.6319) || 挂载数据: 无 ) 
│   │   ├── 效果和变换简介 --> ( 难度等级: [0.6319, 0.6343) || 挂载数据: 无 ) 
│   │   │   ├── 效果 --> ( 难度等级: [0.6319, 0.6327) || 挂载数据: qa: 2 ) 
│   │   │   ├── 变换 --> ( 难度等级: [0.6327, 0.6335) || 挂载数据: 无 ) 
│   │   │   └── 演示效果和变换 --> ( 难度等级: [0.6335, 0.6343) || 挂载数据: 无 ) 
│   │   ├── 添加工具提示 --> ( 难度等级: [0.6343, 0.6366) || 挂载数据: 无 ) 
│   │   └── 禁用控件 --> ( 难度等级: [0.6366, 0.6389) || 挂载数据: 无 ) 
│   ├── JavaFX菜单简介 --> ( 难度等级: [0.6389, 0.6667) || 挂载数据: 无 ) 
│   │   ├── 菜单的基础知识 --> ( 难度等级: [0.6389, 0.6417) || 挂载数据: 无 ) 
│   │   ├── MenuBar、Menu和MenuItem概述 --> ( 难度等级: [0.6417, 0.6444) || 挂载数据: 无 ) 
│   │   │   ├── MenuBar --> ( 难度等级: [0.6417, 0.6426) || 挂载数据: 无 ) 
│   │   │   ├── Menu --> ( 难度等级: [0.6426, 0.6435) || 挂载数据: qa: 2 ) 
│   │   │   └── MenuItem --> ( 难度等级: [0.6435, 0.6444) || 挂载数据: 无 ) 
│   │   ├── 创建主菜单 --> ( 难度等级: [0.6444, 0.6472) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加助记符和加速键 --> ( 难度等级: [0.6472, 0.65) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加图片 --> ( 难度等级: [0.65, 0.6528) || 挂载数据: 无 ) 
│   │   ├── 使用RadioMenuItem和CheckMenuItem --> ( 难度等级: [0.6528, 0.6556) || 挂载数据: 无 ) 
│   │   ├── 创建上下文菜单 --> ( 难度等级: [0.6556, 0.6583) || 挂载数据: 无 ) 
│   │   ├── 创建工具栏 --> ( 难度等级: [0.6583, 0.6611) || 挂载数据: 无 ) 
│   │   ├── 完整的MenuDemo程序 --> ( 难度等级: [0.6611, 0.6639) || 挂载数据: 无 ) 
│   │   └── 继续探究JavaFX --> ( 难度等级: [0.6639, 0.6667) || 挂载数据: 无 ) 
│   ├── Java Bean --> ( 难度等级: [0.6667, 0.6944) || 挂载数据: 无 ) 
│   │   ├── Java Bean是什么 --> ( 难度等级: [0.6667, 0.6701) || 挂载数据: 无 ) 
│   │   ├── Java Bean的优势 --> ( 难度等级: [0.6701, 0.6736) || 挂载数据: 无 ) 
│   │   ├── 内省 --> ( 难度等级: [0.6736, 0.6771) || 挂载数据: 无 ) 
│   │   │   ├── 属性的设计模式 --> ( 难度等级: [0.6736, 0.6745) || 挂载数据: 无 ) 
│   │   │   ├── 事件的设计模式 --> ( 难度等级: [0.6745, 0.6753) || 挂载数据: qa: 5 ) 
│   │   │   ├── 方法与设计模式 --> ( 难度等级: [0.6753, 0.6762) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建型模式 --> ( 难度等级: [0.6753, 0.6756) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工厂方法 --> ( 难度等级: [0.6753, 0.6754) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 抽象工厂 --> ( 难度等级: [0.6754, 0.6755) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 生成器 --> ( 难度等级: [0.6755, 0.6755) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 原型 --> ( 难度等级: [0.6755, 0.6756) || 挂载数据: 无 ) 
│   │   │   │   │   └── 单例 --> ( 难度等级: [0.6756, 0.6756) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 结构型模式 --> ( 难度等级: [0.6756, 0.6759) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 适配器 --> ( 难度等级: [0.6756, 0.6757) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 桥接 --> ( 难度等级: [0.6757, 0.6757) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 组合 --> ( 难度等级: [0.6757, 0.6758) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 装饰器 --> ( 难度等级: [0.6758, 0.6758) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 外观 --> ( 难度等级: [0.6758, 0.6758) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 享元 --> ( 难度等级: [0.6758, 0.6759) || 挂载数据: 无 ) 
│   │   │   │   │   └── 代理 --> ( 难度等级: [0.6759, 0.6759) || 挂载数据: 无 ) 
│   │   │   │   └── 行为型模式 --> ( 难度等级: [0.6759, 0.6762) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 责任链 --> ( 难度等级: [0.6759, 0.676) || 挂载数据: 无 ) 
│   │   │   │       ├── 命令 --> ( 难度等级: [0.676, 0.676) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 解释器 --> ( 难度等级: [0.676, 0.676) || 挂载数据: 无 ) 
│   │   │   │       ├── 迭代器 --> ( 难度等级: [0.676, 0.676) || 挂载数据: 无 ) 
│   │   │   │       ├── 中介 --> ( 难度等级: [0.676, 0.6761) || 挂载数据: 无 ) 
│   │   │   │       ├── 备忘录 --> ( 难度等级: [0.6761, 0.6761) || 挂载数据: 无 ) 
│   │   │   │       ├── 观察者 --> ( 难度等级: [0.6761, 0.6761) || 挂载数据: 无 ) 
│   │   │   │       ├── 状态 --> ( 难度等级: [0.6761, 0.6761) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 策略 --> ( 难度等级: [0.6761, 0.6762) || 挂载数据: 无 ) 
│   │   │   │       ├── 模板方法 --> ( 难度等级: [0.6762, 0.6762) || 挂载数据: qa: 1 ) 
│   │   │   │       └── 访问者 --> ( 难度等级: [0.6762, 0.6762) || 挂载数据: 无 ) 
│   │   │   └── 使用BeanInfo接口 --> ( 难度等级: [0.6762, 0.6771) || 挂载数据: qa: 1 ) 
│   │   ├── 绑定属性与约束属性 --> ( 难度等级: [0.6771, 0.6806) || 挂载数据: 无 ) 
│   │   ├── 持久性 --> ( 难度等级: [0.6806, 0.684) || 挂载数据: 无 ) 
│   │   ├── 定制器 --> ( 难度等级: [0.684, 0.6875) || 挂载数据: 无 ) 
│   │   ├── Java Bean API --> ( 难度等级: [0.6875, 0.691) || 挂载数据: 无 ) 
│   │   │   ├── Introspector类 --> ( 难度等级: [0.6875, 0.6884) || 挂载数据: 无 ) 
│   │   │   ├── PropertyDescriptor类 --> ( 难度等级: [0.6884, 0.6892) || 挂载数据: 无 ) 
│   │   │   ├── EventSetDescriptor类 --> ( 难度等级: [0.6892, 0.6901) || 挂载数据: 无 ) 
│   │   │   └── MethodDescriptor类 --> ( 难度等级: [0.6901, 0.691) || 挂载数据: 无 ) 
│   │   └── 一个Bean示例 --> ( 难度等级: [0.691, 0.6944) || 挂载数据: 无 ) 
│   ├── servlet --> ( 难度等级: [0.6944, 0.7222) || 挂载数据: qa: 1 ) 
│   │   ├── 背景 --> ( 难度等级: [0.6944, 0.6968) || 挂载数据: qa: 1 ) 
│   │   ├── servelet的生命周期 --> ( 难度等级: [0.6968, 0.6991) || 挂载数据: qa: 1 ) 
│   │   ├── servlet开发选项 --> ( 难度等级: [0.6991, 0.7014) || 挂载数据: 无 ) 
│   │   ├── 使用Tomcat --> ( 难度等级: [0.7014, 0.7037) || 挂载数据: qa: 1 ) 
│   │   ├── 一个简单的servlet --> ( 难度等级: [0.7037, 0.706) || 挂载数据: 无 ) 
│   │   │   ├── 创建和编译servlet源代码 --> ( 难度等级: [0.7037, 0.7045) || 挂载数据: qa: 10 ) 
│   │   │   ├── 启动Tomcat --> ( 难度等级: [0.7045, 0.7052) || 挂载数据: qa: 10 ) 
│   │   │   └── 启动Web浏览器并请求servlet --> ( 难度等级: [0.7052, 0.706) || 挂载数据: qa: 8 ) 
│   │   ├── Servlet API --> ( 难度等级: [0.706, 0.7083) || 挂载数据: 无 ) 
│   │   ├── javax.servlet包 --> ( 难度等级: [0.7083, 0.7106) || 挂载数据: qa: 1 ) 
│   │   │   ├── Servlet接口 --> ( 难度等级: [0.7083, 0.7086) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletConfig接口 --> ( 难度等级: [0.7086, 0.7088) || 挂载数据: 无 ) 
│   │   │   ├── ServletContext接口 --> ( 难度等级: [0.7088, 0.7091) || 挂载数据: qa: 2 ) 
│   │   │   ├── ServletRequest接口 --> ( 难度等级: [0.7091, 0.7094) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletResponse接口 --> ( 难度等级: [0.7094, 0.7096) || 挂载数据: qa: 1 ) 
│   │   │   ├── GenericServlet类 --> ( 难度等级: [0.7096, 0.7099) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletInputStream类 --> ( 难度等级: [0.7099, 0.7101) || 挂载数据: 无 ) 
│   │   │   ├── ServletOutputStream类 --> ( 难度等级: [0.7101, 0.7104) || 挂载数据: 无 ) 
│   │   │   └── servlet异常类 --> ( 难度等级: [0.7104, 0.7106) || 挂载数据: qa: 4 ) 
│   │   ├── 读取servlet参数 --> ( 难度等级: [0.7106, 0.713) || 挂载数据: 无 ) 
│   │   ├── javax.servlet.http包 --> ( 难度等级: [0.713, 0.7153) || 挂载数据: 无 ) 
│   │   │   ├── HttpServletRequest接口 --> ( 难度等级: [0.713, 0.7134) || 挂载数据: qa: 1 ) 
│   │   │   ├── HttpServletResponse接口 --> ( 难度等级: [0.7134, 0.7139) || 挂载数据: 无 ) 
│   │   │   ├── HttpSession接口 --> ( 难度等级: [0.7139, 0.7144) || 挂载数据: 无 ) 
│   │   │   ├── Cookie类 --> ( 难度等级: [0.7144, 0.7148) || 挂载数据: qa: 6 ) 
│   │   │   └── HttpServlet类 --> ( 难度等级: [0.7148, 0.7153) || 挂载数据: qa: 2 ) 
│   │   ├── 处理HTTP请求和响应 --> ( 难度等级: [0.7153, 0.7176) || 挂载数据: 无 ) 
│   │   │   ├── 处理HTTP GET请求 --> ( 难度等级: [0.7153, 0.7164) || 挂载数据: qa: 10 ) 
│   │   │   └── 处理HTTP POST请求 --> ( 难度等级: [0.7164, 0.7176) || 挂载数据: qa: 10 ) 
│   │   ├── 使用cookie --> ( 难度等级: [0.7176, 0.7199) || 挂载数据: 无 ) 
│   │   └── 会话跟踪 --> ( 难度等级: [0.7199, 0.7222) || 挂载数据: qa: 3 ) 
│   └── 其他 --> ( 难度等级: [0.7222, 0.75) || 挂载数据: 无 ) 
│       ├── 入门和技术基础 --> ( 难度等级: [0.7222, 0.7233) || 挂载数据: 无 ) 
│       │   ├── 认识SSM框架和Redis --> ( 难度等级: [0.7222, 0.7228) || 挂载数据: 无 ) 
│       │   │   ├── Spring框架 --> ( 难度等级: [0.7222, 0.7223) || 挂载数据: 无 ) 
│       │   │   │   ├── Spring IoC简介 --> ( 难度等级: [0.7222, 0.7222) || 挂载数据: 无 ) 
│       │   │   │   └── Spring AOP --> ( 难度等级: [0.7222, 0.7223) || 挂载数据: qa: 1 ) 
│       │   │   ├── MyBatis简介 --> ( 难度等级: [0.7223, 0.7223) || 挂载数据: 无 ) 
│       │   │   │   ├── Hibernate简介 --> ( 难度等级: [0.7223, 0.7223) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── MyBatis --> ( 难度等级: [0.7223, 0.7223) || 挂载数据: qa: 1 ) 
│       │   │   │   └── Hibernate和MyBatis的区别 --> ( 难度等级: [0.7223, 0.7223) || 挂载数据: qa: 6 ) 
│       │   │   ├── Spring MVC简介 --> ( 难度等级: [0.7223, 0.7224) || 挂载数据: 无 ) 
│       │   │   ├── 最流行的NoSQL——Redis --> ( 难度等级: [0.7224, 0.7224) || 挂载数据: 无 ) 
│       │   │   ├── SSM+Redis结构框图及概述 --> ( 难度等级: [0.7224, 0.7224) || 挂载数据: qa: 10 ) 
│       │   │   ├── Redis概述 --> ( 难度等级: [0.7224, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis在Java Web中的应用 --> ( 难度等级: [0.7224, 0.7224) || 挂载数据: 无 ) 
│       │   │   │   │   └── 高速读/写场合 --> ( 难度等级: [0.7224, 0.7224) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis基本安装和使用 --> ( 难度等级: [0.7224, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 在Windows下安装Redis --> ( 难度等级: [0.7224, 0.7225) || 挂载数据: qa: 3 ) 
│       │   │   │   │   └── 在Linux下安装Redis --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── Redis的Java API --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 在Java程序中使用Redis --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   └── 在Spring中使用Redis --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 简介Redis的6种数据类型 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   ├── Redis数据结构常用命令 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——字符串 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——哈希 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── Redis数据结构——链表（linked-list） --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── Redis数据结构——集合 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——有序集合 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   ├── Redis基础命令 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   ├── spring-data-redis对有序集合的封装 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   │   └── 使用Spring操作有序集合 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 基数——HyperLogLog --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   ├── Redis的一些常用技术 --> ( 难度等级: [0.7225, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis的基础事务 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── 探索Redis事务回滚 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 使用watch命令监控事务 --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── 流水线（pipelined） --> ( 难度等级: [0.7225, 0.7225) || 挂载数据: 无 ) 
│       │   │   │   ├── 发布订阅 --> ( 难度等级: [0.7225, 0.7226) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 超时命令 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   └── 使用Lua语言 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │       ├── 执行输入Lua程序代码 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │       └── 执行Lua文件 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: qa: 3 ) 
│       │   │   ├── Redis配置 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis基础配置文件 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis备份（持久化） --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis内存回收策略 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── 复制 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: qa: 2 ) 
│       │   │   │   │   ├── 主从同步基础概念 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   │   ├── Redis主从同步配置 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   │   └── Redis主从同步的过程 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   └── 哨兵（Sentinel）模式 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │       ├── 哨兵模式概述 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: qa: 1 ) 
│       │   │   │       ├── 搭建哨兵模式 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │       ├── 在Java中使用哨兵模式 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │       └── 哨兵模式的其他配置项 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   ├── 使用redis-cli --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── 安全设置 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 基本操作 --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── keys --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis List --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis Hash --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── Set --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   │   └── Pub/Sub --> ( 难度等级: [0.7226, 0.7226) || 挂载数据: 无 ) 
│       │   │   ├── Spring Boot集成Redis --> ( 难度等级: [0.7226, 0.7227) || 挂载数据: 无 ) 
│       │   │   ├── 使用StringRedisTemplate --> ( 难度等级: [0.7227, 0.7227) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── opsFor --> ( 难度等级: [0.7227, 0.7227) || 挂载数据: 无 ) 
│       │   │   │   ├── 绑定Key的操作 --> ( 难度等级: [0.7227, 0.7227) || 挂载数据: 无 ) 
│       │   │   │   └── RedisConnection --> ( 难度等级: [0.7227, 0.7227) || 挂载数据: 无 ) 
│       │   │   └── 序列化策略 --> ( 难度等级: [0.7227, 0.7228) || 挂载数据: 无 ) 
│       │   │       ├── 默认序列化策略 --> ( 难度等级: [0.7227, 0.7228) || 挂载数据: 无 ) 
│       │   │       └── 自定义序列化策略 --> ( 难度等级: [0.7228, 0.7228) || 挂载数据: 无 ) 
│       │   └── Java设计模式 --> ( 难度等级: [0.7228, 0.7233) || 挂载数据: 无 ) 
│       │       ├── Java反射技术 --> ( 难度等级: [0.7228, 0.7229) || 挂载数据: 无 ) 
│       │       │   ├── 通过反射构建对象 --> ( 难度等级: [0.7228, 0.7228) || 挂载数据: 无 ) 
│       │       │   └── 反射方法 --> ( 难度等级: [0.7228, 0.7229) || 挂载数据: qa: 9 ) 
│       │       ├── 动态代理模式和责任链模式 --> ( 难度等级: [0.7229, 0.723) || 挂载数据: 无 ) 
│       │       │   ├── JDK动态代理 --> ( 难度等级: [0.7229, 0.7229) || 挂载数据: 无 ) 
│       │       │   ├── CGLIB动态代理 --> ( 难度等级: [0.7229, 0.7229) || 挂载数据: qa: 6 ) 
│       │       │   ├── 拦截器 --> ( 难度等级: [0.7229, 0.723) || 挂载数据: 无 ) 
│       │       │   │   ├── 拦截器的定义 --> ( 难度等级: [0.7229, 0.723) || 挂载数据: qa: 4 ) 
│       │       │   │   ├── 拦截器的执行流程 --> ( 难度等级: [0.723, 0.723) || 挂载数据: 无 ) 
│       │       │   │   ├── 开发拦截器 --> ( 难度等级: [0.723, 0.723) || 挂载数据: qa: 5 ) 
│       │       │   │   └── 多个拦截器执行的顺序 --> ( 难度等级: [0.723, 0.723) || 挂载数据: qa: 5 ) 
│       │       │   └── 责任链模式 --> ( 难度等级: [0.723, 0.723) || 挂载数据: qa: 2 ) 
│       │       ├── 观察者（Observer）模式 --> ( 难度等级: [0.723, 0.7231) || 挂载数据: 无 ) 
│       │       │   └── 概述 --> ( 难度等级: [0.723, 0.7231) || 挂载数据: 无 ) 
│       │       ├── 工厂模式和抽象工厂模式 --> ( 难度等级: [0.7231, 0.7232) || 挂载数据: 无 ) 
│       │       │   ├── 普通工厂（Simple Factory）模式 --> ( 难度等级: [0.7231, 0.7232) || 挂载数据: 无 ) 
│       │       │   └── 抽象工厂（Abstract Factory）模式 --> ( 难度等级: [0.7232, 0.7232) || 挂载数据: qa: 3 ) 
│       │       └── 建造者（Builder）模式 --> ( 难度等级: [0.7232, 0.7233) || 挂载数据: qa: 1 ) 
│       │           └── 概述 --> ( 难度等级: [0.7232, 0.7233) || 挂载数据: 无 ) 
│       ├── 互联网持久框架——MyBatis --> ( 难度等级: [0.7233, 0.7244) || 挂载数据: 无 ) 
│       │   ├── 认识MyBatis核心组件 --> ( 难度等级: [0.7233, 0.7235) || 挂载数据: 无 ) 
│       │   │   ├── 准备MyBatis环境 --> ( 难度等级: [0.7233, 0.7234) || 挂载数据: qa: 10 ) 
│       │   │   ├── MyBatis的核心组件 --> ( 难度等级: [0.7234, 0.7234) || 挂载数据: 无 ) 
│       │   │   ├── SqlSessionFactory（工厂接口） --> ( 难度等级: [0.7234, 0.7234) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用XML构建SqlSessionFactory --> ( 难度等级: [0.7234, 0.7234) || 挂载数据: 无 ) 
│       │   │   │   └── 使用代码创建SqlSessionFactory --> ( 难度等级: [0.7234, 0.7234) || 挂载数据: 无 ) 
│       │   │   ├── SqlSession --> ( 难度等级: [0.7234, 0.7235) || 挂载数据: 无 ) 
│       │   │   ├── 映射器 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── 用XML实现映射器 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── 注解实现映射器 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── SqlSession发送SQL --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── 用Mapper接口发送SQL --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 对比两种发送SQL方式 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   └── 生命周期 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │       ├── SqlSessionFactoryBuilder --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │       ├── SqlSessionFactory --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │       ├── SqlSession --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │       └── Mapper --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: qa: 4 ) 
│       │   ├── MyBatis配置 --> ( 难度等级: [0.7235, 0.7237) || 挂载数据: 无 ) 
│       │   │   ├── properties属性 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── property子元素 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用properties文件 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 使用程序传递方式传递参数 --> ( 难度等级: [0.7235, 0.7235) || 挂载数据: qa: 2 ) 
│       │   │   ├── settings设置 --> ( 难度等级: [0.7235, 0.7236) || 挂载数据: 无 ) 
│       │   │   ├── typeAliases别名 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   │   ├── 系统定义别名 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   │   └── 自定义别名 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: qa: 1 ) 
│       │   │   ├── typeHandler类型转换器 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   │   ├── 系统定义的typeHandler --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义typeHandler --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 枚举typeHandler --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   │   └── 文件操作 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   ├── ObjectFactory（对象工厂） --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   ├── 插件 --> ( 难度等级: [0.7236, 0.7236) || 挂载数据: 无 ) 
│       │   │   ├── environments（运行环境） --> ( 难度等级: [0.7236, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── transactionManager（事务管理器） --> ( 难度等级: [0.7236, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   └── environment数据源环境 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: qa: 2 ) 
│       │   │   ├── databaseIdProvider数据库厂商标识 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用系统默认的databaseIdProvider --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   └── 不使用系统规则 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   └── 引入映射器的方法 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   ├── 映射器 --> ( 难度等级: [0.7237, 0.7239) || 挂载数据: 无 ) 
│       │   │   ├── select元素——查询语句 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── 简单的select元素的应用 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 自动映射和驼峰映射 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递多个参数 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用resultMap映射结果集 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   └── 分页参数RowBounds --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   ├── insert元素——插入语句 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   │   ├── 简单的insert语句的应用 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: qa: 7 ) 
│       │   │   │   ├── 主键回填 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 自定义主键 --> ( 难度等级: [0.7237, 0.7237) || 挂载数据: 无 ) 
│       │   │   ├── update元素和delete元素 --> ( 难度等级: [0.7237, 0.7238) || 挂载数据: qa: 1 ) 
│       │   │   ├── sql元素 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   ├── 参数 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── 存储过程参数支持 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 特殊字符串的替换和处理（#和$） --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: qa: 1 ) 
│       │   │   ├── resultMap元素 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── resultMap元素的构成 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── 使用map存储结果集 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   └── 使用POJO存储结果集 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   ├── 级联 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── MyBatis中的级联 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── 建立POJO --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 配置映射文件 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── 延迟加载 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   │   ├── 另一种级联 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 多对多级联 --> ( 难度等级: [0.7238, 0.7238) || 挂载数据: 无 ) 
│       │   │   ├── 缓存 --> ( 难度等级: [0.7238, 0.7239) || 挂载数据: 无 ) 
│       │   │   │   ├── 一级缓存和二级缓存 --> ( 难度等级: [0.7238, 0.7239) || 挂载数据: qa: 4 ) 
│       │   │   │   └── 缓存配置项、自定义和引用 --> ( 难度等级: [0.7239, 0.7239) || 挂载数据: 无 ) 
│       │   │   └── 存储过程 --> ( 难度等级: [0.7239, 0.7239) || 挂载数据: 无 ) 
│       │   │       ├── IN和OUT参数存储过程 --> ( 难度等级: [0.7239, 0.7239) || 挂载数据: qa: 10 ) 
│       │   │       └── 游标的使用 --> ( 难度等级: [0.7239, 0.7239) || 挂载数据: 无 ) 
│       │   ├── 动态SQL --> ( 难度等级: [0.7239, 0.7241) || 挂载数据: qa: 1 ) 
│       │   │   ├── if元素 --> ( 难度等级: [0.7239, 0.7239) || 挂载数据: qa: 1 ) 
│       │   │   ├── choose、when、otherwise元素 --> ( 难度等级: [0.7239, 0.724) || 挂载数据: 无 ) 
│       │   │   ├── trim、where、set元素 --> ( 难度等级: [0.724, 0.724) || 挂载数据: qa: 4 ) 
│       │   │   ├── foreach元素 --> ( 难度等级: [0.724, 0.724) || 挂载数据: 无 ) 
│       │   │   ├── 用test的属性判断字符串 --> ( 难度等级: [0.724, 0.724) || 挂载数据: qa: 3 ) 
│       │   │   └── bind元素 --> ( 难度等级: [0.724, 0.7241) || 挂载数据: 无 ) 
│       │   ├── MyBatis的解析和运行原理 --> ( 难度等级: [0.7241, 0.7243) || 挂载数据: 无 ) 
│       │   │   ├── 构建SqlSessionFactory过程 --> ( 难度等级: [0.7241, 0.7242) || 挂载数据: 无 ) 
│       │   │   │   ├── 构建Configuration --> ( 难度等级: [0.7241, 0.7241) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 构建映射器的内部组成 --> ( 难度等级: [0.7241, 0.7241) || 挂载数据: 无 ) 
│       │   │   │   └── 构建SqlSessionFactory --> ( 难度等级: [0.7241, 0.7242) || 挂载数据: qa: 1 ) 
│       │   │   └── SqlSession运行过程 --> ( 难度等级: [0.7242, 0.7243) || 挂载数据: qa: 10 ) 
│       │   │       ├── 映射器（Mapper）的动态代理 --> ( 难度等级: [0.7242, 0.7242) || 挂载数据: 无 ) 
│       │   │       └── SqlSession下的四大对象 --> ( 难度等级: [0.7242, 0.7243) || 挂载数据: 无 ) 
│       │   └── 插件 --> ( 难度等级: [0.7243, 0.7244) || 挂载数据: 无 ) 
│       │       ├── 插件接口 --> ( 难度等级: [0.7243, 0.7243) || 挂载数据: 无 ) 
│       │       ├── 插件的初始化 --> ( 难度等级: [0.7243, 0.7244) || 挂载数据: qa: 8 ) 
│       │       ├── 插件的代理和反射设计 --> ( 难度等级: [0.7244, 0.7244) || 挂载数据: 无 ) 
│       │       └── 常用的工具类——MetaObject --> ( 难度等级: [0.7244, 0.7244) || 挂载数据: 无 ) 
│       ├── Spring基础 --> ( 难度等级: [0.7244, 0.7256) || 挂载数据: 无 ) 
│       │   ├── Spring IoC的概念 --> ( 难度等级: [0.7244, 0.7246) || 挂载数据: 无 ) 
│       │   │   ├── Spring的概述 --> ( 难度等级: [0.7244, 0.7245) || 挂载数据: 无 ) 
│       │   │   │   └── Spring的简史 --> ( 难度等级: [0.7244, 0.7245) || 挂载数据: qa: 10 ) 
│       │   │   ├── Spring IoC概述 --> ( 难度等级: [0.7245, 0.7246) || 挂载数据: 无 ) 
│       │   │   │   ├── 主动创建对象 --> ( 难度等级: [0.7245, 0.7245) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 被动创建对象 --> ( 难度等级: [0.7245, 0.7245) || 挂载数据: 无 ) 
│       │   │   │   └── Spring IoC阐述 --> ( 难度等级: [0.7245, 0.7246) || 挂载数据: 无 ) 
│       │   │   └── Spring IoC容器 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   │       ├── Spring IoC容器的设计 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   │       ├── Spring IoC容器的初始化和依赖注入 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   │       └── Spring Bean的生命周期 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   ├── 装配Spring Bean --> ( 难度等级: [0.7246, 0.7248) || 挂载数据: 无 ) 
│       │   │   ├── 依赖注入的3种方式 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   │   │   ├── 构造器注入 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用setter注入 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 接口注入 --> ( 难度等级: [0.7246, 0.7246) || 挂载数据: qa: 1 ) 
│       │   │   ├── 装配Bean概述 --> ( 难度等级: [0.7246, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 通过XML配置装配Bean --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 装配简易值 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 装配集合 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   └── 命名空间装配 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 通过注解装配Bean --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用@Component装配Bean --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 自动装配——@Autowired --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 自动装配的歧义性（@Primary和@Qualifier） --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 装载带有参数的构造方法类 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 使用@Bean装配Bean --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 注解自定义Bean的初始化和销毁方法 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 装配的混合使用 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 使用Profile --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用注解@Profile配置 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用XML定义Profile --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 启动Profile --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   ├── 点睛 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   │   └── 演示 --> ( 难度等级: [0.7247, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 加载属性（properties）文件 --> ( 难度等级: [0.7247, 0.7248) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用注解方式加载属性文件 --> ( 难度等级: [0.7247, 0.7248) || 挂载数据: 无 ) 
│       │   │   │   └── 使用XML方式加载属性文件 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: qa: 4 ) 
│       │   │   ├── 条件化装配Bean --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   ├── Bean的作用域 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   └── 使用Spring表达式（Spring EL） --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │       ├── Spring EL相关的类 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: qa: 2 ) 
│       │   │       └── Spring EL运算 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: qa: 10 ) 
│       │   ├── 面向切面编程 --> ( 难度等级: [0.7248, 0.725) || 挂载数据: 无 ) 
│       │   │   ├── 一个简单的约定游戏 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   │   ├── 约定规则 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   │   ├── 读者的代码 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   │   └── 笔者的代码 --> ( 难度等级: [0.7248, 0.7248) || 挂载数据: 无 ) 
│       │   │   ├── Spring AOP的基本概念 --> ( 难度等级: [0.7248, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── AOP的概念和使用原因 --> ( 难度等级: [0.7248, 0.7249) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 面向切面编程的术语 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   └── Spring对AOP的支持 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   ├── 使用@AspectJ注解开发Spring AOP --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 选择切点 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建切面 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 连接点 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 测试AOP --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 装配AOP --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 使用注解装配AOP --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: qa: 1 ) 
│       │   │   │   │   └── AOP避坑指南 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 环绕通知 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 织入 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 给通知传递参数 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   └── 引入 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用XML配置开发Spring AOP --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 前置通知、后置通知、返回通知和异常通知 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 环绕通知 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   ├── 给通知传递参数 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   │   └── 引入 --> ( 难度等级: [0.7249, 0.7249) || 挂载数据: 无 ) 
│       │   │   ├── 经典Spring AOP应用程序 --> ( 难度等级: [0.7249, 0.725) || 挂载数据: 无 ) 
│       │   │   └── 多个切面 --> ( 难度等级: [0.725, 0.725) || 挂载数据: 无 ) 
│       │   ├── Spring和数据库编程 --> ( 难度等级: [0.725, 0.7252) || 挂载数据: 无 ) 
│       │   │   ├── 传统的JDBC代码的弊端 --> ( 难度等级: [0.725, 0.725) || 挂载数据: 无 ) 
│       │   │   ├── 配置数据库资源 --> ( 难度等级: [0.725, 0.7251) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用简单数据库配置 --> ( 难度等级: [0.725, 0.7251) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 使用第三方数据库连接池 --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 使用JNDI数据库连接池 --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: 无 ) 
│       │   │   ├── JDBC代码失控的解决方案——jdbcTemplate --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: 无 ) 
│       │   │   │   ├── jdbcTemplate的增、删、查、改 --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── 执行多条SQL --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: qa: 1 ) 
│       │   │   │   └── jdbcTemplate的源码分析 --> ( 难度等级: [0.7251, 0.7251) || 挂载数据: qa: 7 ) 
│       │   │   └── Spring的缺点 --> ( 难度等级: [0.7251, 0.7252) || 挂载数据: 无 ) 
│       │   ├── 深入Spring数据库事务管理 --> ( 难度等级: [0.7252, 0.7254) || 挂载数据: 无 ) 
│       │   │   ├── Spring数据库事务管理器的设计 --> ( 难度等级: [0.7252, 0.7252) || 挂载数据: 无 ) 
│       │   │   │   ├── 配置事务管理器 --> ( 难度等级: [0.7252, 0.7252) || 挂载数据: 无 ) 
│       │   │   │   └── 用Java配置方式实现Spring数据库事务 --> ( 难度等级: [0.7252, 0.7252) || 挂载数据: qa: 1 ) 
│       │   │   ├── 编程式事务 --> ( 难度等级: [0.7252, 0.7252) || 挂载数据: 无 ) 
│       │   │   ├── 声明式事务 --> ( 难度等级: [0.7252, 0.7253) || 挂载数据: 无 ) 
│       │   │   │   ├── Transactional的配置项 --> ( 难度等级: [0.7252, 0.7252) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 使用XML进行配置事务管理器 --> ( 难度等级: [0.7252, 0.7253) || 挂载数据: 无 ) 
│       │   │   │   ├── 事务定义器 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: 无 ) 
│       │   │   │   └── 声明式事务的约定流程 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: qa: 1 ) 
│       │   │   ├── 数据库的相关知识 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 数据库事务ACID特性 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 丢失更新 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 隔离级别 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: 无 ) 
│       │   │   ├── 选择隔离级别和传播行为 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: 无 ) 
│       │   │   │   ├── 选择隔离级别 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 传播行为 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: 无 ) 
│       │   │   ├── 在Spring+MyBatis组合中使用事务 --> ( 难度等级: [0.7253, 0.7253) || 挂载数据: 无 ) 
│       │   │   └── 典型错误用法的剖析 --> ( 难度等级: [0.7253, 0.7254) || 挂载数据: 无 ) 
│       │   │       ├── 错误使用Service --> ( 难度等级: [0.7253, 0.7254) || 挂载数据: qa: 10 ) 
│       │   │       ├── 过长时间占用事务 --> ( 难度等级: [0.7254, 0.7254) || 挂载数据: 无 ) 
│       │   │       └── 错误捕捉异常 --> ( 难度等级: [0.7254, 0.7254) || 挂载数据: qa: 1 ) 
│       │   └── Spring基础配置 --> ( 难度等级: [0.7254, 0.7256) || 挂载数据: qa: 10 ) 
│       │       └── Java配置 --> ( 难度等级: [0.7254, 0.7256) || 挂载数据: 无 ) 
│       ├── Spring MVC框架 --> ( 难度等级: [0.7256, 0.7267) || 挂载数据: 无 ) 
│       │   ├── Spring MVC的初始化和流程 --> ( 难度等级: [0.7256, 0.7259) || 挂载数据: 无 ) 
│       │   │   ├── MVC设计概述 --> ( 难度等级: [0.7256, 0.7257) || 挂载数据: 无 ) 
│       │   │   │   ├── Spring MVC的架构 --> ( 难度等级: [0.7256, 0.7256) || 挂载数据: qa: 10 ) 
│       │   │   │   └── Spring MVC组件与流程 --> ( 难度等级: [0.7256, 0.7257) || 挂载数据: qa: 1 ) 
│       │   │   ├── Spring MVC初始化 --> ( 难度等级: [0.7257, 0.7258) || 挂载数据: 无 ) 
│       │   │   │   ├── 初始化Spring IoC上下文 --> ( 难度等级: [0.7257, 0.7257) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 初始化映射请求上下文 --> ( 难度等级: [0.7257, 0.7258) || 挂载数据: 无 ) 
│       │   │   │   └── 使用注解配置方式初始化 --> ( 难度等级: [0.7258, 0.7258) || 挂载数据: 无 ) 
│       │   │   └── Spring MVC开发流程详解 --> ( 难度等级: [0.7258, 0.7259) || 挂载数据: qa: 1 ) 
│       │   │       ├── 配置@RequestMapping --> ( 难度等级: [0.7258, 0.7258) || 挂载数据: 无 ) 
│       │   │       ├── 控制器的开发 --> ( 难度等级: [0.7258, 0.7259) || 挂载数据: qa: 10 ) 
│       │   │       └── 视图渲染 --> ( 难度等级: [0.7259, 0.7259) || 挂载数据: 无 ) 
│       │   ├── 深入Spring MVC组件开发 --> ( 难度等级: [0.7259, 0.7263) || 挂载数据: 无 ) 
│       │   │   ├── 控制器接收各类请求参数 --> ( 难度等级: [0.7259, 0.726) || 挂载数据: 无 ) 
│       │   │   │   ├── 接收普通请求参数 --> ( 难度等级: [0.7259, 0.7259) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 使用@RequestParam注解获取参数 --> ( 难度等级: [0.7259, 0.7259) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 使用URL传递参数 --> ( 难度等级: [0.7259, 0.726) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递JSON参数 --> ( 难度等级: [0.726, 0.726) || 挂载数据: qa: 8 ) 
│       │   │   │   └── 接收列表数据和表单序列化 --> ( 难度等级: [0.726, 0.726) || 挂载数据: 无 ) 
│       │   │   ├── 重定向 --> ( 难度等级: [0.726, 0.726) || 挂载数据: qa: 2 ) 
│       │   │   ├── 保存并获取属性参数 --> ( 难度等级: [0.726, 0.7261) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 注解@RequestAttribute --> ( 难度等级: [0.726, 0.726) || 挂载数据: 无 ) 
│       │   │   │   ├── 注解@SessionAttribute和注解@SessionAttributes --> ( 难度等级: [0.726, 0.7261) || 挂载数据: 无 ) 
│       │   │   │   └── 注解@CookieValue和注解@RequestHeader --> ( 难度等级: [0.7261, 0.7261) || 挂载数据: 无 ) 
│       │   │   ├── 验证表单 --> ( 难度等级: [0.7261, 0.7261) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用JSR 303注解验证输入内容 --> ( 难度等级: [0.7261, 0.7261) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 使用验证器 --> ( 难度等级: [0.7261, 0.7261) || 挂载数据: qa: 10 ) 
│       │   │   ├── 数据模型 --> ( 难度等级: [0.7261, 0.7262) || 挂载数据: 无 ) 
│       │   │   ├── 视图和视图解析器 --> ( 难度等级: [0.7262, 0.7262) || 挂载数据: 无 ) 
│       │   │   │   ├── 视图 --> ( 难度等级: [0.7262, 0.7262) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 视图解析器 --> ( 难度等级: [0.7262, 0.7262) || 挂载数据: 无 ) 
│       │   │   └── 上传文件 --> ( 难度等级: [0.7262, 0.7263) || 挂载数据: qa: 1 ) 
│       │   │       ├── MultipartResolver概述 --> ( 难度等级: [0.7262, 0.7263) || 挂载数据: 无 ) 
│       │   │       └── 提交上传文件表单 --> ( 难度等级: [0.7263, 0.7263) || 挂载数据: qa: 10 ) 
│       │   └── Spring MVC高级应用 --> ( 难度等级: [0.7263, 0.7267) || 挂载数据: 无 ) 
│       │       ├── Spring MVC的数据转换和格式化 --> ( 难度等级: [0.7263, 0.7264) || 挂载数据: 无 ) 
│       │       │   ├── HttpMessageConverter和JSON消息转换器 --> ( 难度等级: [0.7263, 0.7263) || 挂载数据: qa: 6 ) 
│       │       │   ├── 一对一转换器（Converter） --> ( 难度等级: [0.7263, 0.7263) || 挂载数据: qa: 1 ) 
│       │       │   ├── 数组和集合转换器GenericConverter --> ( 难度等级: [0.7263, 0.7264) || 挂载数据: qa: 1 ) 
│       │       │   └── 使用格式化器（Formatter） --> ( 难度等级: [0.7264, 0.7264) || 挂载数据: 无 ) 
│       │       ├── 为控制器添加通知 --> ( 难度等级: [0.7264, 0.7265) || 挂载数据: 无 ) 
│       │       ├── 处理异常 --> ( 难度等级: [0.7265, 0.7266) || 挂载数据: 无 ) 
│       │       └── 国际化 --> ( 难度等级: [0.7266, 0.7267) || 挂载数据: 无 ) 
│       │           ├── MessageSource接口 --> ( 难度等级: [0.7266, 0.7266) || 挂载数据: 无 ) 
│       │           ├── CookieLocaleResolver和SessionLocaleResolver --> ( 难度等级: [0.7266, 0.7266) || 挂载数据: 无 ) 
│       │           ├── 国际化拦截器（LocaleChangeInterceptor） --> ( 难度等级: [0.7266, 0.7266) || 挂载数据: 无 ) 
│       │           └── 开发国际化 --> ( 难度等级: [0.7266, 0.7267) || 挂载数据: 无 ) 
│       ├── SSM框架+Redis实践应用 --> ( 难度等级: [0.7267, 0.7278) || 挂载数据: 无 ) 
│       │   └── 高并发业务 --> ( 难度等级: [0.7267, 0.7278) || 挂载数据: 无 ) 
│       │       ├── 互联系统应用架构基础分析 --> ( 难度等级: [0.7267, 0.7268) || 挂载数据: 无 ) 
│       │       ├── 高并发系统的分析和设计 --> ( 难度等级: [0.7268, 0.727) || 挂载数据: 无 ) 
│       │       │   ├── 有效请求和无效请求 --> ( 难度等级: [0.7268, 0.7269) || 挂载数据: qa: 6 ) 
│       │       │   ├── 系统设计 --> ( 难度等级: [0.7269, 0.7269) || 挂载数据: qa: 1 ) 
│       │       │   ├── 数据库设计 --> ( 难度等级: [0.7269, 0.7269) || 挂载数据: qa: 10 ) 
│       │       │   ├── 动静分离技术 --> ( 难度等级: [0.7269, 0.727) || 挂载数据: 无 ) 
│       │       │   └── 锁和高并发 --> ( 难度等级: [0.727, 0.727) || 挂载数据: qa: 10 ) 
│       │       ├── 搭建抢红包开发环境和超发现象 --> ( 难度等级: [0.727, 0.7271) || 挂载数据: 无 ) 
│       │       │   ├── 搭建Service层和DAO层 --> ( 难度等级: [0.727, 0.7271) || 挂载数据: qa: 6 ) 
│       │       │   └── 使用全注解搭建SSM开发环境 --> ( 难度等级: [0.7271, 0.7271) || 挂载数据: qa: 2 ) 
│       │       ├── 悲观锁 --> ( 难度等级: [0.7271, 0.7273) || 挂载数据: 无 ) 
│       │       ├── 乐观锁 --> ( 难度等级: [0.7273, 0.7275) || 挂载数据: 无 ) 
│       │       │   ├── CAS原理概述 --> ( 难度等级: [0.7273, 0.7274) || 挂载数据: qa: 2 ) 
│       │       │   ├── 乐观锁实现抢红包业务 --> ( 难度等级: [0.7274, 0.7274) || 挂载数据: qa: 3 ) 
│       │       │   └── 乐观锁重入机制 --> ( 难度等级: [0.7274, 0.7275) || 挂载数据: qa: 1 ) 
│       │       ├── 使用Redis实现抢红包 --> ( 难度等级: [0.7275, 0.7276) || 挂载数据: 无 ) 
│       │       │   ├── 使用注解方式配置Redis --> ( 难度等级: [0.7275, 0.7275) || 挂载数据: 无 ) 
│       │       │   ├── 数据存储设计 --> ( 难度等级: [0.7275, 0.7276) || 挂载数据: qa: 4 ) 
│       │       │   └── 使用Redis实现抢红包 --> ( 难度等级: [0.7276, 0.7276) || 挂载数据: 无 ) 
│       │       └── 各类方式的优缺点 --> ( 难度等级: [0.7276, 0.7278) || 挂载数据: qa: 1 ) 
│       ├── 点睛Spring 4.x --> ( 难度等级: [0.7278, 0.7289) || 挂载数据: qa: 1 ) 
│       │   ├── Spring常用配置 --> ( 难度等级: [0.7278, 0.7283) || 挂载数据: 无 ) 
│       │   │   ├── Bean的Scope --> ( 难度等级: [0.7278, 0.7279) || 挂载数据: 无 ) 
│       │   │   │   └── 示例 --> ( 难度等级: [0.7278, 0.7279) || 挂载数据: 无 ) 
│       │   │   ├── Spring EL和资源调用. --> ( 难度等级: [0.7279, 0.7281) || 挂载数据: 无 ) 
│       │   │   │   └── 示例 --> ( 难度等级: [0.7279, 0.7281) || 挂载数据: 无 ) 
│       │   │   ├── Bean的初始化和销毁 --> ( 难度等级: [0.7281, 0.7282) || 挂载数据: 无 ) 
│       │   │   └── 事件（Application Event） --> ( 难度等级: [0.7282, 0.7283) || 挂载数据: qa: 3 ) 
│       │   │       └── 示例 --> ( 难度等级: [0.7282, 0.7283) || 挂载数据: 无 ) 
│       │   └── Spring高级话题 --> ( 难度等级: [0.7283, 0.7289) || 挂载数据: qa: 1 ) 
│       │       ├── Spring Aware --> ( 难度等级: [0.7283, 0.7284) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.7283, 0.7284) || 挂载数据: 无 ) 
│       │       ├── 多线程 --> ( 难度等级: [0.7284, 0.7285) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.7284, 0.7285) || 挂载数据: qa: 1 ) 
│       │       ├── 计划任务 --> ( 难度等级: [0.7285, 0.7286) || 挂载数据: qa: 1 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.7285, 0.7286) || 挂载数据: 无 ) 
│       │       ├── 条件注解@Conditional --> ( 难度等级: [0.7286, 0.7287) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.7286, 0.7287) || 挂载数据: 无 ) 
│       │       ├── 组合注解与元注解 --> ( 难度等级: [0.7287, 0.7287) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.7287, 0.7287) || 挂载数据: 无 ) 
│       │       ├── @Enable*注解的工作原理 --> ( 难度等级: [0.7287, 0.7288) || 挂载数据: qa: 1 ) 
│       │       │   ├── 第一类：直接导入配置类 --> ( 难度等级: [0.7287, 0.7288) || 挂载数据: 无 ) 
│       │       │   ├── 第二类：依据条件选择配置类 --> ( 难度等级: [0.7288, 0.7288) || 挂载数据: 无 ) 
│       │       │   └── 第三类：动态注册Bean --> ( 难度等级: [0.7288, 0.7288) || 挂载数据: 无 ) 
│       │       └── 测试 --> ( 难度等级: [0.7288, 0.7289) || 挂载数据: 无 ) 
│       │           └── 示例 --> ( 难度等级: [0.7288, 0.7289) || 挂载数据: 无 ) 
│       ├── 点睛Spring MVC 4.x --> ( 难度等级: [0.7289, 0.73) || 挂载数据: 无 ) 
│       │   └── Spring MVC基础 --> ( 难度等级: [0.7289, 0.73) || 挂载数据: 无 ) 
│       │       ├── Spring MVC概述 --> ( 难度等级: [0.7289, 0.7291) || 挂载数据: 无 ) 
│       │       ├── Spring MVC的常用注解 --> ( 难度等级: [0.7291, 0.7293) || 挂载数据: 无 ) 
│       │       ├── Spring MVC基本配置 --> ( 难度等级: [0.7293, 0.7296) || 挂载数据: 无 ) 
│       │       │   ├── 静态资源映射 --> ( 难度等级: [0.7293, 0.7294) || 挂载数据: qa: 3 ) 
│       │       │   ├── 拦截器配置 --> ( 难度等级: [0.7294, 0.7294) || 挂载数据: 无 ) 
│       │       │   ├── @ControllerAdvice --> ( 难度等级: [0.7294, 0.7295) || 挂载数据: 无 ) 
│       │       │   └── 其他配置 --> ( 难度等级: [0.7295, 0.7296) || 挂载数据: qa: 8 ) 
│       │       ├── Spring MVC的高级配置 --> ( 难度等级: [0.7296, 0.7298) || 挂载数据: 无 ) 
│       │       │   ├── 文件上传配置 --> ( 难度等级: [0.7296, 0.7296) || 挂载数据: qa: 1 ) 
│       │       │   ├── 自定义HttpMessageConverter --> ( 难度等级: [0.7296, 0.7297) || 挂载数据: 无 ) 
│       │       │   └── 服务器端推送技术 --> ( 难度等级: [0.7297, 0.7298) || 挂载数据: qa: 2 ) 
│       │       └── Spring MVC的测试 --> ( 难度等级: [0.7298, 0.73) || 挂载数据: 无 ) 
│       ├── Java EE简介 --> ( 难度等级: [0.73, 0.7311) || 挂载数据: 无 ) 
│       │   ├── Java EE --> ( 难度等级: [0.73, 0.7304) || 挂载数据: 无 ) 
│       │   │   ├── Java EE架构 --> ( 难度等级: [0.73, 0.7302) || 挂载数据: qa: 4 ) 
│       │   │   └── Java EE的缺点 --> ( 难度等级: [0.7302, 0.7304) || 挂载数据: 无 ) 
│       │   ├── Spring Boot --> ( 难度等级: [0.7304, 0.7307) || 挂载数据: 无 ) 
│       │   └── Hello，Spring Boot --> ( 难度等级: [0.7307, 0.7311) || 挂载数据: 无 ) 
│       │       ├── 创建一个Maven工程 --> ( 难度等级: [0.7307, 0.7308) || 挂载数据: qa: 2 ) 
│       │       ├── 增加Web支持 --> ( 难度等级: [0.7308, 0.7309) || 挂载数据: 无 ) 
│       │       ├── Hello Spring Boot示例 --> ( 难度等级: [0.7309, 0.731) || 挂载数据: qa: 2 ) 
│       │       ├── 使用热部署 --> ( 难度等级: [0.731, 0.731) || 挂载数据: 无 ) 
│       │       └── 添加REST支持 --> ( 难度等级: [0.731, 0.7311) || 挂载数据: 无 ) 
│       ├── Spring Boot基础 --> ( 难度等级: [0.7311, 0.7322) || 挂载数据: 无 ) 
│       │   ├── 检查Java环境与安装Java --> ( 难度等级: [0.7311, 0.7315) || 挂载数据: 无 ) 
│       │   ├── 安装和配置Maven --> ( 难度等级: [0.7315, 0.7319) || 挂载数据: 无 ) 
│       │   │   ├── Maven介绍 --> ( 难度等级: [0.7315, 0.7316) || 挂载数据: qa: 9 ) 
│       │   │   ├── 安装Maven --> ( 难度等级: [0.7316, 0.7316) || 挂载数据: qa: 2 ) 
│       │   │   ├── 设置Maven --> ( 难度等级: [0.7316, 0.7317) || 挂载数据: 无 ) 
│       │   │   ├── 使用IDE设置Maven --> ( 难度等级: [0.7317, 0.7318) || 挂载数据: 无 ) 
│       │   │   └── Maven的常用命令 --> ( 难度等级: [0.7318, 0.7319) || 挂载数据: 无 ) 
│       │   └── Spring核心技术 --> ( 难度等级: [0.7319, 0.7322) || 挂载数据: 无 ) 
│       │       ├── Spring的历史 --> ( 难度等级: [0.7319, 0.732) || 挂载数据: 无 ) 
│       │       ├── Spring容器介绍 --> ( 难度等级: [0.732, 0.7321) || 挂载数据: 无 ) 
│       │       └── Spring AOP介绍 --> ( 难度等级: [0.7321, 0.7322) || 挂载数据: 无 ) 
│       ├── MVC框架 --> ( 难度等级: [0.7322, 0.7333) || 挂载数据: 无 ) 
│       │   ├── 集成MVC框架 --> ( 难度等级: [0.7322, 0.7323) || 挂载数据: 无 ) 
│       │   │   ├── 引入依赖 --> ( 难度等级: [0.7322, 0.7323) || 挂载数据: 无 ) 
│       │   │   ├── Web应用目录结构 --> ( 难度等级: [0.7323, 0.7323) || 挂载数据: qa: 1 ) 
│       │   │   └── Java包名结构 --> ( 难度等级: [0.7323, 0.7323) || 挂载数据: 无 ) 
│       │   ├── 使用Controller --> ( 难度等级: [0.7323, 0.7325) || 挂载数据: qa: 10 ) 
│       │   ├── URL映射到方法 --> ( 难度等级: [0.7325, 0.7326) || 挂载数据: 无 ) 
│       │   │   ├── @RequestMapping --> ( 难度等级: [0.7325, 0.7325) || 挂载数据: qa: 2 ) 
│       │   │   ├── URL路径匹配 --> ( 难度等级: [0.7325, 0.7325) || 挂载数据: qa: 10 ) 
│       │   │   ├── HTTP method匹配 --> ( 难度等级: [0.7325, 0.7325) || 挂载数据: qa: 2 ) 
│       │   │   ├── consumes和produces --> ( 难度等级: [0.7325, 0.7326) || 挂载数据: 无 ) 
│       │   │   └── params和header匹配 --> ( 难度等级: [0.7326, 0.7326) || 挂载数据: qa: 2 ) 
│       │   ├── 方法参数 --> ( 难度等级: [0.7326, 0.7327) || 挂载数据: 无 ) 
│       │   │   ├── PathVariable --> ( 难度等级: [0.7326, 0.7326) || 挂载数据: 无 ) 
│       │   │   ├── Model＆ModelAndView --> ( 难度等级: [0.7326, 0.7326) || 挂载数据: qa: 3 ) 
│       │   │   ├── JavaBean接受HTTP参数 --> ( 难度等级: [0.7326, 0.7326) || 挂载数据: qa: 6 ) 
│       │   │   ├── @RequsetBody接受JSON --> ( 难度等级: [0.7326, 0.7327) || 挂载数据: qa: 1 ) 
│       │   │   ├── MultipartFile --> ( 难度等级: [0.7327, 0.7327) || 挂载数据: qa: 1 ) 
│       │   │   ├── @ModelAttribute --> ( 难度等级: [0.7327, 0.7327) || 挂载数据: 无 ) 
│       │   │   └── @InitBinder --> ( 难度等级: [0.7327, 0.7327) || 挂载数据: 无 ) 
│       │   ├── 验证框架 --> ( 难度等级: [0.7327, 0.7328) || 挂载数据: 无 ) 
│       │   │   ├── JSR- --> ( 难度等级: [0.7327, 0.7328) || 挂载数据: 无 ) 
│       │   │   ├── MVC中使用@Validated --> ( 难度等级: [0.7328, 0.7328) || 挂载数据: 无 ) 
│       │   │   └── 自定义校验 --> ( 难度等级: [0.7328, 0.7328) || 挂载数据: 无 ) 
│       │   ├── WebMvcConfigurer --> ( 难度等级: [0.7328, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── 跨域访问 --> ( 难度等级: [0.7328, 0.7329) || 挂载数据: qa: 2 ) 
│       │   │   └── 注册Controller --> ( 难度等级: [0.7329, 0.733) || 挂载数据: 无 ) 
│       │   ├── 视图技术 --> ( 难度等级: [0.733, 0.7331) || 挂载数据: 无 ) 
│       │   │   ├── 使用Freemarker --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 7 ) 
│       │   │   ├── 使用Beetl --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── 使用Jackson --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 1 ) 
│       │   │   ├── Redirect和Forward --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── Beetl模板引擎 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   ├── 安装Beetl --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   ├── 设置定界符号和占位符 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 配置Beetl --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   └── groupTemplate --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── 使用变量 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   ├── 全局变量 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 局部变量 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   ├── 共享变量 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 模板变量 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 4 ) 
│       │   │   ├── 表达式 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 计算表达式 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 逻辑表达式 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 2 ) 
│       │   │   ├── 控制语句 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   ├── 循环语句 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 条件语句 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   │   └── try catch --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 6 ) 
│       │   │   ├── 函数调用 --> ( 难度等级: [0.733, 0.733) || 挂载数据: qa: 1 ) 
│       │   │   ├── 格式化函数 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── 直接调用Java --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── 标签函数 --> ( 难度等级: [0.733, 0.733) || 挂载数据: 无 ) 
│       │   │   ├── HTML标签 --> ( 难度等级: [0.733, 0.7331) || 挂载数据: qa: 10 ) 
│       │   │   ├── 安全输出 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 4 ) 
│       │   │   ├── 高级功能 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义函数 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 自定义格式化函数 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义标签函数 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义HTML标签 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 1 ) 
│       │   │   │   └── AJAX局部渲染 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 10 ) 
│       │   │   ├── 脚本引擎 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 1 ) 
│       │   │   ├── JSON技术 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 在Spring Boot中使用Jackson --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义ObjectMapper --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── Jackson的三种使用方式 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   ├── Jackson树遍历 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 对象绑定 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── 流式操作 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── Jackson注解 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │   │   └── 集合的反序列化 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: qa: 2 ) 
│       │   │   └── MVC分离开发 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │       ├── 集成WebSimulate --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │       ├── 模拟JSON响应 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   │       └── 模拟模板渲染 --> ( 难度等级: [0.7331, 0.7331) || 挂载数据: 无 ) 
│       │   ├── 通用错误处理 --> ( 难度等级: [0.7331, 0.7332) || 挂载数据: 无 ) 
│       │   └── curl命令 --> ( 难度等级: [0.7332, 0.7333) || 挂载数据: 无 ) 
│       ├── 数据库访问 --> ( 难度等级: [0.7333, 0.7344) || 挂载数据: 无 ) 
│       │   ├── 配置数据源 --> ( 难度等级: [0.7333, 0.7334) || 挂载数据: 无 ) 
│       │   ├── Spring JDBC Template --> ( 难度等级: [0.7334, 0.7335) || 挂载数据: 无 ) 
│       │   │   ├── 查询 --> ( 难度等级: [0.7334, 0.7335) || 挂载数据: qa: 2 ) 
│       │   │   ├── 修改 --> ( 难度等级: [0.7335, 0.7335) || 挂载数据: qa: 10 ) 
│       │   │   └── JdbcTemplate增强 --> ( 难度等级: [0.7335, 0.7335) || 挂载数据: 无 ) 
│       │   ├── BeetlSQL介绍 --> ( 难度等级: [0.7335, 0.7336) || 挂载数据: 无 ) 
│       │   │   ├── BeetlSQL功能概览 --> ( 难度等级: [0.7335, 0.7335) || 挂载数据: 无 ) 
│       │   │   ├── 添加Maven依赖 --> ( 难度等级: [0.7335, 0.7335) || 挂载数据: 无 ) 
│       │   │   ├── 配置BeetlSQL --> ( 难度等级: [0.7335, 0.7336) || 挂载数据: 无 ) 
│       │   │   ├── SQLManager --> ( 难度等级: [0.7336, 0.7336) || 挂载数据: 无 ) 
│       │   │   ├── 使用SQL文件 --> ( 难度等级: [0.7336, 0.7336) || 挂载数据: 无 ) 
│       │   │   └── 使用实体 --> ( 难度等级: [0.7336, 0.7336) || 挂载数据: 无 ) 
│       │   ├── SQLManager内置CRUD --> ( 难度等级: [0.7336, 0.7337) || 挂载数据: qa: 1 ) 
│       │   │   ├── 内置的插入API --> ( 难度等级: [0.7336, 0.7336) || 挂载数据: 无 ) 
│       │   │   ├── 内置的更新（删除）API --> ( 难度等级: [0.7336, 0.7337) || 挂载数据: 无 ) 
│       │   │   ├── 内置的查询API --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: 无 ) 
│       │   │   └── 代码生成方法 --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: 无 ) 
│       │   ├── 使用sqlId --> ( 难度等级: [0.7337, 0.7338) || 挂载数据: 无 ) 
│       │   │   ├── md文件命名 --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: 无 ) 
│       │   │   ├── md文件构成 --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: qa: 1 ) 
│       │   │   ├── 调用sqlId --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: 无 ) 
│       │   │   ├── 翻页查询 --> ( 难度等级: [0.7337, 0.7337) || 挂载数据: 无 ) 
│       │   │   ├── TailBean --> ( 难度等级: [0.7337, 0.7338) || 挂载数据: 无 ) 
│       │   │   ├── ORM查询 --> ( 难度等级: [0.7338, 0.7338) || 挂载数据: qa: 1 ) 
│       │   │   ├── 其他API --> ( 难度等级: [0.7338, 0.7338) || 挂载数据: qa: 2 ) 
│       │   │   └── Mapper详解 --> ( 难度等级: [0.7338, 0.7338) || 挂载数据: 无 ) 
│       │   ├── BeetlSQL的其他功能 --> ( 难度等级: [0.7338, 0.7339) || 挂载数据: 无 ) 
│       │   │   ├── 常用函数和标签 --> ( 难度等级: [0.7338, 0.7338) || 挂载数据: 无 ) 
│       │   │   ├── 主键设置 --> ( 难度等级: [0.7338, 0.7338) || 挂载数据: 无 ) 
│       │   │   ├── BeetlSQL注解 --> ( 难度等级: [0.7338, 0.7339) || 挂载数据: 无 ) 
│       │   │   └── NameConversion --> ( 难度等级: [0.7339, 0.7339) || 挂载数据: 无 ) 
│       │   ├── 使用JDBC --> ( 难度等级: [0.7339, 0.734) || 挂载数据: 无 ) 
│       │   ├── 使用DAO --> ( 难度等级: [0.734, 0.7341) || 挂载数据: qa: 5 ) 
│       │   ├── 集成Hibernate --> ( 难度等级: [0.7341, 0.7342) || 挂载数据: 无 ) 
│       │   ├── 集成JPA --> ( 难度等级: [0.7342, 0.7343) || 挂载数据: 无 ) 
│       │   ├── 集成MyBatis --> ( 难度等级: [0.7343, 0.7344) || 挂载数据: 无 ) 
│       │   └── 设计ORM --> ( 难度等级: [0.7344, 0.7344) || 挂载数据: 无 ) 
│       ├── Spring Data JPA --> ( 难度等级: [0.7344, 0.7356) || 挂载数据: 无 ) 
│       │   ├── 集成Spring Data JPA --> ( 难度等级: [0.7344, 0.735) || 挂载数据: 无 ) 
│       │   │   ├── 集成数据源 --> ( 难度等级: [0.7344, 0.7346) || 挂载数据: qa: 1 ) 
│       │   │   ├── 配置JPA支持 --> ( 难度等级: [0.7346, 0.7347) || 挂载数据: qa: 7 ) 
│       │   │   ├── 创建Entity --> ( 难度等级: [0.7347, 0.7349) || 挂载数据: 无 ) 
│       │   │   └── 简化Entity --> ( 难度等级: [0.7349, 0.735) || 挂载数据: 无 ) 
│       │   └── Repository --> ( 难度等级: [0.735, 0.7356) || 挂载数据: 无 ) 
│       │       ├── CrudRepository --> ( 难度等级: [0.735, 0.7351) || 挂载数据: 无 ) 
│       │       ├── PagingAndSortingRepository --> ( 难度等级: [0.7351, 0.7351) || 挂载数据: 无 ) 
│       │       ├── JpaRepository --> ( 难度等级: [0.7351, 0.7352) || 挂载数据: 无 ) 
│       │       ├── 持久化Entity --> ( 难度等级: [0.7352, 0.7352) || 挂载数据: 无 ) 
│       │       ├── Sort --> ( 难度等级: [0.7352, 0.7353) || 挂载数据: qa: 3 ) 
│       │       ├── Pageable和Page --> ( 难度等级: [0.7353, 0.7353) || 挂载数据: qa: 2 ) 
│       │       ├── 基于方法名字查询 --> ( 难度等级: [0.7353, 0.7354) || 挂载数据: 无 ) 
│       │       ├── @Query查询 --> ( 难度等级: [0.7354, 0.7354) || 挂载数据: qa: 2 ) 
│       │       ├── 使用JPA Query --> ( 难度等级: [0.7354, 0.7355) || 挂载数据: 无 ) 
│       │       └── Example查询 --> ( 难度等级: [0.7355, 0.7356) || 挂载数据: 无 ) 
│       ├── Spring Boot配置 --> ( 难度等级: [0.7356, 0.7367) || 挂载数据: 无 ) 
│       │   ├── 配置Spring Boot --> ( 难度等级: [0.7356, 0.7358) || 挂载数据: 无 ) 
│       │   │   ├── 服务器配置 --> ( 难度等级: [0.7356, 0.7356) || 挂载数据: qa: 10 ) 
│       │   │   ├── 使用其他Web服务器 --> ( 难度等级: [0.7356, 0.7357) || 挂载数据: qa: 1 ) 
│       │   │   ├── 配置启动信息 --> ( 难度等级: [0.7357, 0.7358) || 挂载数据: qa: 2 ) 
│       │   │   └── 配置浏览器显示ico --> ( 难度等级: [0.7358, 0.7358) || 挂载数据: qa: 1 ) 
│       │   ├── 日志配置 --> ( 难度等级: [0.7358, 0.7361) || 挂载数据: 无 ) 
│       │   ├── 读取应用配置 --> ( 难度等级: [0.7361, 0.7364) || 挂载数据: 无 ) 
│       │   │   ├── Environment --> ( 难度等级: [0.7361, 0.7362) || 挂载数据: 无 ) 
│       │   │   ├── @Value --> ( 难度等级: [0.7362, 0.7363) || 挂载数据: qa: 8 ) 
│       │   │   └── @ConfigurationProperties --> ( 难度等级: [0.7363, 0.7364) || 挂载数据: 无 ) 
│       │   └── Spring Boot自动装配 --> ( 难度等级: [0.7364, 0.7367) || 挂载数据: 无 ) 
│       │       ├── @Configuration和@Bean --> ( 难度等级: [0.7364, 0.7364) || 挂载数据: 无 ) 
│       │       ├── Bean条件装配 --> ( 难度等级: [0.7364, 0.7365) || 挂载数据: 无 ) 
│       │       ├── Class条件装配 --> ( 难度等级: [0.7365, 0.7365) || 挂载数据: 无 ) 
│       │       ├── Environment装配 --> ( 难度等级: [0.7365, 0.7365) || 挂载数据: 无 ) 
│       │       ├── 其他条件装配 --> ( 难度等级: [0.7365, 0.7366) || 挂载数据: qa: 3 ) 
│       │       ├── 联合多个条件 --> ( 难度等级: [0.7366, 0.7366) || 挂载数据: 无 ) 
│       │       ├── Condition接口 --> ( 难度等级: [0.7366, 0.7366) || 挂载数据: 无 ) 
│       │       └── 制作Starter --> ( 难度等级: [0.7366, 0.7367) || 挂载数据: qa: 7 ) 
│       ├── 部署Spring Boot应用 --> ( 难度等级: [0.7367, 0.7378) || 挂载数据: 无 ) 
│       │   ├── 以jar文件运行 --> ( 难度等级: [0.7367, 0.7369) || 挂载数据: qa: 3 ) 
│       │   ├── 以war方式部署 --> ( 难度等级: [0.7369, 0.7372) || 挂载数据: qa: 4 ) 
│       │   ├── 多环境部署 --> ( 难度等级: [0.7372, 0.7375) || 挂载数据: qa: 4 ) 
│       │   └── @Profile注解 --> ( 难度等级: [0.7375, 0.7378) || 挂载数据: 无 ) 
│       ├── Testing单元测试 --> ( 难度等级: [0.7378, 0.7389) || 挂载数据: 无 ) 
│       │   ├── JUnit介绍 --> ( 难度等级: [0.7378, 0.7381) || 挂载数据: 无 ) 
│       │   │   ├── JUnit的相关概念 --> ( 难度等级: [0.7378, 0.7378) || 挂载数据: 无 ) 
│       │   │   ├── JUnit测试 --> ( 难度等级: [0.7378, 0.7379) || 挂载数据: qa: 3 ) 
│       │   │   ├── Assert --> ( 难度等级: [0.7379, 0.738) || 挂载数据: 无 ) 
│       │   │   └── Suite --> ( 难度等级: [0.738, 0.7381) || 挂载数据: 无 ) 
│       │   ├── Spring Boot单元测试 --> ( 难度等级: [0.7381, 0.7383) || 挂载数据: 无 ) 
│       │   │   ├── 测试范围依赖 --> ( 难度等级: [0.7381, 0.7381) || 挂载数据: qa: 2 ) 
│       │   │   ├── Spring Boot测试脚手架 --> ( 难度等级: [0.7381, 0.7381) || 挂载数据: qa: 1 ) 
│       │   │   ├── 测试MVC --> ( 难度等级: [0.7381, 0.7382) || 挂载数据: 无 ) 
│       │   │   ├── 完成MVC请求模拟 --> ( 难度等级: [0.7382, 0.7382) || 挂载数据: 无 ) 
│       │   │   ├── 比较MVC的返回结果 --> ( 难度等级: [0.7382, 0.7383) || 挂载数据: 无 ) 
│       │   │   └── JSON比较 --> ( 难度等级: [0.7383, 0.7383) || 挂载数据: qa: 10 ) 
│       │   ├── Mockito --> ( 难度等级: [0.7383, 0.7386) || 挂载数据: 无 ) 
│       │   │   ├── 模拟对象 --> ( 难度等级: [0.7383, 0.7384) || 挂载数据: qa: 3 ) 
│       │   │   ├── 模拟方法参数 --> ( 难度等级: [0.7384, 0.7385) || 挂载数据: 无 ) 
│       │   │   └── 模拟方法返回值 --> ( 难度等级: [0.7385, 0.7386) || 挂载数据: qa: 2 ) 
│       │   └── 面向数据库应用的单元测试 --> ( 难度等级: [0.7386, 0.7389) || 挂载数据: 无 ) 
│       │       ├── @Sql --> ( 难度等级: [0.7386, 0.7387) || 挂载数据: qa: 10 ) 
│       │       ├── XLSUnit --> ( 难度等级: [0.7387, 0.7388) || 挂载数据: 无 ) 
│       │       └── XLSUnit的基本用法 --> ( 难度等级: [0.7388, 0.7389) || 挂载数据: 无 ) 
│       ├── REST --> ( 难度等级: [0.7389, 0.74) || 挂载数据: 无 ) 
│       │   ├── REST简介 --> ( 难度等级: [0.7389, 0.7392) || 挂载数据: 无 ) 
│       │   │   ├── REST风格的架构 --> ( 难度等级: [0.7389, 0.7389) || 挂载数据: 无 ) 
│       │   │   ├── 使用“api”作为上下文 --> ( 难度等级: [0.7389, 0.739) || 挂载数据: 无 ) 
│       │   │   ├── 增加一个版本标识 --> ( 难度等级: [0.739, 0.739) || 挂载数据: 无 ) 
│       │   │   ├── 标识资源 --> ( 难度等级: [0.739, 0.739) || 挂载数据: 无 ) 
│       │   │   ├── 确定HTTP Method --> ( 难度等级: [0.739, 0.7391) || 挂载数据: qa: 4 ) 
│       │   │   ├── 确定HTTP Status --> ( 难度等级: [0.7391, 0.7391) || 挂载数据: qa: 1 ) 
│       │   │   └── REST VS. WebService --> ( 难度等级: [0.7391, 0.7392) || 挂载数据: qa: 10 ) 
│       │   ├── Spring Boot集成REST --> ( 难度等级: [0.7392, 0.7394) || 挂载数据: 无 ) 
│       │   │   ├── 集成REST --> ( 难度等级: [0.7392, 0.7393) || 挂载数据: 无 ) 
│       │   │   ├── @RestController --> ( 难度等级: [0.7393, 0.7394) || 挂载数据: 无 ) 
│       │   │   └── REST Client --> ( 难度等级: [0.7394, 0.7394) || 挂载数据: qa: 5 ) 
│       │   ├── Swagger UI --> ( 难度等级: [0.7394, 0.7397) || 挂载数据: qa: 4 ) 
│       │   │   ├── 集成Swagger --> ( 难度等级: [0.7394, 0.7395) || 挂载数据: 无 ) 
│       │   │   ├── Swagger规范 --> ( 难度等级: [0.7395, 0.7395) || 挂载数据: qa: 3 ) 
│       │   │   ├── 接口描述 --> ( 难度等级: [0.7395, 0.7395) || 挂载数据: qa: 1 ) 
│       │   │   ├── 查询参数描述 --> ( 难度等级: [0.7395, 0.7396) || 挂载数据: qa: 1 ) 
│       │   │   ├── URI中的参数 --> ( 难度等级: [0.7396, 0.7396) || 挂载数据: 无 ) 
│       │   │   ├── HTTP头参数 --> ( 难度等级: [0.7396, 0.7396) || 挂载数据: 无 ) 
│       │   │   ├── 表单参数 --> ( 难度等级: [0.7396, 0.7397) || 挂载数据: 无 ) 
│       │   │   ├── 文件上传参数 --> ( 难度等级: [0.7397, 0.7397) || 挂载数据: 无 ) 
│       │   │   └── 整个请求体作为参数 --> ( 难度等级: [0.7397, 0.7397) || 挂载数据: 无 ) 
│       │   └── 模拟REST服务 --> ( 难度等级: [0.7397, 0.74) || 挂载数据: 无 ) 
│       ├── MongoDB --> ( 难度等级: [0.74, 0.7411) || 挂载数据: 无 ) 
│       │   ├── 安装MongoDB --> ( 难度等级: [0.74, 0.7403) || 挂载数据: qa: 3 ) 
│       │   ├── 使用shell --> ( 难度等级: [0.7403, 0.7406) || 挂载数据: qa: 3 ) 
│       │   │   ├── 指定数据库 --> ( 难度等级: [0.7403, 0.7403) || 挂载数据: 无 ) 
│       │   │   ├── 插入文档 --> ( 难度等级: [0.7403, 0.7404) || 挂载数据: qa: 1 ) 
│       │   │   ├── 查询文档 --> ( 难度等级: [0.7404, 0.7404) || 挂载数据: 无 ) 
│       │   │   ├── 更新操作 --> ( 难度等级: [0.7404, 0.7405) || 挂载数据: 无 ) 
│       │   │   └── 删除操作 --> ( 难度等级: [0.7405, 0.7406) || 挂载数据: 无 ) 
│       │   ├── Spring Boot集成MongoDB --> ( 难度等级: [0.7406, 0.7408) || 挂载数据: 无 ) 
│       │   └── 增删改查 --> ( 难度等级: [0.7408, 0.7411) || 挂载数据: qa: 2 ) 
│       │       ├── 增加API --> ( 难度等级: [0.7408, 0.7409) || 挂载数据: qa: 1 ) 
│       │       ├── 根据主键查询API --> ( 难度等级: [0.7409, 0.7409) || 挂载数据: 无 ) 
│       │       ├── 查询API --> ( 难度等级: [0.7409, 0.741) || 挂载数据: 无 ) 
│       │       ├── 修改API --> ( 难度等级: [0.741, 0.741) || 挂载数据: 无 ) 
│       │       ├── 删除API --> ( 难度等级: [0.741, 0.741) || 挂载数据: 无 ) 
│       │       ├── 使用MongoDatabase --> ( 难度等级: [0.741, 0.7411) || 挂载数据: 无 ) 
│       │       └── 打印日志 --> ( 难度等级: [0.7411, 0.7411) || 挂载数据: qa: 9 ) 
│       ├── Elasticsearch --> ( 难度等级: [0.7411, 0.7422) || 挂载数据: 无 ) 
│       │   ├── Elasticsearch介绍 --> ( 难度等级: [0.7411, 0.7414) || 挂载数据: 无 ) 
│       │   │   ├── 安装Elasticsearch --> ( 难度等级: [0.7411, 0.7412) || 挂载数据: 无 ) 
│       │   │   └── Elasticsearch的基本概念 --> ( 难度等级: [0.7412, 0.7414) || 挂载数据: qa: 2 ) 
│       │   ├── 使用REST访问Elasticsearch --> ( 难度等级: [0.7414, 0.7417) || 挂载数据: 无 ) 
│       │   │   ├── 添加文档 --> ( 难度等级: [0.7414, 0.7414) || 挂载数据: qa: 4 ) 
│       │   │   ├── 根据主键查询 --> ( 难度等级: [0.7414, 0.7415) || 挂载数据: 无 ) 
│       │   │   ├── 根据主键更新 --> ( 难度等级: [0.7415, 0.7415) || 挂载数据: 无 ) 
│       │   │   ├── 根据主键删除 --> ( 难度等级: [0.7415, 0.7416) || 挂载数据: qa: 2 ) 
│       │   │   ├── 搜索文档 --> ( 难度等级: [0.7416, 0.7416) || 挂载数据: qa: 1 ) 
│       │   │   └── 联合多个索引搜索 --> ( 难度等级: [0.7416, 0.7417) || 挂载数据: 无 ) 
│       │   ├── 使用RestTemplate访问ES --> ( 难度等级: [0.7417, 0.7419) || 挂载数据: qa: 1 ) 
│       │   │   ├── 创建Book --> ( 难度等级: [0.7417, 0.7418) || 挂载数据: qa: 2 ) 
│       │   │   └── 使用RestTemplate获取搜索结果 --> ( 难度等级: [0.7418, 0.7419) || 挂载数据: qa: 3 ) 
│       │   └── Spring Data Elastic --> ( 难度等级: [0.7419, 0.7422) || 挂载数据: 无 ) 
│       │       ├── 安装Spring Data --> ( 难度等级: [0.7419, 0.742) || 挂载数据: qa: 7 ) 
│       │       ├── 编写Entity --> ( 难度等级: [0.742, 0.7421) || 挂载数据: qa: 2 ) 
│       │       ├── 编写Dao --> ( 难度等级: [0.7421, 0.7422) || 挂载数据: 无 ) 
│       │       └── 编写Controller --> ( 难度等级: [0.7422, 0.7422) || 挂载数据: qa: 1 ) 
│       ├── Cache --> ( 难度等级: [0.7422, 0.7433) || 挂载数据: 无 ) 
│       │   ├── 关于Cache --> ( 难度等级: [0.7422, 0.7424) || 挂载数据: 无 ) 
│       │   │   ├── Cache的组件和概念 --> ( 难度等级: [0.7422, 0.7423) || 挂载数据: 无 ) 
│       │   │   ├── Cache的单体应用 --> ( 难度等级: [0.7423, 0.7423) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用专有的Cache服务器 --> ( 难度等级: [0.7423, 0.7424) || 挂载数据: 无 ) 
│       │   │   └── 使用一二级缓存服务器 --> ( 难度等级: [0.7424, 0.7424) || 挂载数据: 无 ) 
│       │   ├── Spring Boot Cache --> ( 难度等级: [0.7424, 0.7426) || 挂载数据: 无 ) 
│       │   ├── 注释驱动缓存 --> ( 难度等级: [0.7426, 0.7428) || 挂载数据: 无 ) 
│       │   │   ├── @Cacheable --> ( 难度等级: [0.7426, 0.7426) || 挂载数据: qa: 1 ) 
│       │   │   ├── Key生成器 --> ( 难度等级: [0.7426, 0.7427) || 挂载数据: qa: 5 ) 
│       │   │   ├── @CachePut --> ( 难度等级: [0.7427, 0.7427) || 挂载数据: 无 ) 
│       │   │   ├── @CacheEvict --> ( 难度等级: [0.7427, 0.7427) || 挂载数据: 无 ) 
│       │   │   ├── @Caching --> ( 难度等级: [0.7427, 0.7427) || 挂载数据: 无 ) 
│       │   │   └── @CacheConfig --> ( 难度等级: [0.7427, 0.7428) || 挂载数据: 无 ) 
│       │   ├── 使用Redis Cache --> ( 难度等级: [0.7428, 0.743) || 挂载数据: 无 ) 
│       │   │   ├── 集成Redis缓存 --> ( 难度等级: [0.7428, 0.7428) || 挂载数据: 无 ) 
│       │   │   ├── 禁止缓存 --> ( 难度等级: [0.7428, 0.7429) || 挂载数据: 无 ) 
│       │   │   └── 定制缓存 --> ( 难度等级: [0.7429, 0.743) || 挂载数据: 无 ) 
│       │   ├── Redis缓存原理 --> ( 难度等级: [0.743, 0.7431) || 挂载数据: 无 ) 
│       │   └── 实现Redis两级缓存 --> ( 难度等级: [0.7431, 0.7433) || 挂载数据: 无 ) 
│       │       ├── 实现TwoLevelCacheManager --> ( 难度等级: [0.7431, 0.7432) || 挂载数据: 无 ) 
│       │       ├── 创建RedisAndLocalCache --> ( 难度等级: [0.7432, 0.7432) || 挂载数据: 无 ) 
│       │       ├── 缓存同步说明 --> ( 难度等级: [0.7432, 0.7433) || 挂载数据: 无 ) 
│       │       └── 将代码组合在一起 --> ( 难度等级: [0.7433, 0.7433) || 挂载数据: 无 ) 
│       ├── Spring Session --> ( 难度等级: [0.7433, 0.7444) || 挂载数据: 无 ) 
│       │   ├── 水平扩展实现 --> ( 难度等级: [0.7433, 0.7439) || 挂载数据: qa: 2 ) 
│       │   └── Spring Session --> ( 难度等级: [0.7439, 0.7444) || 挂载数据: 无 ) 
│       │       ├── Spring Session介绍 --> ( 难度等级: [0.7439, 0.7442) || 挂载数据: qa: 10 ) 
│       │       └── Nginx+Redis --> ( 难度等级: [0.7442, 0.7444) || 挂载数据: qa: 9 ) 
│       ├── 监控Spring Boot应用 --> ( 难度等级: [0.7444, 0.7456) || 挂载数据: 无 ) 
│       │   ├── 安装Acutator --> ( 难度等级: [0.7444, 0.7446) || 挂载数据: 无 ) 
│       │   ├── HTTP跟踪 --> ( 难度等级: [0.7446, 0.7447) || 挂载数据: 无 ) 
│       │   ├── 日志查看 --> ( 难度等级: [0.7447, 0.7448) || 挂载数据: qa: 2 ) 
│       │   ├── 线程栈信息 --> ( 难度等级: [0.7448, 0.7449) || 挂载数据: 无 ) 
│       │   ├── 内存信息 --> ( 难度等级: [0.7449, 0.7451) || 挂载数据: 无 ) 
│       │   ├── 查看URL映射 --> ( 难度等级: [0.7451, 0.7452) || 挂载数据: 无 ) 
│       │   ├── 查看Spring容器管理的Bean --> ( 难度等级: [0.7452, 0.7453) || 挂载数据: 无 ) 
│       │   ├── 其他监控 --> ( 难度等级: [0.7453, 0.7454) || 挂载数据: 无 ) 
│       │   └── 编写自己的监控信息 --> ( 难度等级: [0.7454, 0.7456) || 挂载数据: 无 ) 
│       │       ├── 编写HealthIndicator --> ( 难度等级: [0.7454, 0.7455) || 挂载数据: qa: 10 ) 
│       │       └── 自定义监控 --> ( 难度等级: [0.7455, 0.7456) || 挂载数据: qa: 2 ) 
│       ├── Web开发 --> ( 难度等级: [0.7456, 0.7467) || 挂载数据: 无 ) 
│       │   ├── Web基础 --> ( 难度等级: [0.7456, 0.7456) || 挂载数据: qa: 10 ) 
│       │   ├── Servlet入门 --> ( 难度等级: [0.7456, 0.7457) || 挂载数据: qa: 6 ) 
│       │   ├── Servlet开发 --> ( 难度等级: [0.7457, 0.7458) || 挂载数据: 无 ) 
│       │   ├── Servlet进阶 --> ( 难度等级: [0.7458, 0.7459) || 挂载数据: qa: 1 ) 
│       │   ├── JSP开发 --> ( 难度等级: [0.7459, 0.7459) || 挂载数据: qa: 10 ) 
│       │   ├── MVC开发 --> ( 难度等级: [0.7459, 0.746) || 挂载数据: 无 ) 
│       │   ├── MVC高级开发 --> ( 难度等级: [0.746, 0.7461) || 挂载数据: 无 ) 
│       │   ├── 使用Filter --> ( 难度等级: [0.7461, 0.7461) || 挂载数据: qa: 2 ) 
│       │   │   └── 修改响应 --> ( 难度等级: [0.7461, 0.7461) || 挂载数据: 无 ) 
│       │   ├── 使用Listener --> ( 难度等级: [0.7461, 0.7462) || 挂载数据: 无 ) 
│       │   ├── 部署 --> ( 难度等级: [0.7462, 0.7463) || 挂载数据: 无 ) 
│       │   ├── 集成Filter --> ( 难度等级: [0.7463, 0.7464) || 挂载数据: 无 ) 
│       │   ├── 使用Interceptor --> ( 难度等级: [0.7464, 0.7464) || 挂载数据: 无 ) 
│       │   ├── 处理CORS --> ( 难度等级: [0.7464, 0.7465) || 挂载数据: 无 ) 
│       │   ├── 异步处理 --> ( 难度等级: [0.7465, 0.7466) || 挂载数据: 无 ) 
│       │   └── 使用WebSocket --> ( 难度等级: [0.7466, 0.7467) || 挂载数据: qa: 3 ) 
│       ├── Spring开发 --> ( 难度等级: [0.7467, 0.7478) || 挂载数据: 无 ) 
│       │   ├── IoC容器 --> ( 难度等级: [0.7467, 0.7472) || 挂载数据: 无 ) 
│       │   │   ├── IoC原理 --> ( 难度等级: [0.7467, 0.7468) || 挂载数据: 无 ) 
│       │   │   ├── 使用Annotation配置 --> ( 难度等级: [0.7468, 0.7469) || 挂载数据: 无 ) 
│       │   │   ├── 定制Bean --> ( 难度等级: [0.7469, 0.747) || 挂载数据: 无 ) 
│       │   │   ├── 使用Resource --> ( 难度等级: [0.747, 0.7471) || 挂载数据: qa: 2 ) 
│       │   │   └── 注入配置 --> ( 难度等级: [0.7471, 0.7472) || 挂载数据: 无 ) 
│       │   └── 集成第三方组件 --> ( 难度等级: [0.7472, 0.7478) || 挂载数据: 无 ) 
│       │       ├── 集成JavaMail --> ( 难度等级: [0.7472, 0.7473) || 挂载数据: qa: 7 ) 
│       │       ├── 集成JMS --> ( 难度等级: [0.7473, 0.7473) || 挂载数据: 无 ) 
│       │       ├── 使用Scheduler --> ( 难度等级: [0.7473, 0.7474) || 挂载数据: qa: 1 ) 
│       │       ├── 集成JMX --> ( 难度等级: [0.7474, 0.7475) || 挂载数据: 无 ) 
│       │       ├── 集成Open API --> ( 难度等级: [0.7475, 0.7475) || 挂载数据: 无 ) 
│       │       ├── 访问Redis --> ( 难度等级: [0.7475, 0.7476) || 挂载数据: 无 ) 
│       │       ├── 集成Artemis --> ( 难度等级: [0.7476, 0.7477) || 挂载数据: qa: 3 ) 
│       │       ├── 集成RabbitMQ --> ( 难度等级: [0.7477, 0.7477) || 挂载数据: qa: 3 ) 
│       │       └── 集成Kafka --> ( 难度等级: [0.7477, 0.7478) || 挂载数据: 无 ) 
│       ├── Spring Boot开发 --> ( 难度等级: [0.7478, 0.7489) || 挂载数据: 无 ) 
│       │   ├── 使用开发者工具 --> ( 难度等级: [0.7478, 0.7479) || 挂载数据: qa: 1 ) 
│       │   ├── 打包Spring Boot应用 --> ( 难度等级: [0.7479, 0.7481) || 挂载数据: 无 ) 
│       │   ├── 使用Actuator --> ( 难度等级: [0.7481, 0.7482) || 挂载数据: 无 ) 
│       │   ├── 使用Profiles --> ( 难度等级: [0.7482, 0.7483) || 挂载数据: 无 ) 
│       │   ├── 使用Conditional --> ( 难度等级: [0.7483, 0.7485) || 挂载数据: 无 ) 
│       │   ├── 加载配置文件 --> ( 难度等级: [0.7485, 0.7486) || 挂载数据: 无 ) 
│       │   ├── 禁用自动配置 --> ( 难度等级: [0.7486, 0.7488) || 挂载数据: 无 ) 
│       │   └── 添加Filter --> ( 难度等级: [0.7488, 0.7489) || 挂载数据: qa: 2 ) 
│       └── Spring Cloud开发 --> ( 难度等级: [0.7489, 0.75) || 挂载数据: qa: 2 ) 
└── 其他 --> ( 难度等级: [0.75, 1.0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0.75, 0.8333) || 挂载数据: qa: 10 ) 
    ├── 应用类问题 --> ( 难度等级: [0.8333, 0.9167) || 挂载数据: qa: 10 ) 
    └── 第三方包问题 --> ( 难度等级: [0.9167, 1.0) || 挂载数据: qa: 10 )