Java无难事——详解Java编程核心思想与技术电子书

作者简介

内容简介

前言

第1章　Java初窥

1.1　Java的起源

1.2　Java能做什么

1.3　相关概念

1.3.1　JDK

1.3.2　Java家族的三个成员

1.3.3　Java 1、Java 2和Java 5

1.3.4　JRE

1.4　安装JDK

1.4.1　下载JDK 11（Java SE 11）

1.4.2　安装JDK

1.4.3　下载帮助文档

1.5　Java的特性

1.5.1　简单

1.5.2　面向对象

1.5.3　健壮

1.5.4　安全

1.5.5　结构中立

1.5.6　可移植

1.5.7　高性能

1.5.8　解释执行

1.5.9　平台无关

1.5.10　多线程

1.5.11　动态

1.6　Java跨平台的原理

1.6.1　Java源文件的编译过程

1.6.2　Java解释器运行机制

1.6.3　Java字节码的执行方式

1.6.4　理解JVM

1.7　第一个程序

1.7.1　了解JDK

1.7.2　编写第一个Java程序

1.8　扫清Java征途中的两块绊脚石

1.8.1　有用的PATH

1.8.2　难缠的CLASSPATH

1.9　交互式编程环境JShell

1.10　为Java程序打包

1.10.1　JAR文件

1.10.2　将字节码文件打包到JAR包中

1.10.3　将目录中所有文件打包到JAR文件中

1.10.4　清单文件

1.11　总结

1.12　实战练习

第2章　初识Java语言

2.1　标识符

2.2　数据类型

2.2.1　整数类型

2.2.2　浮点类型

2.2.3　字符（char）型

2.2.4　布尔（boolean）型

2.2.5　String类型

2.3　变量和字面常量

2.3.1　变量

2.3.2　字面常量

2.4　类型转换的奥秘

2.5　运算符

2.5.1　赋值运算符

2.5.2　自增和自减运算符

2.5.3　算术运算符

2.5.4　关系运算符

2.5.5　布尔运算符

2.5.6　位运算符

2.5.7　移位运算符

2.5.8　一元和二元运算符

2.5.9　三元运算符

2.5.10　优先级

2.6　表达式与语句

2.7　程序结构

2.7.1　分支语句

2.7.2　循环语句

2.8　数组

2.8.1　数组类型与声明数组

2.8.2　创建数组

2.8.3　使用数组

2.8.4　匿名数组

2.8.5　多维数组

2.8.6　数组的初始值和越界

2.9　分隔符

2.10　注释

2.10.1　传统注释

2.10.2　JavaDoc注释

2.11　Java中的关键字

2.12　总结

2.13　实战练习

第3章　进入对象的世界

3.1　面向对象思想

3.2　对象的状态和行为

3.2.1　对象都有一组固定的行为

3.2.2　注意思维习惯

3.3　面向对象编程的难点

3.4　Java的类与对象

3.5　字段（field）与方法

3.5.1　字段

3.5.2　方法

3.5.3　方法的参数与返回值

3.6　构造方法与new关键字

3.7　方法重载

3.8　特殊变量this

3.9　关键字static

3.9.1　静态字段

3.9.2　静态方法

3.9.3　static语句块

3.10　常量

3.11　枚举（enum）

3.11.1　原始的枚举实现

3.11.2　枚举类型

3.11.3　枚举值的比较

3.11.4　自定义枚举值

3.12　总结

3.13　实战练习

第4章　高级面向对象编程

4.1　继承

4.2　方法的覆盖（override）

4.3　多态（polymorphism）

4.3.1　何为多态

4.3.2　多态的实际应用

4.3.3　Java编译器如何实现多态

4.3.4　类型转换

4.3.5　协变返回类型

4.3.6　在构造方法中调用被覆盖的方法

4.4　特殊变量super

4.4.1　访问父类被子类覆盖的方法或隐藏的变量

4.4.2　调用父类构造方法

4.5　封装与private

4.6　对外发布的接口——public

4.7　再谈final

4.7.1　final类

4.7.2　final方法

4.7.3　final参数

4.8　对象的销毁

4.9　面向对象的四个基本特性

4.10　总结

4.11　实战练习

第5章　包和访问控制

5.1　在包中的类

5.2　导入类

5.3　静态导入

5.4　静态导入枚举类型

5.5　访问控制

5.5.1　类的访问说明符

5.5.2　类成员的访问说明符

5.6　总结

5.7　实战练习

