ApacheCN Java 译文集 20211012 更新 java

Effective Java 中文第三版
- 1. 考虑使用静态工厂方法替代构造方法
- 2. 当构造方法参数过多时使用 builder 模式
- 3. 使用私有构造方法或枚类实现 Singleton 属性
- 4. 使用私有构造器执行非实例化
- 5. 依赖注入优于硬连接资源（hardwiring resources）
- 6. 避免创建不必要的对象
- 7. 消除过期的对象引用
- 8. 避免使用 Finalizer 和 Cleaner 机制
- 9. 使用 try-with-resources 语句替代 try-finally 语句
- 10. 重写 equals 方法时遵守通用约定
- 11. 重写 equals 方法时同时也要重写 hashcode 方法
- 12. 始终重写 toString 方法
- 13. 谨慎地重写 clone 方法
- 14. 考虑实现 Comparable 接口
- 15. 使类和成员的可访问性最小化
- 16. 在公共类中使用访问方法而不是公共属性
- 17. 最小化可变性
- 18. 组合优于继承
- 19. 要么设计继承并提供文档说明，要么禁用继承
- 20. 接口优于抽象类
- 21. 为后代设计接口
- 22. 接口仅用来定义类型
- 23. 类层次结构优于标签类
- 24. 支持使用静态成员类而不是非静态类
- 25. 将源文件限制为单个顶级类
- 26. 不要使用原始类型
- 27. 消除非检查警告
- 28. 列表优于数组
- 29. 优先考虑泛型
- 30. 优先使用泛型方法
- 31. 使用限定通配符来增加 API 的灵活性
- 32. 合理地结合泛型和可变参数
- 33. 优先考虑类型安全的异构容器
- 34. 使用枚举类型替代整型常量
- 35. 使用实例属性替代序数
- 36. 使用 EnumSet 替代位属性
- 37. 使用 EnumMap 替代序数索引
- 38. 使用接口模拟可扩展的枚举
- 39. 注解优于命名模式
- 40. 始终使用 Override 注解
- 41. 使用标记接口定义类型
- 42. lambda 表达式优于匿名类
- 43. 方法引用优于 lambda 表达式
- 44. 优先使用标准的函数式接口
- 45. 明智审慎地使用 Stream
- 46. 优先考虑流中无副作用的函数
- 47. 优先使用 Collection 而不是 Stream 来作为方法的返回类型
- 48. 谨慎使用流并行
- 49. 检查参数有效性
- 50. 必要时进行防御性拷贝
- 51. 仔细设计方法签名
- 52. 明智审慎地使用重载
- 53. 明智审慎地使用可变参数
- 54. 返回空的数组或集合，不要返回 null
- 55. 明智审慎地返回 Optional
- 56. 为所有已公开的 API 元素编写文档注释
- 57. 最小化局部变量的作用域
- 58. for-each 循环优于传统 for 循环
- 59. 了解并使用库
- 60. 若需要精确答案就应避免使用 float 和 double 类型
- 61. 基本数据类型优于包装类
- 62. 当使用其他类型更合适时应避免使用字符串
- 63. 当心字符串连接引起的性能问题
- 64. 通过接口引用对象
- 65. 接口优于反射
- 66. 明智审慎地本地方法
- 67. 明智审慎地进行优化
- 68. 遵守被广泛认可的命名约定
- 69. 只针对异常的情况下才使用异常
- 70. 对可恢复的情况使用受检异常，对编程错误使用运行时异常
- 71. 避免不必要的使用受检异常
- 72. 优先使用标准的异常
- 73. 抛出与抽象对应的异常
- 74. 每个方法抛出的异常都需要创建文档
- 75. 在细节消息中包含失败一捕获信息
- 76. 保持失败原子性
- 77. 不要忽略异常
- 78. 同步访问共享的可变数据
- 79. 避免过度同步
- 80. executor 、task 和 stream 优先于线程
- 81. 并发工具优于 wait 和 notify
- 82. 文档应包含线程安全属性
- 83. 明智审慎的使用延迟初始化
- 84. 不要依赖线程调度器
- 85. 优先选择 Java 序列化的替代方案
- 86. 非常谨慎地实现 Serializable
- 87. 考虑使用自定义的序列化形式
- 88. 保护性的编写 readObject 方法
- 89. 对于实例控制，枚举类型优于 readResolve
- 90. 考虑用序列化代理代替序列化实例
Thinking in Java (Java 编程思想)
- 写在前面的话
- 引言
- 第1章对象入门
  - 1.1 抽象的进步
  - 1.2 对象的接口
  - 1.3 实现方案的隐藏
  - 1.4 方案的重复使用
  - 1.5 继承：重新使用接口
  - 1.6 多态对象的互换使用
  - 1.7 对象的创建和存在时间
  - 1.8 异常控制：解决错误
  - 1.9 多线程
  - 1.10 永久性
  - 1.11 Java和因特网
  - 1.12 分析和设计
  - 1.13 Java还是C++
