关于java: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。

请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越，但咱们并不要求您做到美中不足，因而请不要放心因为翻译上犯错——在大部分状况下，咱们的服务器曾经记录所有的翻译，因而您不用放心会因为您的失误受到无法挽回的毁坏。（改编自维基百科）

组织介绍

拜访咱们的主页。

资助咱们

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