第6章　抽象类与接口

6.1　抽象方法和抽象类

6.2　接口

6.3　接口中的数据成员

6.4　接口的继承与实现

6.5　接口的应用

6.6　深入接口——通信双方的协议

6.7　接口的默认方法和静态方法

6.7.1　默认方法

6.7.2　静态方法

6.8　接口的私有方法

6.9　总结

6.10　实战练习

第7章　内部类（Inner Class）

7.1　创建内部类

7.2　访问外部类

7.3　内部类与接口

7.4　局部内部类

7.5　匿名内部类

7.5.1　创建匿名内部类

7.5.2　匿名内部类的构造方法

7.6　静态内部类

7.7　内部类的继承与覆盖

7.7.1　内部类的继承

7.7.2　内部类的覆盖

7.8　内部类规则总结

7.9　回调与事件机制

7.9.1　回调（callback）

7.9.2　事件（event）

7.10　总结

7.11　实战练习

第8章　异常处理

8.1　什么是异常

8.2　捕获异常

8.3　使用finally进行清理

8.4　抛出异常与声明异常

8.5　RuntimeException

8.6　创建自己的异常体系结构

8.7　try-with-resources

8.7.1　自动关闭资源

8.7.2　声明多个资源

8.7.3　catch多个异常

8.7.4　使用更具包容性的类型检查重新抛出异常

8.8　总结

8.9　实战练习

第9章　深入字符串

9.1　String类

9.2　==运算符与equals方法

9.3　compareTo方法

9.4　字符串拼接

9.5　操作字符串

9.5.1　获取字符串的长度

9.5.2　查找字符或字符串

9.5.3　判断字符串的开始与结尾

9.5.4　获取指定索引位置的字符

9.5.5　截取子字符串

9.5.6　分割字符串

9.5.7　替换字符或字符串

9.5.8　合并字符串

9.5.9　重复字符串

9.5.10　大小写转换

9.5.11　去除字符串首尾空白

9.5.12　判断字符串是否为空

9.5.13　提取字符串的行流

9.5.14　与字节数组相互转换

9.6　StringBuffer类和StringBuilder类

9.7　格式化输出

9.7.1　格式说明符

9.7.2　参数索引

9.7.3　格式说明字符

9.7.4　宽度和精度

9.7.5　标志字符

9.7.6　生成格式化的String对象

9.8　正则表达式

9.8.1　正则表达式的优点

9.8.2　一切从模式开始

9.8.3　创建正则表达式

9.8.4　量词

9.8.5　String类的正则表达式方法

9.8.6　Pattern和Matcher

9.8.7　邮件地址验证

9.8.8　获取组匹配的内容

9.8.9　替换字符串

9.9　总结

9.10　实战练习

第10章　Java应用

10.1　再论引用类型

10.1.1　引用类型——数组

10.1.2　方法传参

10.2　操作数组

10.2.1　数组的复制

10.2.2　数组的排序

10.2.3　搜索数组中的元素

10.2.4　填充数组

10.3　基本数据类型与封装类

10.3.1　基本数据类型与封装类对象的互相转换

10.3.2　封装类对象与字符串的互相转换

10.3.3　基本数据类型与字符串的互相转换

10.3.4　自动装箱与拆箱

10.4　对象的克隆

10.5　国际化与本地化

10.5.1　Locale

10.5.2　资源包

10.5.3　消息格式化

10.6　总结

10.7　实战练习

第11章　泛型

11.1　为什么需要泛型

11.2　泛型与基本数据类型

11.3　泛型类中的数组

11.4　元组

11.5　泛型接口

11.5.1　一个简单的泛型接口

11.5.2　匿名内部类实现泛型接口

11.5.3　map机制的实现

11.6　泛型方法

11.6.1　简单的泛型方法

11.6.2　完善映射机制的实现

11.7　通配符类型

11.7.1　通配符的子类型限定

11.7.2　通配符的超类型限定

11.8　类型参数的限定

11.9　深入泛型机制

11.10　泛型的一些问题

11.10.1　接口的二次实现

11.10.2　方法重载

11.10.3　泛型类型的实例化

11.10.4　异常

11.11　使用泛型的限制

11.12　类型参数的命名约定

11.13　总结

11.14　实战练习

第12章　Lambda表达式

12.1　理解Lambda表达式

12.2　Lambda表达式的语法

12.3　函数式接口

12.4　内置函数式接口

12.5　方法引用