- 第2章一切都是对象
  - 2.1 用引用操纵对象
  - 2.2 所有对象都必须创建
  - 2.3 绝对不要清除对象
  - 2.4 新建数据类型：类
  - 2.5 方法、参数和返回值
  - 2.6 构建Java程序
  - 2.7 我们的第一个Java程序
  - 2.8 注释和嵌入文档
  - 2.9 编码样式
  - 2.10 总结
  - 2.11 练习
- 第3章控制程序流程
  - 3.1 使用Java运算符
  - 3.2 执行控制
  - 3.3 总结
  - 3.4 练习
- 第4章初始化和清除
  - 4.1 用构造器自动初始化
  - 4.2 方法重载
  - 4.3 清除：收尾和垃圾收集
  - 4.4 成员初始化
  - 4.5 数组初始化
  - 4.6 总结
  - 4.7 练习
- 第5章隐藏实现过程
  - 5.1 包：库单元
  - 5.2 Java访问指示符
  - 5.3 接口与实现
  - 5.4 类访问
  - 5.5 总结
  - 5.6 练习
- 第6章类复用
  - 6.1 組合的语法
  - 6.2 继承的语法
  - 6.3 组合与继承的结合
  - 6.4 到底选择组合还是继承
  - 6.5 protected
  - 6.6 累积开发
  - 6.7 向上转换
  - 6.8 final关键字
  - 6.9 初始化和类装载
  - 6.10 总结
  - 6.11 练习
- 第7章多态性
  - 7.1 向上转换
  - 7.2 深入理解
  - 7.3 覆盖与重载
  - 7.4 抽象类和方法
  - 7.5 接口
  - 7.6 内部类
  - 7.7 构造器和多态性
  - 7.8 通过继承进行设计
  - 7.9 总结
  - 7.10 练习
- 第8章对象的容纳
  - 8.1 数组
  - 8.2 集合
  - 8.3 枚举器（迭代器）
  - 8.4 集合的类型
  - 8.5 排序
  - 8.6 通用集合库
  - 8.7 新集合
  - 8.8 总结
  - 8.9 练习
- 第9章异常差错控制
  - 9.1 基本异常
  - 9.2 异常的捕获
  - 9.3 标准Java异常
  - 9.4 创建自己的异常
  - 9.5 异常的限制
  - 9.6 用finally清除
  - 9.7 构造器
  - 9.8 异常匹配
  - 9.9 总结
  - 9.10 练习
- 第10章 Java IO系统
  - 10.1 输入和输出
  - 10.2 增添属性和有用的接口
  - 10.3 本身的缺陷：RandomAccessFile
  - 10.4 File类
  - 10.5 IO流的典型应用
  - 10.6 StreamTokenizer
  - 10.7 Java 1.1的IO流
  - 10.8 压缩
  - 10.9 对象序列化
  - 10.10 总结
  - 10.11 练习
- 第11章运行期类型识别
  - 11.1 对RTTI的需要
  - 11.2 RTTI语法
  - 11.3 反射：运行期类信息
  - 11.4 总结
  - 11.5 练习
- 第12章传递和返回对象
  - 12.1 传递引用
  - 12.2 制作本地副本
  - 12.3 克隆的控制
  - 12.4 只读类
  - 12.5 总结
  - 12.6 练习
- 第13章创建窗口和程序片
  - 13.1 为何要用AWT？
  - 13.2 基本程序片
  - 13.3 制作按钮
  - 13.4 捕获事件
  - 13.5 文本字段
  - 13.6 文本区域
  - 13.7 标签
  - 13.8 复选框
  - 13.9 单选钮
  - 13.10 下拉列表
  - 13.11 列表框
  - 13.12 布局的控制
  - 13.13 action的替代品
  - 13.14 程序片的局限
  - 13.15 视窗化应用
  - 13.16 新型AWT
  - 13.17 Java 1.1用户接口API
  - 13.18 可视编程和Beans
  - 13.19 Swing入门（注释⑦）
  - 13.20 总结
  - 13.21 练习
- 第14章多线程
  - 14.1 反应灵敏的用户界面
  - 14.2 共享有限的资源
  - 14.3 堵塞
  - 14.4 优先级
  - 14.5 回顾runnable
  - 14.6 总结
  - 14.7 练习
