ApacheCN Java 译文集 20211012 更新

• 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 扩展

下载

Docker

docker pull apachecn0/apachecn-java-zh
docker run -tid -p <port>:80 apachecn0/apachecn-java-zh
# 访问 http://localhost:{port} 

PYPI

pip install apachecn-java-zh
apachecn-java-zh <port>
# 访问 http://localhost:{port} 

NPM

npm install -g apachecn-java-zh
apachecn-java-zh <port>
# 访问 http://localhost:{port} 

贡献指南

本项目需要校对，欢迎大家提交 Pull Request。

请您勇敢地去翻译和改进翻译。虽然我们追求卓越，但我们并不要求您做到十全十美，因此请不要担心因为翻译上犯错——在大部分情况下，我们的服务器已经记录所有的翻译，因此您不必担心会因为您的失误遭到无法挽回的破坏。（改编自维基百科）

组织介绍

访问我们的主页。

赞助我们

通过平台自带的打赏功能，或点击这里。