12.6　构造方法引用

12.7　数组引用

12.8　总结

12.9　实战练习

第13章　集合类

13.1　集合框架中的接口与实现类

13.1.1　集合框架中的接口

13.1.2　集合框架中的实现类

13.1.3　Collection类型的集合

13.1.4　Map类型的集合

13.2　迭代

13.2.1　Iterator接口

13.2.2　迭代器与“for each”循环

13.2.3　新增的forEach方法

13.2.4　ListIterator接口

13.2.5　迭代与回调

13.3　数据结构简介

13.3.1　链表

13.3.2　栈

13.3.3　队列

13.4　List

13.4.1　ArrayList

13.4.2　LinkedList

13.4.3　List集合类的性能

13.5　Set

13.5.1　HashSet

13.5.2　TreeSet

13.5.3　LinkedHashSet

13.5.4　Set集合类的性能

13.6　Queue

13.6.1　Queue接口

13.6.2　PriorityQueue类

13.6.3　Deque接口

13.7　Collections类

13.7.1　排序集合中的元素

13.7.2　获取最大和最小元素

13.7.3　在集合中搜索

13.7.4　获取包装器集合

13.8　再探Comparator接口

13.9　深入Map类型

13.9.1　Map接口

13.9.2　Map的工作原理

13.9.3　HashMap

13.9.4　TreeMap

13.9.5　LinkedHashMap

13.9.6　Map性能测试

13.10　遗留的集合

13.10.1　Enumeration接口

13.10.2　Vector类

13.10.3　Stack类

13.10.4　Hashtable类

13.10.5　Properties类

13.10.6　BitSet类

13.11　集合工厂方法

13.11.1　of方法

13.11.2　copyOf方法

13.12　总结

13.13　实战练习

第14章　Stream

14.1　什么是Stream

14.2　创建流

14.3　并行流与串行流

14.4　有序流和无序流

14.5　中间操作

14.5.1　筛选和截断

14.5.2　映射

14.5.3　排序

14.5.4　peek

14.6　终端操作

14.6.1　遍历

14.6.2　查找与匹配

14.6.3　最大/最小与计数

14.6.4　收集统计信息

14.6.5　reduce

14.6.6　collect

14.7　并行流的性能

14.8　总结

14.9　实战练习

第15章　Class类与反射API

15.1　Class<T>类

15.2　获取类型信息

15.2.1　获取方法和字段信息

15.2.2　获取基类和接口信息

15.2.3　获取枚举信息

15.2.4　获取泛型信息

15.2.5　获取注解信息

15.3　检测类型

15.4　使用Class和反射创建类的对象

15.5　使用反射调用对象的方法

15.6　使用反射修改对象的字段

15.7　依赖注入容器

15.8　动态代理

15.9　ClassLoader

15.9.1　类加载器的分类

15.9.2　类加载器的加载机制

15.9.3　自定义类加载器

15.10　适可而止

15.11　方法句柄

15.12　服务加载器

15.13　总结

15.14　实战练习

第16章　注解（Annotation）

16.1　预定义的注解

16.1.1　@Override

16.1.2　@Deprecated

16.1.3　@SuppressWarnings

16.1.4　@SafeVarargs

16.1.5　@FunctionalInterface

16.2　自定义注解

16.3　元注解

16.3.1　@Documented

16.3.2　@Retention

16.3.3　@Target

16.3.4　@Inherited

16.3.5　@Repeatable

16.4　注解与反射

16.5　编写注解处理器

16.5.1　依赖注入容器的注解实现

16.5.2　使用注解生成数据库表

16.6　总结

16.7　实战练习

第17章　多线程

17.1　基本概念

17.1.1　程序和进程

17.1.2　线程

17.2　Java对多线程的支持

17.3　Java线程

17.3.1　Thread类

17.3.2　创建任务

17.3.3　让步

17.3.4　休眠

17.3.5　优先级

17.3.6　加入一个线程

17.3.7　捕获线程的异常

17.3.8　后台线程

17.3.9　线程组

17.3.10　线程的状态

17.4　线程同步

17.4.1　错误地访问共享资源

17.4.2　同步语句块

17.4.3　同步方法

17.4.4　死锁

17.5　线程本地存储

17.5.1　使用ThreadLocal类

17.5.2　ThreadLocal的实现原理

17.6　生产者与消费者

17.7　线程的终止

17.7.1　取消一个任务

17.7.2　在阻塞中中止

17.7.3　注意清理