- 第15章网络编程
  - 15.1 机器的标识
  - 15.10 练习
  - 15.2 套接字
  - 15.3 服务多个客户
  - 15.4 数据报
  - 15.5 一个Web应用
  - 15.6 Java与CGI的沟通
  - 15.7 用JDBC连接数据库
  - 15.8 远程方法
  - 15.9 总结
- 第16章设计模式
  - 16.1 模式的概念
  - 16.2 观察器模式
  - 16.3 模拟垃圾回收站
  - 16.4 改进设计
  - 16.5 抽象的应用
  - 16.6 多重分发
  - 16.7 访问器模式
  - 16.8 RTTI真的有害吗
  - 16.9 总结
  - 16.10 练习
- 第17章项目
  - 17.1 文字处理
  - 17.2 方法查找工具
  - 17.3 复杂性理论
  - 17.4 总结
  - 17.5 练习
- 附录A 使用非JAVA代码
- 附录B 对比C++和Java
- 附录C Java编程规则
- 附录D 性能
- 附录E 关于垃圾收集的一些话
- 附录F 推荐读物
Java 8 简明教程
- Java 8 简明教程
- Java 8 数据流教程
- Java 8 Nashorn 教程
- Java 8 并发教程：线程和执行器
- Java 8 并发教程：同步和锁
- Java 8 并发教程：原子变量和 ConcurrentMap
- Java 8 API 示例：字符串、数值、算术和文件
- 在 Java 8 中避免 Null 检查
- 使用 Intellij IDEA 解决 Java 8 的数据流问题
- 在 Nashron 中使用 Backbone.js
Java 设计模式最佳实践
- 零、前言
- 一、从面向对象到函数式编程
- 二、创建型模式
- 三、行为模式
- 四、结构模式
- 五、函数式模式
- 六、让我们开始反应式吧
- 七、反应式设计模式
- 八、应用架构的发展趋势
- 九、Java 最佳实践
Java 编程问题
- 零、前言
- 一、字符串、数字和数学
- 二、对象、不变性和switch表达式
- 三、使用日期和时间
- 四、类型推断
- 五、数组、集合和数据结构
- 六、Java I/O 路径、文件、缓冲区、扫描和格式化
- 七、Java 反射类、接口、构造器、方法和字段
- 八、函数式编程-基础和设计模式
- 九、函数式编程——深入研究
- 十、并发-线程池、可调用对象和同步器
- 十一、并发-深入探索
- 十二、Optional
- 十三、HTTP 客户端和 WebSocket API
Java 项目大全
- 零、前言
- 一、Java11 入门
- 二、第一个真正的 Java 程序-排序名称
- 三、优化排序代码
- 四、Mastermind-创造游戏
- 五、扩展游戏-跑得并行，跑得更快
- 六、使我们的游戏专业化-将其作为 Web 应用
- 七、使用 REST 构建商业 Web 应用
- 八、扩展我们的电子商务应用
- 九、使用反应式编程构建会计应用
Java 12 编程学习手册
- 零、前言
- 第 1 节：Java 编程概述
  - 一、Java12 入门
  - 二、Java 面向对象编程（OOP）
  - 三、Java 基础
- 第 2 节：Java 的构建块
  - 四、异常处理
  - 五、字符串、输入/输出和文件
  - 六、数据结构、泛型和流行工具
  - 七、Java 标准和外部库
  - 八、多线程和并发处理
  - 九、JVM 结构与垃圾收集
  - 十、管理数据库中的数据
  - 十一、网络编程
  - 十二、Java GUI 编程
- 第 3 节：高级 Java
  - 十三、函数式程序设计
  - 十四、Java 标准流
  - 十五、反应式程序设计
  - 十六、微服务
  - 十七、Java 微基准线束
  - 十八、编写高质量代码的最佳实践
  - 十九、Java 新特性