17.8　线程池

17.9　总结

17.10　实战练习

第18章　Java常用工具类

18.1　java.lang.Math类

18.2　随机数

18.2.1　Math.random方法

18.2.2　Random类

18.2.3　ThreadLocalRandom类

18.3　大数字运算

18.3.1　BigInteger

18.3.2　BigDecimal

18.4　日期时间工具

18.4.1　Date类

18.4.2　DateFormat类

18.4.3　SimpleDateFormat类

18.4.4　Calendar类

18.5　Java 8新增的日期/时间API

18.5.1　新的日期/时间类

18.5.2　构造日期/时间对象

18.5.3　格式化和解析日期/时间字符串

18.5.4　操作日历字段

18.5.5　计算时间间隔

18.5.6　使用Instant计算某项操作花费的时间

18.5.7　判断闰年

18.5.8　与Date和Calendar的相互转换

18.6　Optional类

18.6.1　创建Optional类的实例

18.6.2　判断Optional的值是否存在

18.6.3　获取Optional的值

18.6.4　过滤与映射

18.6.5　得到Stream对象

18.6.6　为什么要使用Optional

18.6.7　OptionalInt、OptionalLong和OptionalDouble

18.7　Base64编解码

18.8　Timer类

18.9　Runtime类与单例设计模式

18.10　总结

18.11　实战练习

第19章　Java I/O操作

19.1　File类

19.1.1　分隔符

19.1.2　创建文件夹

19.1.3　文件操作

19.1.4　搜索目录中的文件

19.1.5　移动文件

19.1.6　临时文件

19.2　流式I/O

19.3　输入输出流

19.3.1　InputStream

19.3.2　OutputStream

19.3.3　字节数组输入/输出流

19.3.4　文件输入/输出流

19.3.5　过滤流

19.3.6　缓冲的输入/输出流

19.3.7　数据输入/输出流

19.3.8　管道流

19.3.9　复制文件

19.4　Java I/O库的设计原则

19.5　Reader和Writer

19.6　InputStreamReader和OutputStreamWriter

19.7　字符集与中文乱码问题

19.7.1　字符集

19.7.2　对乱码产生过程的分析

19.7.3　Charset类

19.8　RandomAccessFile类

19.9　标准I/O

19.9.1　从标准输入中读取数据

19.9.2　Scanner

19.9.3　I/O重定向

19.10　对象序列化

19.10.1　使用对象流实现序列化

19.10.2　对象引用的序列化

19.10.3　序列化过滤器

19.10.4　定制序列化

19.10.5　替换对象

19.10.6　使用Externalizable接口定制序列化

19.10.7　序列化版本

19.11　NIO

19.11.1　缓冲区（Buffer）

19.11.2　通道（Channel）

19.11.3　使用通道复制文件

19.11.4　视图缓冲区

19.11.5　字节顺序

19.11.6　直接和非直接缓冲区

19.11.7　分散和聚集

19.11.8　字符缓冲区的问题

19.11.9　内存映射文件

19.11.10　对文件加锁

19.11.11　管道

19.12　Files类与Path接口

19.12.1　Path接口

19.12.2　读写文件

19.12.3　遍历目录

19.12.4　小结

19.13　异步文件通道

19.13.1　写入数据

19.13.2　读取数据

19.14　总结

19.15　实战练习

第20章　Java并发编程

20.1　Callable和Future接口

20.2　新的任务执行框架

20.2.1　Executor接口

20.2.2　ExecutorService接口

20.2.3　Executors工具类

20.2.4　ThreadFactory

20.2.5　ScheduledExecutorService

20.2.6　批量执行任务

20.2.7　CompletionService接口

20.2.8　ThreadPoolExecutor类

20.3　锁对象

20.3.1　Lock接口

20.3.2　重入互斥锁

20.3.3　读写锁

20.3.4　StampedLock

20.4　条件对象

20.5　同步工具类

20.5.1　CountDownLatch

20.5.2　CyclicBarrier

20.5.3　Semaphore

20.5.4　Exchanger

20.6　线程安全的集合

20.6.1　写时拷贝

20.6.2　阻塞队列

20.6.3　延迟队列

20.6.4　传输队列

20.6.5　ConcurrentHashMap

20.6.6　ConcurrentSkipListMap

20.7　Fork/Join框架

20.8　CompletableFuture

20.8.1　异步执行任务

20.8.2　构造异步任务链

20.8.3　结果转换

20.8.4　组合异步任务

20.8.5　任务链完成时的结果处理和异常处理

20.9　原子操作

20.9.1　AtomicInteger类

20.9.2　LongAdder

20.10　变量句柄

20.11　总结

20.12　实战练习

第21章　Eclipse开发工具

21.1　Eclipse简介

21.2　下载并安装

21.3　Eclipse开发环境介绍

21.4　配置Eclipse

21.4.1　配置JDK

21.4.2　配置字体

21.4.3　配置和使用快捷键

21.4.4　配置字符集

21.5　开发Java程序

21.6　调试代码

21.7　JUnit单元测试

21.8　导入现有的Eclipse项目

21.9　总结

21.10　实战练习

第22章　图形界面编程

22.1　AWT

22.1.1　第一个AWT应用程序

22.1.2　关闭窗口

22.1.3　向窗口内添加组件

22.2　布局管理器

22.2.1　BorderLayout

22.2.2　FlowLayout

22.2.3　GridLayout

22.2.4　CardLayout

22.2.5　GridBagLayout

22.2.6　组合多个布局管理器

22.3　事件模型

22.3.1　按钮点击事件的处理

22.3.2　事件监听器

22.3.3　观察者模式

22.4　Swing

22.4.1　基本的框架窗口

22.4.2　添加文本域和菜单栏

22.4.3　菜单功能

22.4.4　弹出菜单

22.5　Swing与并发

22.6　使用WindowBuilder快速开发图形界面程序

22.6.1　安装WindowBuilder

22.6.2　用户登录界面

22.6.3　注册事件监听器

22.7　总结

22.8　实战练习

第23章　Java网络编程

23.1　网络基础知识

23.1.1　计算机网络

23.1.2　IP地址

23.1.3　协议

23.1.4　网络的状况

23.1.5　网络异质性问题的解决

23.1.6　ISO/OSI七层参考模型

23.1.7　数据封装

23.1.8　TCP/IP模型

23.1.9　端口

23.1.10　套接字（Socket）

23.1.11　客户机/服务器模式

23.2　基于TCP的套接字编程

23.2.1　服务器程序

23.2.2　客户端程序

23.2.3　多线程的服务器程序

23.2.4　套接字超时

23.3　基于UDP的套接字编程

23.3.1　接收端

23.3.2　发送端

23.3.3　获取发送端的信息

23.4　非阻塞的套接字编程

23.4.1　SocketChannel

23.4.2　ServerSocketChannel

23.4.3　Selector

23.4.4　非阻塞的服务器程序

23.4.5　非阻塞的客户端程序

23.5　URL和URLConnection

23.5.1　URL类

23.5.2　URLConnection类

23.5.3　一个实用的下载程序

23.6　HTTP Client API

23.6.1　HttpClient

23.6.2　HttpRequest

23.6.3　HttpResponse

23.6.4　异步发送多个请求

23.6.5　启用HttpClient的日志记录功能

23.7　总结

23.8　实战练习

第24章　数据库访问

24.1　JDBC驱动程序的类型

24.1.1　JDBC-ODBC桥

24.1.2　部分本地API的Java驱动程序

24.1.3　JDBC网络纯Java驱动程序

24.1.4　本地协议的纯Java驱动程序

24.2　安装数据库

24.3　下载MySQL JDBC驱动

24.4　JDBC API

24.5　加载并注册数据库驱动

24.5.1　Driver接口

24.5.2　加载与注册JDBC驱动

24.5.3　服务加载

24.6　建立到数据库的连接

24.7　访问数据库

24.7.1　Statement

24.7.2　ResultSet

24.7.3　PreparedStatement

24.7.4　CallableStatement

24.7.5　元数据

24.8　事务处理

24.9　可滚动和可更新的结果集

24.9.1　可滚动的结果集

24.9.2　可更新的结果集

24.10　行集

24.10.1　行集的标准实现

24.10.2　行集的事件模型

24.10.3　CachedRowSet

24.11　JDBC数据源和连接池

24.12　总结

24.13　实战练习

第25章　Java平台模块系统

25.1　Java平台的模块

25.2　模块的物理结构

25.3　创建模块

25.4　模块依赖

25.5　导出包

25.6　可传递的模块与静态依赖

25.7　开放包

25.8　限定导出和开放

25.9　服务加载

25.10　未命名模块

25.11　自动模块

25.12　为什么要引入模块系统

25.13　总结

25.14　实战练习

后折页