- 二十、答案
精通 Java 11
- 零、前言
- 一、Java11 环境
- 二、探索 Java11
- 三、Java11 基础
- 四、用 Java11 构建模块化应用
- 五、将应用迁移到 Java11
- 六、试用 Java Shell
- 七、利用默认的 G1 垃圾收集器
- 八、JMH 的微基准应用
- 九、利用进程 API
- 十、细粒度栈跟踪
- 十一、新工具和工具增强功能
- 十二、并发性增强
- 十三、安全增强功能
- 十四、命令行标志
- 十五、Java 平台的其他增强功能
- 十六、未来发展方向
- 十七、为 Java 平台做贡献
- 十八、答案
Java 自动化测试初学者实用指南
- 零、前言
- 一、Java 中的第一个编程步骤
- 二、了解 Java 中的类、对象及其用法
- 三、在 Java 中处理字符串及其函数
- 四、Java 程序–循环和条件的构建块
- 五、您需要了解的关于接口和继承的所有信息
- 六、了解有关数组的所有信息
- 七、了解 Java11 中的日期类和构造器
- 八、super和this关键字和异常在 Java 中的重要性
- 九、理解集合框架
- 十、final关键字、包和修饰符的重要性
Java9 高性能应用
- 零、序言
- 一、学习 Java 9 底层性能改进
- 二、提高生产率和加速应用的工具
- 三、多线程和反应式编程
- 四、微服务
- 五、利用新 API 改进代码
- 六、测验答案
Java11 秘籍
- 零、序言
- 一、安装和对 Java11 的窥探
- 二、面向对象编程的快速通道-类和接口
- 三、模块化编程
- 四、走向函数式
- 五、流和管道
- 六、数据库编程
- 七、并发和多线程编程
- 八、更好地管理操作系统进程
- 九、使用 springboot 的 restfulWeb 服务
- 十、网络
- 十一、内存管理和调试
- 十二、使用 JShell 的读取求值打印循环（REPL）
- 十三、使用新的日期和时间 API
- 十四、测试
- 十五、Java10 和 Java11 的编程新方法
- 十六、将 JavaFX 用于 GUI 编程
精通 JUnit5 软件测试
- 零、序言
- 一、软件质量与 Java 测试回顾
- 二、JUnit5 有什么新功能
- 三、JUnit5 标准测试
- 四、使用高级 JUnit 特性简化测试
- 五、JUnit5 与外部框架的集成
- 六、从需求到测试用例
- 七、测试管理
Java 测试驱动开发
- 零、前言
- 一、为什么我应该关心测试驱动的开发？
- 二、工具、框架和环境
- 三、红绿重构——从失败到成功，直到完美
- 四、单元测试——关注你做了什么，而不是已经做了什么
- 五、设计——如果它不可测试，那么它就设计得不好
- 六、模拟——删除外部依赖项
- 七、TDD 和函数式编程——完美匹配
- 八、BDD——与整个团队合作
- 九、重构遗留代码——使其再次年轻
- 十、功能切换——将部分完成的功能部署到生产环境
- 十一、把它们放在一起
- 十二、通过实现连续交付利用 TDD
Java 云原生应用
- 零、前言
- 一、云原生简介
- 二、编写第一个云原生应用
- 三、设计您的云原生应用
- 四、扩展云原生应用
- 五、测试云原生应用
- 六、云原生应用部署
- 七、云原生应用运行时
- 八、平台部署——AWS
- 九、平台部署——Azure
- 十、集成为服务
- 十一、API 设计最佳实践
- 十二、数字转型
Java 代码面试完全指南
- 零、序言
- 第一节：面试的非技术部分
  - 一、从何处开始以及如何准备面试
  - 二、大公司的面试是什么样的
  - 三、常见非技术性问题及解答
  - 四、如何处理失败
  - 五、如何应对编码挑战
- 第二节：概念
  - 六、面向对象编程
  - 七、算法的大 O 分析
  - 八、递归与动态规划
  - 九、位操作
- 第三节：算法和数据结构
  - 十、数组和字符串
  - 十一、链表和地图
  - 十二、栈和队列
  - 十三、树与图
  - 十四、排序
  - 十五、数学与谜题
- 第四节：奖励——并发和函数式编程
  - 十六、并发
  - 十七、函数式编程
  - 十八、单元测试
  - 十九、系统可扩展性
Java 基础知识
- 零、序言
- 一、Java 简介
- 二、变量、数据类型和运算符
- 三、控制流程
- 四、面向对象编程
- 五、深入 OOP
- 六、数据结构、数组和字符串
- 七、Java 集合框架和泛型
- 八、Java 高级数据结构
- 九、异常处理
- 十、附录
JavaFX 基础知识
- 零、序言
- 一、JavaFX 8 入门
- 二、JavaFX 8 基础和创建自定义 UI
- 三、开发 JavaFX 桌面和 Web 应用
- 四、为 Android 开发 JavaFX 应用
- 五、为 iOS 开发 JavaFX 应用
- 六、在 Raspberry Pi 上运行 JavaFX 应用
- 七、使用 JavaFX 监控 Arduino
- 八、使用 JavaFX 的交互式 Leap Motion 应用
- 九、成为 JavaFX 大师
Java 编程入门
- 零、前言
- 一、计算机上的 Java 虚拟机（JVM）
- 二、Java 语言基础
- 三、您的开发环境设置
- 四、您的第一个 Java 项目
- 五、Java 语言元素和类型
- 六、接口、类和对象构造
- 七、包和可访问性（可见性）
- 八、面向对象设计（OOD）原则
- 九、运算符、表达式和语句
- 十、控制流语句
- 十一、JVM 进程和垃圾收集
- 十二、Java 标准和外部库
- 十三、Java 集合
- 十四、管理集合和数组
- 十五、管理对象、字符串、时间和随机数
- 十六、数据库编程
- 十七、Lambda 表达式与函数式编程
- 十八、流和管道
- 十六、反应式系统
Java7 并发秘籍
- 零、序言
- 一、线程管理
- 二、线程基本同步
- 三、线程同步工具
- 四、线程执行器
- 五、Fork/Join 框架
- 六、并发
- 七、自定义并发类
- 八、测试并发应用
Java9 和 JShell
- 零、序言
- 一、JShell——Java 9 的读取-求值-打印循环
- 二、通过 Java 9 JShell 将现实世界的对象转换为 UML 图
- 三、类与实例
- 四、数据封装
- 五、可变类和不可变类
- 六、继承、抽象、扩展和特化
- 七、成员继承与多态性
- 八、使用接口的契约式编程
- 九、使用接口的高级契约式编程
- 十、使用泛型实现代码重用的最大化
- 十一、高级多态
- 十二、面向对象、函数式编程和 Lambda 表达式
- 十三、Java 9 中的模块化
- 十四、练习答案
面向初学者的 Java 编程
- 零、前言
- 一、Java 入门
- 二、理解类型化变量
- 三、分支
- 四、数据结构
- 五、函数
- 六、Java 面向对象建模
- 七、更加面向对象的 Java
- 八、有用的 Java 类
- 九、文件输入和输出
- 十、基本图形用户界面开发
- 十一、XML
精通 Java8 并发编程
- 零、序言
- 一、第一步——并发设计原则
- 二、管理大量线程——执行器
- 三、最大程度利用执行器
- 四、从任务获取数据——Runnable接口和Future接口
- 四、分阶段运行任务——相位器类
- 六、优化分治的解决方案——Fork/Join 框架
- 七、用并行流处理海量数据集——映射和归约模型
- 八、用并行流处理海量数据集——映射和收集模型
- 九、深入研究并发数据结构和同步工具
- 十、片段整合和备选方案实现
- 十一、测试和监控并发应用
Java7 新特性秘籍
- 零、序言
- 一、Java 语言的改进
- 二、使用路径定位文件和目录
- 三、获取文件和目录信息
- 四、管理文件和目录
- 五、管理文件系统
- 六、Java 7 中的流式 IO
- 七、图形用户界面改进
- 八、事件处理
- 九、数据库、安全和系统增强
- 十、并发处理
- 十一、杂项
Java9 编程蓝图
- 零、前言
- 一、引言
- 二、用 Java 管理进程
- 三、清理重复的文件
- 四、日期计算器
- 五、Sunago——社交媒体聚合器
- 六、Sunago——安卓端
- 七、使用邮件过滤器管理电子邮件和垃圾邮件
- 八、使用 PhotoBeans 进行照片管理
- 九、使用 Monumentum 记笔记
- 十、无服务器 Java
- 十一、DeskDroid——Android 手机的桌面客户端
- 十二、下一步是什么？
Java SE7 编程学习指南
- 零、序言
- 一、Java 入门
- 二、Java 数据类型及其使用
- 三、决策结构
- 四、使用数组和集合
- 五、循环结构
- 六、类、构造器和方法
- 七、继承与多态性
- 八、处理应用中的异常
- 九、Java 应用
- 十、测试你的知识——答案
Java Lambda 学习指南
- 零、序言
- 一、引言
- 二、Lambda 简介
- 三、深入 Lambda
- 四、字节码
Java 网络编程学习指南
- 零、序言
- 一、网络编程入门
- 二、网络寻址
- 三、NIO 对网络的支持
- 四、客户端/服务器开发
- 五、对等网络
- 六、UDP 和多播
- 七、网络可扩展性
- 八、网络安全
- 九、网络互操作性
Java8 反应式编程学习指南
- 零、序言
- 一、反应式编程简介
- 二、使用 Java 8 的函数结构
- 三、创建和连接可观察对象、观察者和主体
- 四、转换、过滤和积累您的数据
- 五、组合器、条件和错误处理
- 六、使用调度器获得并发性和并行性
- 七、测试 RxJava 应用
- 八、资源管理与 RxJava 扩展