《疯狂Java讲义》（第5版） 李刚

第1章 Java语言概述与开发环境

1.1 Java语言的发展简史

JDK1.0 :

Sun在1996年年初发布了JDK 1.0，该版本包括两部分：运行环境（即JRE）和开发环境（即JDK）。运行环境包括核心API、集成API、用户界面API、发布技术、Java虚拟机（JVM）5个部分；开发环境包括编译Java程序的编译器（即javac命令）。

JDK1.1 ：

Sun在1997年2月18日发布了JDK 1.1，该版本增加了JIT（即时编译）编译器。

JDK 1.2 :

1998年12月Sun发布了JDK 1.2，伴随JDK 1.2一同发布的还有JSP/Servlet、EJB等规范，并将Java分成了J2EE、J2SE和J2ME三个版本。JDK 1.2还把它的API分成了三大类：核心API、可选API、特殊API。

JDK1.4 ：

2002年2月，Sun发布了JDK 1.4。

JDK1.5 ：

2004年10月，Sun发布了JDK 1.5，将JDK 1.5改名为Java SE 5.0，J2EE、J2ME也相应地改名为Java EE和Java ME。JDK 1.5增加了诸如泛型、增强的for语句、可变数量的形参、注释（Annotations）、自动拆箱和装箱等功能；推出了EJB 3.0规范、推出了自己的MVC框架规范：JSF。

JDK 1.6 :

2006年12月，Sun公司发布了JDK 1.6（也被称为Java SE 6）。2009年4月20日，Oracle收购Sun.

JDK 1.7 :

2011年7月28日，Oracle发布Java SE 7，该版本引入了二进制整数、支持字符串的switch语句、菱形语法、多异常捕捉、自动关闭资源的try语句等新特性。

JDK 1.8:

2014年3月18日，Oracle公司发布了Java SE 8，该版本带来了全新的Lambda表达式、流式编程等大量新特性

JDK1.9 ：

2017年9月22日，Oracle公司发布了Java SE 9，这次版本升级强化了Java的模块化系统，而且采用了更高效、更智能的G1垃圾回收器，并在核心类库上进行了大量更新。

JDK1.10：

2018年3月如约发布Java 10

JDK1.11 ：

2018年9月如约发布Java 11。

1.2 Java程序运行机制

Java语言具有解释型语言、编译型语言的特征，因为Java程序要经过先编译、后解释两个步骤。

1.2.1 高级语言的运行机制

计算机高级语言按程序的执行方式可以分为编译型和解释型两种。

1.2.2 Java程序的运行机制和JVM

Java程序的执行过程必须经过先编译、后解释两个步骤，如图1.1所示。

Java语言里负责解释执行字节码文件的是Java虚拟机，即JVM（Java Virtual Machine）。JVM是Java程序跨平台的关键部分，只要为不同平台实现了相应的虚拟机，编译后的Java字节码就可以在该平台上运行。JVM是一个抽象的计算机，和实际的计算机一样，它具有指令集并使用不同的存储区域。它负责执行指令，还要管理数据、内存和寄存器。

Oracle公司制定的Java虚拟机规范在技术上规定了JVM的统一标准，具体定义了JVM的如下细节： 指令集、寄存器、 类文件的格式、 栈、 垃圾回收堆、存储区，制定这些规范的目的是为了提供统一的标准，最终实现Java程序的平台无关性。

1.3 开发Java的准备

下载和安装Java 11的JDK、设置PATH环境变量

1.4 第一个Java程序

1.5 Java程序的基本规则

Java程序必须以类（class）的形式存在，类（class）是Java程序的最小程序单位。

Java程序源文件的扩展名必须是.java，不能是其他文件扩展名。

在通常情况下，Java程序源文件的主文件名可以是任意的。如果Java程序源代码里定义了一个public类，则该源文件的主文件名必须与该public类（也就是该类定义使用了public关键字修饰）的类名相同。

通常有如下建议：一个Java源文件通常只定义一个类，不同的类使用不同的源文件定义。 让Java源文件的主文件名与该源文件中定义的public类同名。

1.6 交互式工具：jshell

1.7 Java 11改进的垃圾回收器

第2章 理解面向对象

Java完全支持面向对象的三种基本特征：继承、封装和多态。Java语言完全以对象为中心，Java程序的最小程序单位是类，整个Java程序由一个一个的类组成。

面向对象的方式由OOA（面向对象分析）、OOD（面向对象设计）和OOP（面向对象编程）组成，其中，OOA和OOD的结构需要使用一种方式来描述并记录，目前业界统一采用UML（统一建模语言）来描述并记录OOA和OOD的结果。

2.1 面向对象

程序的三种基本结构：顺序结构、选择结构、循环结构。

面向对象程序设计方法的基本思想是使用类、对象、继承、封装、消息等基本概念进行程序设计。

成员变量（状态数据）+方法（行为）= 类定义

2.1.4 面向对象的基本特征

面向对象方法具有三个基本特征：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

封装：指将对象的实现细节隐藏起来，然后通过一些公用方法来暴露该对象的功能；

继承：是面向对象实现软件复用的重要手段，当子类继承父类后，子类作为特殊的父类，将直接获得父类的属性和方法；

多态：指子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征，这意味着同一个类型的对象在执行同一个方法时，可能表现出多种行为特征。

除此之外，抽象也是面向对象的重要部分，抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。

2.2 UML（统一建模语言）介绍

UML图大致上可分为静态图和动态图两种，UML 2.0的组成如图2.9所示:

2.3 Java的面向对象特征

2.3.1 一切都是对象

在Java语言中，除8个基本数据类型值之外，一切都是对象，而对象就是面向对象程序设计的中心。Java通过为对象定义成员变量来描述对象的状态；Java通过为对象定义方法来描述对象的行为。

2.3.2 类和对象

具有相同或相似性质的一组对象的抽象就是类，类是对一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的个体，也称为实例（instance）。对象的抽象化是类，类的具体化就是对象，也可以说类的实例是对象。

类通常有如下两种主要的结构关系:

一般→特殊关系：这种关系就是典型的继承关系，Java语言使用extends关键字来表示这种继承关系，Java的子类是一种特殊的父类。因此，这种一般→特殊的关系其实是一种“is a”关系。

整体→部分结构关系：也被称为组装结构，这是典型的组合关系，Java语言通过在一个类里保存另一个对象的引用来实现这种组合关系。因此，这种整体→部分结构关系其实是一种“has a”关系。

第3章 数据类型和运算符

Java语言是一门强类型语言，强类型的含义：① 所有的变量必须先声明、后使用；② 指定类型的变量只能接受类型与之匹配的值。

3.1 注释

Java语言的注释共有3种类型：单行注释（使用 //）、多行注释(使用 /*  …… */)、 文档注释(使用 /**  …… */)。

3.2 标识符和关键字

Java语言里的分隔符： 分号（;）、花括号（{}）、方括号（[]）、圆括号（()）、空格、圆点（.）。

标识符就是用于给程序中变量、类、方法命名的符号。Java语言的标识符必须以字母、下画线（_）、美元符（$）开头，后面可以跟任意数目的字母、数字、下画线（_）和美元符（$）。Java语言是区分大小写的，从Java 9开始，不允许使用单独的下画线（_）作为标识符。

使用标识符时，需要注意如下规则：

➢ 标识符可以由字母、数字、下画线（_）和美元符（$）组成，其中数字不能打头。

➢ 标识符不能是Java关键字和保留字，但可以包含关键字和保留字。

➢ 标识符不能包含空格。

➢ 标识符只能包含美元符（$），不能包含@、#等其他特殊字符。

Java的所有关键字都是小写的，TRUE、FALSE和NULL都不是Java关键字。

不仅如此，Java还提供了三个特殊的直接量（literal）：true、false和null；Java语言的标识符也不能使用这三个特殊的直接量。从Java 10开始引入的var并不是关键字，它相当于一个可变的类型名（后面会详述），因此var依然可作为标识符。

3.3 数据类型分类

声明变量的语法：type varName [=初始值]；

Java语言支持的类型分为两类：基本类型（Primitive Type）和引用类型（Reference Type）。

基本类型：包括boolean类型和数值类型。数值类型有整数类型和浮点类型。整数类型包括byte、short、int、long、char，浮点类型包括float和double。

引用类型：包括类、接口和数组类型，还有一种特殊的null类型。

3.4 基本数据类型

Java只包含这8种基本数据类型，字符串不是基本数据类型，字符串是一个类，也就是一个引用数据类型。

Java中整数值有4种表示方式：十进制、二进制（Java7 开始支持）、八进制、十六进制，其中二进制的整数以0b或0B开头；八进制的整数以0开头；十六进制的整数以0x或者0X开头，其中10～15分别以a～f（此处的a～f不区分大小写）来表示。

所有数字在计算机底层都是以二进制形式存在的，原码是直接将一个数值换算成二进制数。但计算机以补码的形式保存所有的整数。补码的计算规则：正数的补码和原码完全相同，负数的补码是其反码加1；反码是对原码按位取反，只是最高位（符号位）保持不变。

字符型值有三种表示形式：

➢ 直接通过单个字符来指定字符型值，例如'A'、'9'和'0'等。

➢ 通过转义字符表示特殊字符型值，例如'\n'、'\t'等。

➢ 直接使用Unicode值来表示字符型值，格式是'\uXXXX'，其中XXXX代表一个十六进制的整数。

Java语言中常用的转义字符如表3.2所示。

char类型的值也可直接作为整型值来使用。

Java语言中的单引号、双引号和反斜线都有特殊的用途，如果一个字符串中包含了这些特殊字符，则应该使用转义字符的表示形式。例如，在Java程序中表示一个绝对路径："c:\codes"，但这种写法得不到期望的结果，因为Java会把反斜线当成转义字符，所以应该写成这种形式："c:\\codes"，只有同时写两个反斜线，Java才会把第一个反斜线当成转义字符，和后一个反斜线组成真正的反斜线。

Java的浮点数遵循IEEE 754标准，采用二进制数据的科学计数法来表示浮点数，对于float型数值，第1位是符号位，接下来8位表示指数，再接下来的23位表示尾数；对于double类型数值，第1位也是符号位，接下来的11位表示指数，再接下来的52位表示尾数。

Java 7引入了一个新功能：程序员可以在数值中使用下画线，不管是整型数值，还是浮点型数值，都可以自由地使用下画线。

boolean类型的值或变量主要用做旗标来进行流程控制，主要有： if条件控制语句、 while循环控制语句、do while循环控制语句、for循环控制语句、三目运算符（？：）。

Java 10开始支持使用var定义局部变量：var相当于一个动态类型，使用var定义的局部变量的类型由编译器自动推断—定义变量时分配了什么类型的初始值，那该变量就是什么类型。因此，使用var定义局部变量时，必须在定义局部变量的同时指定初始值，否则编译器无法推断该变量的类型。

3.5 基本类型的类型转换

Java中类型转换分为：自动类型转换、强制类型转换。

强制类型转换的语法格式是：(targetType)value，强制类型转换的运算符是圆括号（()）。

当一个算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。Java定义了如下的自动提升规则。➢ 所有的byte类型、short类型和char类型将被提升到int类型。➢ 整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型。操作数的等级排列如图3.10所示，位于箭头右边类型的等级高于位于箭头左边类型的等级。

3.6 直接量

直接量（literal value，也被直译为字面值）是指在程序中通过源代码直接给出的值，例如在int a=5;这行代码中，为变量a所分配的初始值5就是一个直接量。

并不是所有的数据类型都可以指定直接量，能指定直接量的通常只有三种类型：基本类型、字符串类型和null类型。对于null类型的直接量的值只有null一个。

关于字符串直接量有一点需要指出，当程序第一次使用某个字符串直接量时，Java会使用常量池（constantpool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java会直接使用常量池中的字符串直接量。

常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括关于类、方法、接口中的常量，也包括字符串直接量。

3.7 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

Java语言中的运算符可分为如下几种：

➢ 算术运算符（+   -    *    /     %）

➢ 赋值运算符( = )

➢ 比较运算符(>  >=  <  <=  !=   ==)

➢ 逻辑运算符(&&  &  ||  |  !  ^)

➢ 位运算符( |   ~    ^    <<   >>    >>>)

➢ 类型相关运算符

赋值运算符可与算术运算符、位移运算符结合，扩展成功能更加强大的运算符。扩展后的赋值运算符如下。+=    -=    *=    /=     %=     &=     |=   ^=    <<=    >>=     >>>= 

三目运算符只有一个  ？：

第4章 流程控制与数组

4.1 顺序结构

4.2 分支结构

Java提供了两种常见的分支控制结构：if语句和switch语句。

switch语句由一个控制表达式和多个case标签组成，和if语句不同的是，switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型，枚举类型和java.lang.String类型（从Java 7才允许），不能是boolean类型。

switch语句的语法格式:

Java 11编译器做了一些改进，如果开发者忘记了case块后面的break语句，Java 11编译器会生成警告：“[fallthrough]可能无法实现case”。这个警告以前需要为javac指定-X：fallthrough选项才能显示出来。

4.3 循环结构

while循环的语法格式如下：

do while循环的语法格式如下：

for循环的基本语法格式如下：

4.4 控制循环结构

Java提供了continue和break来控制循环结构。除此之外，return可以结束整个方法，当然也就结束了一次循环。

break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束该循环，开始执行循环之后的代码。break语句不仅可以结束其所在的循环，还可以直接结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。Java中的标签就是一个紧跟着英文冒号（:）的标识符。与其他语言不同的是，Java中的标签只有放在循环语句之前才有作用。

continue只是忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环；而break则是完全终止循环本身。与break类似的是，continue后也可以紧跟一个标签，用于直接跳过标签所标识循环的当次循环的剩下语句，重新开始下一次循环。

return关键字并不是专门用于结束循环的，return的功能是结束一个方法。

4.5 数组类型

一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。

数组也是一种数据类型，它本身是一种引用类型。

Java语言支持两种语法格式来定义数组：

Java语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

数组的初始化有如下两种方式。

➢ 静态初始化：初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度。

➢ 动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。

从Java 5之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合。foreach循环的语法格式如下：

Java提供的Arrays类里包含的一些static修饰的方法可以直接操作数组。

第5章 面向对象（上）

5.1 类和对象

类可以当成一种自定义类型，可以使用类来定义变量，这种类型的变量统称为引用变量。

类是某一批对象的抽象，可以把类理解成某种概念；对象才是一个具体存在的实体。Java语言是面向对象的程序设计语言，类和对象是面向对象的核心。Java语言提供了对创建类和创建对象简单的语法支持。

Java语言里定义类的简单语法如下：

在上面的语法格式中，修饰符可以是public、final、abstract，或者完全省略这三个修饰符，类名只要是一个合法的标识符即可，建议Java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。

对一个类定义而言，可以包含三种最常见的成员：构造器、成员变量和方法，static修饰的成员不能访问没有static修饰的成员。成员变量用于定义该类或该类的实例所包含的状态数据，方法则用于定义该类或该类的实例的行为特征或者功能实现。构造器用于构造该类的实例，Java语言通过new关键字来调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此，Java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。

定义成员变量的语法格式如下：

➢ 修饰符：修饰符可以省略，也可以是public、protected、private、static、final，其中public、protected、private三个最多只能出现其中之一，可以与static、final组合起来修饰成员变量。

➢ 类型：类型可以是Java语言允许的任何数据类型，包括基本类型和现在介绍的引用类型。

➢ 成员变量名：成员变量名只要是一个合法的标识符即可，建议成员变量名应该由一个或多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。

➢ 默认值：定义成员变量还可以指定一个可选的默认值。

定义方法的语法格式如下：

➢ 修饰符：修饰符可以省略，也可以是public、protected、private、static、final、abstract，其中public、protected、private三个最多只能出现其中之一；abstract和final最多只能出现其中之一，它们可以与static组合起来修饰方法。

➢ 方法返回值类型：返回值类型可以是Java语言允许的任何数据类型，包括基本类型和引用类型；如果声明了方法返回值类型，则方法体内必须有一个有效的return语句，该语句返回一个变量或一个表达式，这个变量或者表达式的类型必须与此处声明的类型匹配。除此之外，如果一个方法没有返回值，则必须使用void来声明没有返回值。

➢ 方法名：方法名的命名规则与成员变量的命名规则基本相同，但由于方法用于描述该类或该类的实例的行为特征或功能实现，因此通常建议方法名以英文动词开头。

➢ 形参列表：形参列表用于定义该方法可以接受的参数，形参列表由零组到多组“参数类型 形参名”组合而成，多组参数之间以英文逗号（,）隔开，形参类型和形参名之间以英文空格隔开。一旦在定义方法时指定了形参列表，则调用该方法时必须传入对应的参数值——谁调用方法，谁负责为形参赋值。

定义构造器的语法格式如下：

➢ 修饰符：修饰符可以省略，也可以是public、protected、private其中之一。

➢ 构造器名：构造器名必须和类名相同。

➢ 形参列表：和定义方法形参列表的格式完全相同

创建对象的根本途径是构造器，通过new关键字来调用某个类的构造器即可创建这个类的实例。

创建对象之后，接下来即可使用该对象了，Java的对象大致有如下作用：

➢ 访问对象的实例变量

➢ 调用对象的方法。

有这样一行代码：Person p=new Person();  这行代码创建了一个Person实例，也被称为Person对象，这个Person对象被赋给p变量。在这行代码中实际产生了两个东西：一个是p变量，一个是Person对象。

Java提供了一个this关键字，this关键字总是指向调用该方法的对象。

根据this出现位置的不同，this作为对象的默认引用有两种情形：

➢ 构造器中引用该构造器正在初始化的对象。

➢ 在方法中引用调用该方法的对象。

this关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。

5.2 方法详解

Java语言里，方法不能独立存在，方法必须属于类或对象。一旦将一个方法定义在某个类的类体内，如果这个方法使用了static修饰，则这个方法属于这个类，否则这个方法属于这个类的实例。

Java里方法的参数传递方式只有一种：值传递。所谓值传递，就是将实际参数值的副本（复制品）传入方法内，而参数本身不会受到任何影响。

从JDK 1.5之后，Java允许定义形参个数可变的参数，从而允许为方法指定数量不确定的形参。如果在定义方法时，在最后一个形参的类型后增加三点（...），则表明该形参可以接受多个参数值，多个参数值被当成数组传入。

注意：个数可变的形参只能处于形参列表的最后。一个方法中最多只能包含一个个数可变的形参。个数可变的形参本质就是一个数组类型的形参，因此调用包含个数可变形参的方法时，该个数可变的形参既可以传入多个参数，也可以传入一个数组。

一个方法体内调用它自身，被称为方法递归。只要一个方法的方法体实现中再次调用了方法本身，就是递归方法。递归一定要向已知方向递归。

如果同一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则被称为方法重载。方法重载的要求就是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。

5.3 成员变量和局部变量

成员变量指的是在类里定义的变量，也就是前面所介绍的field；局部变量指的是在方法里定义的变量。变量名称建议第一个单词首字母小写，后面每个单词首字母大写。Java程序中的变量划分如图5.9所示。

成员变量无须显式初始化，只要为一个类定义了类变量或实例变量，系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化。

局部变量除形参之外，都必须显式初始化。也就是说，必须先给方法局部变量和代码块局部变量指定初始值，否则不可以访问它们。

当系统加载类或创建该类的实例时，系统自动为成员变量分配内存空间，并在分配内存空间后，自动为成员变量指定初始值。

局部变量定义后，必须经过显式初始化后才能使用，系统不会为局部变量执行初始化。这意味着定义局部变量后，系统并未为这个变量分配内存空间，直到等到程序为这个变量赋初始值时，系统才会为局部变量分配内存，并将初始值保存到这块内存中。与成员变量不同，局部变量不属于任何类或实例，因此它总是保存在其所在方法的栈内存中。如果局部变量是基本类型的变量，则直接把这个变量的值保存在该变量对应的内存中；如果局部变量是一个引用类型的变量，则这个变量里存放的是地址，通过该地址引用到该变量实际引用的对象或数组。栈内存中的变量无须系统垃圾回收，往往随方法或代码块的运行结束而结束。

5.4 隐藏和封装

封装实际上有两个方面的含义：把该隐藏的隐藏起来，把该暴露的暴露出来。这两个方面都需要通过使用Java提供的访问控制符来实现。

Java提供了3个访问控制符：private、protected和public，分别代表了3个访问控制级别，另外还有一个不加任何访问控制符的访问控制级别，提供了4个访问控制级别。Java的访问控制级别由小到大如图5.14所示：

关于访问控制符的使用，存在如下几条基本原则。

➢ 类里的绝大部分成员变量都应该使用private修饰，只有一些static修饰的、类似全局变量的成员变量，才可能考虑使用public修饰。除此之外，有些方法只用于辅助实现该类的其他方法，这些方法被称为工具方法，工具方法也应该使用private修饰。

➢ 如果某个类主要用做其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

➢ 希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通过使用public修饰，从而允许在其他地方创建该类的实例。因为外部类通常都希望被其他类自由使用，所以大部分外部类都使用public修饰。

package语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，即只能包含一条package语句，该源文件中可以定义多个类，则这些类将全部位于该包下。如果没有显式指定package语句，则处于默认包下。

import可以向某个Java文件中导入指定包层次下某个类或全部类，import语句应该出现在package语句（如果有的话）之后、类定义之前。

JDK 1.5以后更是增加了一种静态导入的语法，它用于导入指定类的某个静态成员变量、方法或全部的静态成员变量、方法。静态导入使用import static语句，静态导入也有两种语法，分别用于导入指定类的单个静态成员变量、方法和全部静态成员变量、方法

Java的核心类都放在java包以及其子包下，Java扩展的许多类都放在javax包以及其子包下。

下面几个包是Java语言中的常用包：

➢ java.lang：这个包下包含了Java语言的核心类，如String、Math、System和Thread类等，使用这个包下的类无须使用import语句导入，系统会自动导入这个包下的所有类。

➢ java.util：这个包下包含了Java的大量工具类/接口和集合框架类/接口，例如Arrays和List、Set等。

➢ java.net：这个包下包含了一些Java网络编程相关的类/接口。

➢ java.io：这个包下包含了一些Java输入/输出编程相关的类/接口。

➢ java.text：这个包下包含了一些Java格式化相关的类。

➢ java.sql：这个包下包含了Java进行JDBC数据库编程的相关类/接口。

➢ java.awt：这个包下包含了抽象窗口工具集的相关类/接口，这些类主要用于构建图形用户界面（GUI）程序。

➢ java.swing：这个包下包含了Swing图形用户界面编程的相关类/接口，这些类可用于构建平台无关的GUI程序。

5.5 深入构造器

构造器最大的用处就是在创建对象时执行初始化。

同一个类里具有多个构造器，多个构造器的形参列表不同，即被称为构造器重载。

使用this调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用this调用重载的构造器时，系统会根据this后括号里的实参来调用形参列表与之对应的构造器。

5.6 类的继承

Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类被称为父类，有的也称其为基类、超类。父类和子类的关系，是一种一般和特殊的关系。

注意：子类只能从被扩展的父类获得成员变量、方法和内部类（包括内部接口、枚举），不能获得构造器和初始化块。

如果定义一个Java类时并未显式指定这个类的直接父类，则这个类默认扩展java.lang.Object类。因此，java.lang.Object类是所有类的父类，要么是其直接父类，要么是其间接父类。因此所有的Java对象都可调用java.lang.Object类所定义的实例方法。

子类包含与父类同名方法的现象被称为方法重写（Override），也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。

方法的重写要遵循“两同两小一大”规则，“两同”即方法名相同、形参列表相同；“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。尤其需要指出的是，覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个是类方法，一个是实例方法。

当子类覆盖了父类方法后，子类的对象将无法访问父类中被覆盖的方法，但可以在子类方法中调用父类中被覆盖的方法。如果需要在子类方法中调用父类中被覆盖的方法，则可以使用super（被覆盖的是实例方法）或者父类类名（被覆盖的是类方法）作为调用者来调用父类中被覆盖的方法。

如果父类方法具有private访问权限，则该方法对其子类是隐藏的，因此其子类无法访问该方法，也就是无法重写该方法。如果子类中定义了一个与父类private方法具有相同的方法名、相同的形参列表、相同的返回值类型的方法，依然不是重写，只是在子类中重新定义了一个新方法。

重载主要发生在同一个类的多个同名方法之间，而重写发生在子类和父类的同名方法之间。

super是Java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。

5.7 多态

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态（Polymorphism）。

相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。与方法不同的是，对象的实例变量则不具备多态性。

instanceof运算符的前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类（也可以是接口，可以把接口理解成一种特殊的类），它用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是，则返回true，否则返回false。

在使用instanceof运算符时需要注意：instanceof运算符前面操作数的编译时类型要么与后面的类相同，要么与后面的类具有父子继承关系，否则会引起编译错误。

5.8 继承与组合

继承是实现类复用的重要手段，但继承带来了一个最大的坏处：破坏封装。相比之下，组合也是实现类复用的重要方式，而采用组合方式来实现类复用则能提供更好的封装性。

子类扩展父类时，子类可以从父类继承得到成员变量和方法，如果访问权限允许，子类可以直接访问父类的成员变量和方法，相当于子类可以直接复用父类的成员变量和方法。

为了保证父类有良好的封装性，不会被子类随意改变，设计父类通常应该遵循如下规则。

➢ 尽量隐藏父类的内部数据。尽量把父类的所有成员变量都设置成private访问类型，不要让子类直接访问父类的成员变量。

➢ 不要让子类可以随意访问、修改父类的方法。父类中那些仅为辅助其他的工具方法，应该使用private访问控制符修饰，让子类无法访问该方法；如果父类中的方法需要被外部类调用，则必须以public修饰，但又不希望子类重写该方法，可以使用final修饰符（该修饰符后面会有更详细的介绍）来修饰该方法；如果希望父类的某个方法被子类重写，但不希望被其他类自由访问，则可以使用protected来修饰该方法。

➢ 尽量不要在父类构造器中调用将要被子类重写的方法。

如果想把某些类设置成最终类，即不能被当成父类，则可以使用final修饰这个类，例如JDK提供的java.lang.String类和java.lang.System类。除此之外，使用private修饰这个类的所有构造器，从而保证子类无法调用该类的构造器，也就无法继承该类。对于把所有的构造器都使用private修饰的父类而言，可另外提供一个静态方法，用于创建该类的实例。

如果需要复用一个类，除把这个类当成基类来继承之外，还可以把该类当成另一个类的组合成分，从而允许新类直接复用该类的public方法。

5.9 初始化块

一个类里可以有多个初始化块，相同类型的初始化块之间有顺序：前面定义的初始化块先执行，后面定义的初始化块后执行。

在 Java 语言中，当实例化对象时，对象所在类的所有成员变量首先要进行初始化，只有当所有类成员完成初始化后，才会调用对象所在类的构造函数创建象。

初始化一般遵循3个原则：

• 静态对象（变量）优先于非静态对象（变量）初始化，静态对象（变量）只初始化一次，而非静态对象（变量）可能会初始化多次；
• 父类优先于子类进行初始化；
• 按照成员变量的定义顺序进行初始化。 即使变量定义散布于方法定义之中，它们依然在任何方法（包括构造函数）被调用之前先初始化；

加载顺序

• 父类（静态变量、静态语句块）
• 子类（静态变量、静态语句块）
• 父类（实例变量、普通语句块）
• 父类（构造函数）
• 子类（实例变量、普通语句块）
• 子类（构造函数）

第6章 面向对象（下）

6.1 包装类

JDK 1.5提供了自动装箱（Autoboxing）和自动拆箱（AutoUnboxing）功能。

包装类还可实现基本类型变量和字符串之间的转换。

把字符串类型的值转换为基本类型的值有两种方式。

➢ 利用包装类提供的parseXxx(String s)静态方法（除Character之外的所有包装类都提供了该方法。

➢ 利用包装类提供的valueOf(String s)静态方法。

String类也提供了多个重载valueOf()方法，用于将基本类型变量转换成字符串。

Java 7增强了包装类的功能，Java 7为所有的包装类都提供了一个静态的compare（xxx val1，xxx val2）方法，这样开发者就可以通过包装类提供的compare（xxx val1，xxx val2）方法来比较两个基本类型值的大小，包括比较两个boolean类型值，两个boolean类型值进行比较时，true>false。

6.2 处理对象

Object类提供的toString()方法总是返回该对象实现类的“类名+@+hashCode”值，这个返回值并不能真正实现“自我描述”的功能，因此如果用户需要自定义类能实现“自我描述”的功能，就必须重写Object类的toString()方法。

Java程序中测试两个变量是否相等有两种方式：一种是利用==运算符，另一种是利用equals()方法。当使用==来判断两个变量是否相等时，如果两个变量是基本类型变量，且都是数值类型（不一定要求数据类型严格相同），则只要两个变量的值相等，就将返回true。但对于两个引用类型变量，只有它们指向同一个对象时，==判断才会返回true。==不可用于比较类型上没有父子关系的两个对象。

6.3 类成员

在Java类里只能包含成员变量、方法、构造器、初始化块、内部类（包括接口、枚举）5种成员。

6.4 final修饰符

对于final修饰的成员变量而言，一旦有了初始值，就不能被重新赋值，如果既没有在定义成员变量时指定初始值，也没有在初始化块、构造器中为成员变量指定初始值，那么这些成员变量的值将一直是系统默认分配的0、'\u0000'、false或null，这些成员变量也就完全失去了存在的意义。因此Java语法规定：final修饰的成员变量必须由程序员显式地指定初始值。

归纳起来，final修饰的类变量、实例变量能指定初始值的地方如下：

➢ 类变量：必须在静态初始化块中指定初始值或声明该类变量时指定初始值，而且只能在两个地方的其中之一指定。

➢ 实例变量：必须在非静态初始化块、声明该实例变量或构造器中指定初始值，而且只能在三个地方的其中之一指定。

系统不会对局部变量进行初始化，局部变量必须由程序员显式初始化。因此使用final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值。如果final修饰的局部变量在定义时没有指定默认值，则可以在后面代码中对该final变量赋初始值，但只能一次，不能重复赋值；如果final修饰的局部变量在定义时已经指定默认值，则后面代码中不能再对该变量赋值。final修饰的形参因为形参在调用该方法时，由系统根据传入的参数来完成初始化，因此使用final修饰的形参不能被赋值。

当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。但对于引用类型变量而言，它保存的仅仅是一个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。

对一个final变量来说，不管它是类变量、实例变量，还是局部变量，只要该变量满足三个条件，这个final变量就不再是一个变量，而是相当于一个直接量。➢ 使用final修饰符修饰。➢ 在定义该final变量时指定了初始值。➢ 该初始值可以在编译时就被确定下来。

注意：final修饰符的一个重要用途就是定义“宏变量”。当定义final变量时就为该变量指定了初始值，而且该初始值可以在编译时就确定下来，那么这个final变量本质上就是一个“宏变量”，编译器会把程序中所有用到该变量的地方直接替换成该变量的值。

final修饰的方法不可被重写。

final修饰的类不可以有子类，例如java.lang.Math类就是一个final类，它不可以有子类。

不可变（immutable）类的意思是创建该类的实例后，该实例的实例变量是不可改变的。Java提供的8个包装类和java.lang.String类都是不可变类，当创建它们的实例后，其实例的实例变量不可改变。

如果需要创建自定义的不可变类，可遵守如下规则。

➢ 使用private和final修饰符来修饰该类的成员变量。

➢ 提供带参数的构造器（或返回该实例的类方法），用于根据传入参数来初始化类里的成员变量。

➢ 仅为该类成员变量提供getter方法，不要为该类的成员变量提供setter方法，因为普通方法无法修改final修饰的成员变量。

➢ 如果有必要，重写Object类的hashCode()和equals()方法（关于重写hashCode()的步骤可参考8.3.1节）。equals()方法根据关键成员变量来作为两个对象是否相等的标准，除此之外，还应该保证两个用equals()方法判断为相等的对象的hashCode()也相等。

6.5 抽象类

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。

抽象方法和抽象类的规则如下：

➢ 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。

➢ 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。

➢ 抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。

➢ 含有抽象方法的类（包括直接定义了一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类。

定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号即可。

定义抽象类只需在普通类上增加abstract修饰符即可。甚至一个普通类（没有包含抽象方法的类）增加abstract修饰符后也将变成抽象类。

当使用abstract修饰类时，表明这个类只能被继承；当使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。而final修饰的类不能被继承，final修饰的方法不能被重写。因此final和abstract永远不能同时使用。

注意：abstract不能用于修饰成员变量，不能用于修饰局部变量，即没有抽象变量、没有抽象成员变量等说法；abstract也不能用于修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器。

6.6 Java 9改进的接口

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行得更彻底，则可以提炼出一种更加特殊的“抽象类”—接口（interface）。

Java 8对接口进行了改进，允许在接口中定义默认方法和类方法，默认方法和类方法都可以提供方法实现，Java 9为接口增加了一种私有方法，私有方法也可提供方法实现。

接口定义使用interface关键字，接口定义的基本语法如下：

➢ 修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限访问控制符。

➢ 接口名应与类名采用相同的命名规则

➢ 一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量（只能是静态常量）、方法（只能是抽象实例方法、类方法、默认方法或私有方法）、内部类（包括内部接口、枚举）定义。

接口的继承和类继承不一样，接口完全支持多继承，即一个接口可以有多个直接父接口。和类继承相似，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法、常量。一个接口继承多个父接口时，多个父接口排在extends关键字之后，多个父接口之间以英文逗号（,）隔开。

接口主要有如下用途：➢ 定义变量，也可用于进行强制类型转换。➢ 调用接口中定义的常量。➢ 被其他类实现。

一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所做的补充。类实现接口的语法格式如下：

接口与抽象类异同点：

接口和抽象类很像，它们都具有如下特征（同）：

➢ 接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。

➢ 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

接口和抽象类在用法上也存在如下差别：

➢ 接口里只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现；抽象类则可以包含普通方法。

➢ 接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。

➢ 接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

➢ 接口里不能包含初始化块；但抽象类则完全可以包含初始化块。

➢ 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口。

➢ 接口是一种规范，抽象类是模板模式。

6.7 内部类

Java从JDK 1.1开始引入内部类，内部类主要有如下作用：

➢ 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。

➢ 内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，同一个类的成员之间可以互相访问。但外部类不能访问内部类的实现细节，例如内部类的成员变量。

➢ 匿名内部类适合用于创建那些仅需要一次使用的类。

从语法角度来看，定义内部类与定义外部类的语法大致相同，内部类除需要定义在其他类里面之外，还存在如下两点区别：

➢ 内部类比外部类可以多使用三个修饰符：private、protected、static—外部类不可以使用这三个修饰符。

➢ 非静态内部类不能拥有静态成员。

6.7.1 非静态内部类

内部类都被作为成员内部类定义，而不是作为局部内部类。成员内部类是一种与成员变量、方法、构造器和初始化块相似的类成员；局部内部类和匿名内部类则不是类成员。

成员内部类分为两种：静态内部类和非静态内部类，使用static修饰的成员内部类是静态内部类，没有使用static修饰的成员内部类是非静态内部类。

成员内部类（包括静态内部类、非静态内部类）的class文件总是这种形式：OuterClass$InnerClass.class。

当在非静态内部类的方法内访问某个变量时，系统优先在该方法内查找是否存在该名字的局部变量，如果存在就使用该变量；如果不存在，则到该方法所在的内部类中查找是否存在该名字的成员变量，如果存在则使用该成员变量；如果不存在，则到该内部类所在的外部类中查找是否存在该名字的成员变量，如果存在则使用该成员变量；如果依然不存在，系统将出现编译错误：提示找不到该变量。因此，如果外部类成员变量、内部类成员变量与内部类里方法的局部变量同名，则可通过使用this、外部类类名.this作为限定来区分。

非静态内部类的成员可以访问外部类的实例成员，但反过来就不成立了。如果外部类需要访问非静态内部类的实例成员，则必须显式创建非静态内部类对象来调用访问其实例成员。

根据静态成员不能访问非静态成员的规则，外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例等。总之，不允许在外部类的静态成员中直接使用非静态内部类。

Java不允许在非静态内部类里定义静态成员，非静态内部类里不能有静态方法、静态成员变量、静态初始化块。

6.7.2 静态内部类

静态内部类可以包含静态成员，也可以包含非静态成员。根据静态成员不能访问非静态成员的规则，静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。即使是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员。

6.7.3 使用内部类

1.在外部类内部使用内部类

从前面程序中可以看出，在外部类内部使用内部类时，与平常使用普通类没有太大的区别。一样可以直接通过内部类类名来定义变量，通过new调用内部类构造器来创建实例。唯一存在的一个区别是：不要在外部类的静态成员（包括静态方法和静态初始化块）中使用非静态内部类，因为静态成员不能访问非静态成员。在外部类内部定义内部类的子类与平常定义子类也没有太大的区别。

2.在外部类以外使用非静态内部类

如果希望在外部类以外的地方访问内部类（包括静态和非静态两种），则内部类不能使用private访问控制权限，private修饰的内部类只能在外部类内部使用。

对于使用其他访问控制符修饰的内部类，则能在访问控制符对应的访问权限内使用：

➢ 省略访问控制符的内部类，只能被与外部类处于同一个包中的其他类所访问。

➢ 使用protected修饰的内部类，可被与外部类处于同一个包中的其他类和外部类的子类所访问。

➢ 使用public修饰的内部类，可以在任何地方被访问。

在外部类以外的地方定义内部类（包括静态和非静态两种）变量的语法格式如下：

由于非静态内部类的对象必须寄生在外部类的对象里，因此创建非静态内部类对象之前，必须先创建其外部类对象。在外部类以外的地方创建非静态内部类实例的语法如下：

3.在外部类以外使用静态内部类

因为静态内部类是外部类类相关的，因此创建静态内部类对象时无须创建外部类对象。在外部类以外的地方创建静态内部类实例的语法如下：

6.7.4 局部内部类

如果把一个内部类放在方法里定义，则这个内部类就是一个局部内部类，局部内部类仅在该方法里有效。由于局部内部类不能在外部类的方法以外的地方使用，因此局部内部类也不能使用访问控制符和static修饰符修饰。

6.7.5 匿名内部类

匿名内部类适合创建那种只需要一次使用的类，定义匿名内部类的格式如下：

关于匿名内部类还有如下两条规则：

➢ 匿名内部类不能是抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。因此不允许将匿名内部类定义成抽象类。

➢ 匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义初始化块，可以通过实例初始化块来完成构造器需要完成的事情。

6.8 Java 11增强的Lambda表达式

当使用Lambda表达式代替匿名内部类创建对象时，Lambda表达式的代码块将会代替实现抽象方法的方法体，Lambda表达式就相当一个匿名方法。

从上面语法格式可以看出，Lambda表达式的主要作用就是代替匿名内部类的烦琐语法，它由三部分组成：

➢ 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。

➢ 箭头（->）。必须通过英文中画线和大于符号组成。

➢ 代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么这条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回这条语句的值。

Lambda表达式的类型，也被称为“目标类型（target type）”，Lambda表达式的目标类型必须是“函数式接口（functional interface）”。函数式接口代表只包含一个抽象方法的接口。函数式接口可以包含多个默认方法、类方法，但只能声明一个抽象方法。

前面已经介绍过，如果Lambda表达式的代码块只有一条代码，程序就可以省略Lambda表达式中代码块的花括号。不仅如此，如果Lambda表达式的代码块只有一条代码，还可以在代码块中使用方法引用和构造器引用。方法引用和构造器引用可以让Lambda表达式的代码块更加简洁。方法引用和构造器引用都需要使用两个英文冒号。Lambda表达式支持如表6.2所示的几种引用方式：

Lambda表达式与匿名内部类的联系和区别：

Lambda表达式是匿名内部类的一种简化，因此它可以部分取代匿名内部类的作用。

Lambda表达式与匿名内部类存在如下相同点。

➢ Lambda表达式与匿名内部类一样，都可以直接访问“effectively final”的局部变量，以及外部类的成员变量（包括实例变量和类变量）。

➢ Lambda表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法。

Lambda表达式与匿名内部类主要存在如下区别。

➢ 匿名内部类可以为任意接口创建实例—不管接口包含多少个抽象方法，只要匿名内部类实现所有的抽象方法即可；但Lambda表达式只能为函数式接口创建实例。

➢ 匿名内部类可以为抽象类甚至普通类创建实例；但Lambda表达式只能为函数式接口创建实例。

➢ 匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法；但Lambda表达式的代码块不允许调用接口中定义的默认方法。

6.9 枚举类

Java 5新增了一个enum关键字（它与class、interface关键字的地位相同），用以定义枚举类。正如前面看到的，枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或者多个接口，也可以定义自己的构造器。一个Java源文件中最多只能定义一个public访问权限的枚举类，且该Java源文件也必须和该枚举类的类名相同。

但枚举类终究不是普通类，它与普通类有如下简单区别：

➢ 枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是默认继承Object类，因此枚举类不能显式继承其他父类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。

➢ 使用enum定义、非抽象的枚举类默认会使用final修饰。

➢ 枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认使用private修饰；如果强制指定访问控制符，则只能指定private修饰符。由于枚举类的所有构造器都是private的，而子类构造器总要调用父类构造器一次，因此枚举类不能派生子类。

➢ 枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。列出这些实例时，系统会自动添加public static final修饰，无须程序员显式添加。枚举类默认提供了一个values()方法，该方法可以很方便地遍历所有的枚举值。

6.10 对象与垃圾回收

6.10.1 对象在内存中的状态

当一个对象在堆内存中运行时，根据它被引用变量所引用的状态，可以把它所处的状态分成如下三种：

➢ 可达状态：当一个对象被创建后，若有一个以上的引用变量引用它，则这个对象在程序中处于可达状态，程序可通过引用变量来调用该对象的实例变量和方法。

➢ 可恢复状态：如果程序中某个对象不再有任何引用变量引用它，它就进入了可恢复状态。在这种状态下，系统的垃圾回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有可恢复状态对象的finalize()方法进行资源清理。如果系统在调用finalize()方法时重新让一个引用变量引用该对象，则这个对象会再次变为可达状态；否则该对象将进入不可达状态。

➢ 不可达状态：当对象与所有引用变量的关联都被切断，且系统已经调用所有对象的finalize()方法后依然没有使该对象变成可达状态，那么这个对象将永久性地失去引用，最后变成不可达状态。只有当一个对象处于不可达状态时，系统才会真正回收该对象所占有的资源。

6.10.2 强制垃圾回收

当一个对象失去引用后，系统何时调用它的finalize()方法对它进行资源清理，何时它会变成不可达状态，系统何时回收它所占有的内存，对于程序完全透明。程序只能控制一个对象何时不再被任何引用变量引用，绝不能控制它何时被回收。程序无法精确控制Java垃圾回收的时机，但依然可以强制系统进行垃圾回收—这种强制只是通知系统进行垃圾回收，但系统是否进行垃圾回收依然不确定。大部分时候，程序强制系统垃圾回收后总会有一些效果。

强制系统垃圾回收有如下两种方式：

➢ 调用System类的gc()静态方法：System.gc()。

➢ 调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc()。

这种强制只是建议系统立即进行垃圾回收，系统完全有可能并不立即进行垃圾回收，垃圾回收机制也不会对程序的建议完全置之不理：垃圾回收机制会在收到通知后，尽快进行垃圾回收。

6.10.3 finalize方法

finalize()方法具有如下4个特点。

➢ 永远不要主动调用某个对象的finalize()方法，该方法应交给垃圾回收机制调用。

➢ finalize()方法何时被调用，是否被调用具有不确定性，不要把finalize()方法当成一定会被执行的方法。

➢ 当JVM执行可恢复对象的finalize()方法时，可能使该对象或系统中其他对象重新变成可达状态。

➢ 当JVM执行finalize()方法时出现异常时，垃圾回收机制不会报告异常，程序继续执行。

6.10.4 对象的软、弱和虚引用

Java语言对对象的引用有如下4种方式：

1.强引用（StrongReference）这是Java程序中最常见的引用方式。程序创建一个对象，并把这个对象赋给一个引用变量，程序通过该引用变量来操作实际的对象，前面介绍的对象和数组都采用了这种强引用的方式。当一个对象被一个或一个以上的引用变量所引用时，它处于可达状态，不可能被系统垃圾回收机制回收。

2.软引用（SoftReference）软引用需要通过SoftReference类来实现，当一个对象只有软引用时，它有可能被垃圾回收机制回收。对于只有软引用的对象而言，当系统内存空间足够时，它不会被系统回收，程序也可使用该对象；当系统内存空间不足时，系统可能会回收它。软引用通常用于对内存敏感的程序中。

3.弱引用（WeakReference）弱引用通过WeakReference类实现，弱引用和软引用很像，但弱引用的引用级别更低。对于只有弱引用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。当然，并不是说当一个对象只有弱引用时，它就会立即被回收—正如那些失去引用的对象一样，必须等到系统垃圾回收机制运行时才会被回收。

4.虚引用（PhantomReference）虚引用通过PhantomReference类实现，虚引用完全类似于没有引用。虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象只有一个虚引用时，那么它和没有引用的效果大致相同。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，虚引用必须和引用队列（ReferenceQueue）联合使用。

第7章 Java基础类库

7.1 与用户互动

Scanner主要提供了两个方法来扫描输入。

➢ hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()。

➢ nextXxx()：获取下一个输入项。Xxx的含义与前一个方法中的Xxx相同。

7.2 系统相关

Java程序在不同操作系统上运行时，可能需要取得平台相关的属性，或者调用平台命令来完成特定功能。Java提供了System类和Runtime类来与程序的运行平台进行交互。

7.3 常用类

本节将介绍Java提供的一些常用类，如String、Math、BigDecimal等的用法。

Object类的clone()方法虽然简单、易用，但它只是一种“浅克隆”——它只克隆该对象的所有成员变量值，不会对引用类型的成员变量值所引用的对象进行克隆。如果开发者需要对对象进行“深克隆”，则需要开发者自己进行“递归”克隆，保证所有引用类型的成员变量值所引用的对象都被复制了。

Java 7新增了一个Objects工具类，它提供了一些工具方法来操作对象，这些工具方法大多是“空指针”安全的。

String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。StringBuilder类是JDK 1.5新增的类，它也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是，StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用StringBuilder类。

Java 9改进了字符串（包括String、StringBuffer、StringBuilder）的实现。在Java 9以前字符串采用char[]数组来保存字符，因此字符串的每个字符占2字节；而Java 9及更新版本的JDK的字符串采用byte[]数组再加一个encoding-flag字段来保存字符，因此字符串的每个字符只占1字节。所以Java 9及更新版本的JDK的字符串更加节省空间，但字符串的功能方法没有受到任何影响。

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（以当前时间作为种子），另一个构造器需要程序员显式传入一个long型整数的种子。ThreadLocalRandom类是Java 7新增的一个类，它是Random的增强版。在并发访问的环境下，使用ThreadLocalRandom来代替Random可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。

为了能精确表示、计算浮点数，Java提供了BigDecimal类，该类提供了大量的构造器用于创建BigDecimal对象，包括把所有的基本数值型变量转换成一个BigDecimal对象，也包括利用数字字符串、数字字符数组来创建BigDecimal对象。

7.4 Java 8的日期、时间类

Date、Calendar

7.5 正则表达式

正则表达式是一个强大的字符串处理工具，可以对字符串进行查找、提取、分割、替换等操作。

String类里也提供了如下几个特殊的方法：

➢ boolean matches(String regex)：判断该字符串是否匹配指定的正则表达式。

➢ String replaceAll(String regex, String replacement)：将该字符串中所有匹配regex的子串替换成replacement。

➢ String replaceFirst(String regex, String replacement)：将该字符串中第一个匹配regex的子串替换成replacement。

➢ String[] split(String regex)：以regex作为分隔符，把该字符串分割成多个子串。

Java还提供了Pattern和Matcher两个类专门用于提供正则表达式支持。Pattern对象是正则表达式编译后在内存中的表示形式，因此，正则表达式字符串必须先被编译为Pattern对象，然后再利用该Pattern对象创建对应的Matcher对象。执行匹配所涉及的状态保留在Matcher对象中，多个Matcher对象可共享同一个Pattern对象。

上面定义的Pattern对象可以多次重复使用。如果某个正则表达式仅需一次使用，则可直接使用Pattern类的静态matches()方法，此方法自动把指定字符串编译成匿名的Pattern对象，并执行匹配，如下所示。

Pattern是不可变类，可供多个并发线程安全使用。

Matcher类提供了如下几个常用方法：

➢ find()：返回目标字符串中是否包含与Pattern匹配的子串。

➢ group()：返回上一次与Pattern匹配的子串。

➢ start()：返回上一次与Pattern匹配的子串在目标字符串中的开始位置。

➢ end()：返回上一次与Pattern匹配的子串在目标字符串中的结束位置加1。

➢ lookingAt()：返回目标字符串前面部分与Pattern是否匹配。

➢ matches()：返回整个目标字符串与Pattern是否匹配。

➢ reset()：将现有的Matcher对象应用于一个新的字符序列。

7.6 变量处理和方法处理

Java 9引入了一个新的VarHandle类，并增强了原有的MethodHandle类。通过这两个类，允许Java像动态语言一样引用变量、引用方法，并调用它们。

7.6.1 Java 9增强的MethodHandle

MethodHandle为Java增加了方法引用的功能，方法引用的概念有点类似于C的“函数指针”。这种方法引用是一种轻量级的引用方式，它不会检查方法的访问权限，也不管方法所属的类、实例方法或静态方法，MethodHandle就是简单代表特定的方法，并可通过MethodHandle来调用方法。

为了使用MethodHandle，还涉及如下几个类：

➢ MethodHandles：MethodHandle的工厂类，它提供了一系列静态方法用于获取MethodHandle。

➢ MethodHandles.Lookup：Lookup静态内部类也是MethodHandle、VarHandle的工厂类，专门用于获取MethodHandle和VarHandle。

➢ MethodType：代表一个方法类型。MethodType根据方法的形参、返回值类型来确定方法类型。

下面程序示范了MethodHandle的用法。

7.6.2 Java 9增加的VarHandle

VarHandle主要用于动态操作数组的元素或对象的成员变量。VarHandle与MethodHandle非常相似，它也需要通过MethodHandles来获取实例，接下来调用VarHandle的方法即可动态操作指定数组的元素或指定对象的成员变量。

下面程序示范了VarHandle的用法。

7.7 Java 11改进的国际化与格式化

Java程序的国际化主要通过如下三个类完成。

➢ java.util.ResourceBundle：用于加载国家、语言资源包。

➢ java.util.Locale：用于封装特定的国家/区域、语言环境。

➢ java.text.MessageFormat：用于格式化带占位符的字符串。

为了实现程序的国际化，必须先提供程序所需要的资源文件。资源文件的内容是很多key-value对，其中key是程序使用的部分，而value则是程序界面的显示字符串。

资源文件的命名可以有如下三种形式。

➢ baseName_language_country.properties

➢ baseName_language.properties

➢ baseName.properties

其中baseName是资源文件的基本名，用户可随意指定；而language和country都不可随意变化，必须是Java所支持的语言和国家。

Locale类的getAvailableLocales()方法，该方法返回一个Locale数组，该数组里包含了Java所支持的国家和语言。

MessageFormat是抽象类Format的子类，Format抽象类还有两个子类：NumberFormat和DateFormat，它们分别用以实现数值、日期的格式化。NumberFormat、DateFormat可以将数值、日期转换成字符串，也可以将字符串转换成数值、日期。SimpleDateFormat是DateFormat的子类，正如它的名字所暗示的，它是“简单”的日期格式器。

7.8 Java 8新增的日期、时间格式器

第8章 Java集合

8.1 Java集合概述

集合类主要负责保存、盛装其他数据，因此集合类也称为容器类。所有的集合类都位于java.util包下，后来为了处理多线程环境下的并发安全问题，Java 5还在java.util.concurrent包下提供了一些多线程支持的集合类。

Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。

8.2 Java 11增强的Collection和Iterator接口

Collection接口里定义了如下操作集合元素的方法。

➢ boolean add(Object o)：该方法用于向集合里添加一个元素。

➢ boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。

➢ void clear()：清除集合里的所有元素，将集合长度变为0。

➢ boolean contains(Object o)：返回集合里是否包含指定元素。

➢ boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素。

➢ boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false。

➢ Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。

➢ boolean remove(Object o)：删除集合中的指定元素o，当集合中包含了一个或多个元素o时，该方法只删除第一个符合条件的元素，该方法将返回true。

➢ boolean removeAll(Collection c)：从集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。

➢ boolean retainAll(Collection c)：从集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合和集合c的交集），如果该操作改变了调用该方法的集合，则该方法返回true。

➢ int size()：该方法返回集合里元素的个数

Java 11为Collection新增了一个toArray(IntFunction)方法，使用该方法的主要目的就是利用泛型。对于传统的toArray()方法而言，不管Collection本身是否使用泛型，toArray()的返回值总是Object[]；但新增的toArray(IntFunction)方法不同，当Collection使用泛型时，toArray(IntFunction)可以返回特定类型的数组。

8.2.1 使用Lambda表达式遍历集合

Java 8为Iterable接口新增了一个forEach(Consumer action)默认方法，该方法所需参数的类型是一个函数式接口。正因为Consumer是函数式接口，因此可以使用Lambda表达式来遍历集合元素。

8.2.2 使用Iterator遍历集合元素

Iterator则主要用于遍历（即迭代访问）Collection集合中的元素，Iterator对象也被称为迭代器。

Iterator接口里定义了如下4个方法。

➢ boolean hasNext()：如果被迭代的集合元素还没有被遍历完，则返回true。

➢ Object next()：返回集合里的下一个元素。

➢ void remove()：删除集合里上一次next方法返回的元素。

➢ void forEachRemaining(Consumer action)，这是Java 8为Iterator新增的默认方法，该方法可使用Lambda表达式来遍历集合元素。

Iterator迭代器采用的是快速失败（fail-fast）机制，一旦在迭代过程中检测到该集合已经被修改（通常是程序中的其他线程修改），程序立即引发ConcurrentModificationException异常，而不是显示修改后的结果，这样可以避免共享资源而引发的潜在问题。

8.2.3 使用Lambda表达式遍历Iterator

Java 8为Iterator新增了一个forEachRemaining(Consumer action)方法，该方法所需的Consumer参数同样也是函数式接口。当程序调用Iterator的forEachRemaining(Consumeraction)遍历集合元素时，程序会依次将集合元素传给Consumer的accept(T t)方法（该接口中唯一的抽象方法）。

8.2.4 使用foreach循环遍历集合元素

Java 5提供的foreach循环迭代访问集合元素更加便捷。

8.2.5 使用Predicate操作集合

Java 8为Collection集合新增了一个removeIf(Predicate filter)方法，该方法将会批量删除符合filter条件的所有元素。该方法需要一个Predicate（谓词）对象作为参数，Predicate也是函数式接口，因此可使用Lambda表达式作为参数。

8.2.6 使用Stream操作集合

Java 8还新增了Stream、IntStream、LongStream、DoubleStream等流式API，这些API代表多个支持串行和并行聚集操作的元素。

Java 8还为上面每个流式API提供了对应的Builder，例如Stream.Builder、IntStream.Builder、LongStream.Builder、DoubleStream.Builder，开发者可以通过这些Builder来创建对应的流。

独立使用Stream的步骤如下：

①使用Stream或XxxStream的builder()类方法创建该Stream对应的Builder。

②重复调用Builder的add()方法向该流中添加多个元素。

③调用Builder的build()方法获取对应的Stream。

④调用Stream的聚集方法。

在上面4个步骤中，第4步可以根据具体需求来调用不同的方法，Stream提供了大量的聚集方法供用户调用，具体可参考Stream或XxxStream的API文档。对于大部分聚集方法而言，每个Stream只能执行一次。

Stream提供了大量的方法进行聚集操作，这些方法既可以是“中间的”（intermediate），也可以是“末端的”（terminal）。

➢ 中间方法：中间操作允许流保持打开状态，并允许直接调用后续方法。

➢ 末端方法：末端方法是对流的最终操作。

除此之外，关于流的方法还有如下两个特征。

➢ 有状态的方法：这种方法会给流增加一些新的属性，比如元素的唯一性、元素的最大数量、保证元素以排序的方式被处理等。有状态的方法往往需要更大的性能开销。

➢ 短路方法：短路方法可以尽早结束对流的操作，不必检查所有的元素。

下面简单介绍一下Stream常用的中间方法。

➢ filter(Predicate predicate)：过滤Stream中所有不符合predicate的元素。

➢ mapToXxx(ToXxxFunction mapper)：使用ToXxxFunction对流中的元素执行一对一的转换，该方法返回的新流中包含了ToXxxFunction转换生成的所有元素。

➢ peek(Consumer action)：依次对每个元素执行一些操作，该方法返回的流与原有流包含相同的元素。该方法用于调试。

➢ distinct()：该方法用于排序流中所有重复元素（判断元素重复的标准是使用equals()比较返回true),这是一个有状态的方法。

➢ sorted()：该方法用于保证流中的元素在后续的访问中处于有序状态。这是一个有状态的方法。

➢ limit(long maxSize)：该方法用于保证对该流的后续访问中最大允许访问的元素个数。这是一个有状态的、短路方法。

下面简单介绍一下Stream常用的末端方法。

➢ forEach(Consumer action)：遍历流中所有元素，对每个元素执行action。

➢ toArray()：将流中所有元素转换为一个数组

➢ reduce()：该方法有三个重载的版本，都用于通过某种操作来合并流中的元素。

➢ min()：返回流中所有元素的最小值。

➢ max()：返回流中所有元素的最大值。

➢ count()：返回流中所有元素的数量。

➢ anyMatch(Predicate predicate)：判断流中是否至少包含一个元素符合Predicate条件。

8.3 Set集合

Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入。

8.3.1 HashSet类

HashSet是Set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。

HashSet具有以下特点。

➢ 不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。

➢ HashSet不是同步的，如果多个线程同时访问一个HashSet，假设有两个或者两个以上线程同时修改了HashSet集合时，则必须通过代码来保证其同步。

➢ 集合元素值可以是null。

HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，且两个对象的hashCode()值也相等。

8.3.2 LinkedHashSet类

HashSet还有一个子类LinkedHashSet，LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。

8.3.3 TreeSet类

TreeSet是SortedSet接口的实现类，正如SortedSet名字所暗示的，TreeSet可以确保集合元素处于排序状态。

与HashSet集合相比，TreeSet还提供了如下几个额外的方法。

➢ Comparator comparator()：如果TreeSet采用了定制排序，则该方法返回定制排序所使用的Comparator；如果TreeSet采用了自然排序，则返回null。

➢ Object first()：返回集合中的第一个元素。

➢ Object last()：返回集合中的最后一个元素。

➢ Object lower(Object e)：返回集合中位于指定元素之前的元素（即小于指定元素的最大元素，参考元素不需要是TreeSet集合里的元素）。

➢ Object higher(Object e)：返回集合中位于指定元素之后的元素（即大于指定元素的最小元素，参考元素不需要是TreeSet集合里的元素）。

➢ SortedSet subSet(Object fromElement, Object toElement)：返回此Set的子集合，范围从fromElement（包含）到toElement（不包含）。

➢ SortedSet headSet(Object toElement)：返回此Set的子集，由小于toElement的元素组成。

➢ SortedSet tailSet(Object fromElement)：返回此Set的子集，由大于或等于fromElement的元素组成。

与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方法：自然排序和定制排序。在默认情况下，TreeSet采用自然排序。

8.3.4 EnumSet类

EnumSet是一个专为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

EnumSet在内部以位向量的形式存储，这种存储形式非常紧凑、高效，因此EnumSet对象占用内存很小，而且运行效率很好。尤其是进行批量操作（如调用containsAll() 和retainAll()方法）时，如果其参数也是EnumSet集合，则该批量操作的执行速度也非常快。

EnumSet集合不允许加入null元素，如果试图插入null元素，EnumSet将抛出NullPointerException异常。如果只是想判断EnumSet是否包含null元素或试图删除null元素都不会抛出异常，只是删除操作将返回false，因为没有任何null元素被删除。

EnumSet类没有暴露任何构造器来创建该类的实例，程序应该通过它提供的类方法来创建EnumSet对象。

EnumSet类它提供了如下常用的类方法来创建EnumSet对象。

➢ EnumSet allOf(Class elementType)：创建一个包含指定枚举类里所有枚举值的EnumSet集合。

➢ EnumSet complementOf(EnumSet s)：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新EnumSet集合包含原EnumSet集合所不包含的、此枚举类剩下的枚举值（即新EnumSet集合和原EnumSet集合的集合元素加起来就是该枚举类的所有枚举值）。

➢ EnumSet copyOf(Collection c)：使用一个普通集合来创建EnumSet集合。

➢ EnumSet copyOf(EnumSet s)：创建一个与指定EnumSet具有相同元素类型、相同集合元素的EnumSet集合。

➢ EnumSet noneOf(Class elementType)：创建一个元素类型为指定枚举类型的空EnumSet。

➢ EnumSet of(E first, E...rest)：创建一个包含一个或多个枚举值的EnumSet集合，传入的多个枚举值必须属于同一个枚举类。

➢ EnumSet range(E from, E to)：创建一个包含从from枚举值到to枚举值范围内所有枚举值的EnumSet集合。

8.3.5 各Set实现类的性能分析

HashSet的性能总是比TreeSet好（特别是最常用的添加、查询元素等操作），因为TreeSet需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet。

HashSet还有一个子类：LinkedHashSet，对于普通的插入、删除操作，LinkedHashSet比HashSet要略微慢一点，这是由维护链表所带来的额外开销造成的，但由于有了链表，遍历LinkedHashSet会更快。

EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素。

必须指出的是，Set的三个实现类HashSet、TreeSet和EnumSet都是线程不安全的。

如果有多个线程同时访问一个Set集合，并且有超过一个线程修改了该Set集合，则必须手动保证该Set集合的同步性。通常可以通过Collections工具类的synchronizedSortedSet方法来“包装”该Set集合。

8.4 List集合

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

8.4.1 改进的List接口和ListIterator接口

List作为Collection接口的子接口，当然可以使用Collection接口里的全部方法。而且由于List是有序集合，因此List集合里增加了一些根据索引来操作集合元素的方法。

➢ void add(int index, Object element)：将元素element插入到List集合的index处。

➢ boolean addAll(int index, Collection c)：将集合c所包含的所有元素都插入到List集合的index处。

➢ Object get(int index)：返回集合index索引处的元素。

➢ int indexOf(Object o)：返回对象o在List集合中第一次出现的位置索引。

➢ int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现的位置索引。

➢ Object remove(int index)：删除并返回index索引处的元素。

➢ Object set(int index, Object element)：将index索引处的元素替换成element对象，返回被替换的旧元素。

➢ List subList(int fromIndex, int toIndex)：返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合。所有的List实现类都可以调用这些方法来操作集合元素。与Set集合相比，List增加了根据索引来插入、替换和删除集合元素的方法。除此之外，Java 8还为List接口添加了如下两个默认方法。

➢ void replaceAll(UnaryOperator operator)：根据operator指定的计算规则重新设置List集合的所有元素。➢ void sort(Comparator c)：根据Comparator参数对List集合的元素排序。

Java 8为List集合增加了sort()和replaceAll()两个常用的默认方法，其中sort()方法需要一个Comparator对象来控制元素排序，程序可使用Lambda表达式来作为参数；而replaceAll()方法则需要一个UnaryOperator来替换所有集合元素，UnaryOperator也是一个函数式接口，因此程序也可使用Lambda表达式作为参数。

与Set只提供了一个iterator()方法不同，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。

ListIterator接口在Iterator接口基础上增加了如下方法。

➢ boolean hasPrevious()：返回该迭代器关联的集合是否还有上一个元素。

➢ Object previous()：返回该迭代器的上一个元素。

➢ void add(Object o)：在指定位置插入一个元素。

8.4.2 ArrayList和Vector实现类

ArrayList和Vector作为List类的两个典型实现，完全支持前面介绍的List接口的全部功能。

ArrayList和Vector类都是基于数组实现的List类，所以ArrayList和Vector类封装了一个动态的、允许再分配的Object[]数组。ArrayList或Vector对象使用initialCapacity参数来设置该数组的长度，当向ArrayList或Vector中添加元素超出了该数组的长度时，它们的initialCapacity会自动增加。对于通常的编程场景，程序员无须关心ArrayList或Vector的initialCapacity。但如果向ArrayList或Vector集合中添加大量元素时，可使用ensureCapacity（int minCapacity）方法一次性地增加initialCapacity。这可以减少重分配的次数，从而提高性能。如果开始就知道ArrayList或Vector集合需要保存多少个元素，则可以在创建它们时就指定initialCapacity大小。如果创建空的ArrayList或Vector集合时不指定initialCapacity参数，则Object[]数组的长度默认为10。

除此之外，ArrayList和Vector还提供了如下两个方法来重新分配Object[]数组。

➢ void ensureCapacity(int minCapacity)：将ArrayList或Vector集合的Object[]数组长度增加大于或等于minCapacity值。

➢ void trimToSize()：调整ArrayList或Vector集合的Object[]数组长度为当前元素的个数。调用该方法可减少ArrayList或Vector集合对象占用的存储空间。

ArrayList和Vector在用法上几乎完全相同，ArrayList和Vector的显著区别是：

ArrayList是线程不安全的，当多个线程访问同一个ArrayList集合时，如果有超过一个线程修改了ArrayList集合，则程序必须手动保证该集合的同步性；但Vector集合则是线程安全的，无须程序保证该集合的同步性。因为Vector是线程安全的，所以Vector的性能比ArrayList的性能要低。实际上，即使需要保证List集合线程安全，也同样不推荐使用Vector实现类。后面会介绍一个Collections工具类，它可以将一个ArrayList变成线程安全的。

Vector还提供了一个Stack子类，它用于模拟“栈”这种数据结构，“栈”通常是指“后进先出”（LIFO）的容器。最后“push”进栈的元素，将最先被“pop”出栈。

Stack类里提供了如下几个方法。

➢ Object peek()：返回“栈”的第一个元素，但并不将该元素“pop”出栈。

➢ Object pop()：返回“栈”的第一个元素，并将该元素“pop”出栈。

➢ void push(Object item)：将一个元素“push”进栈，最后一个进“栈”的元素总是位于“栈”顶。需要指出的是，由于Stack继承了Vector，因此它也是一个非常古老的Java集合类，它同样是线程安全的、性能较差的，因此应该尽量少用Stack类。如果程序需要使用“栈”这种数据结构，建议使用后面将要介绍的ArrayDeque代替它。

8.4.3 固定长度的List

前面讲数组时介绍了一个操作数组的工具类：Arrays，该工具类里提供了asList（Object...a）方法，该方法可以把一个数组或指定个数的对象转换成一个List集合，这个List集合既不是ArrayList实现类的实例，也不是Vector实现类的实例，而是Arrays的内部类ArrayList的实例。Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里的元素，不可增加、删除该集合里的元素。

8.5 Queue集合

Queue用于模拟队列这种数据结构，队列通常是指“先进先出”（FIFO）的容器。

队列的头部保存在队列中存放时间最长的元素，队列的尾部保存在队列中存放时间最短的元素。新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列头部的元素。通常，队列不允许随机访问队列中的元素。

Queue接口中定义了如下几个方法。

➢ void add(Object e)：将指定元素加入此队列的尾部。

➢ Object element()：获取队列头部的元素，但是不删除该元素。

➢ boolean offer(Object e)：将指定元素加入此队列的尾部。当使用有容量限制的队列时，此方法通常比add（Object e）方法更好。

➢ Object peek()：获取队列头部的元素，但是不删除该元素。如果此队列为空，则返回null。

➢ Object poll()：获取队列头部的元素，并删除该元素。如果此队列为空，则返回null。

➢ Object remove()：获取队列头部的元素，并删除该元素。

Queue接口有一个PriorityQueue实现类。除此之外，Queue还有一个Deque接口，Deque代表一个“双端队列”，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可当成队列使用，也可当成栈使用。Java为Deque提供了ArrayDeque和LinkedList两个实现类。

8.5.1 PriorityQueue实现类

PriorityQueue是一个比较标准的队列实现类。PriorityQueue保存队列元素的顺序并不是按加入队列的顺序，而是按队列元素的大小进行重新排序。因此当调用peek()方法或者poll()方法取出队列中的元素时，并不是取出最先进入队列的元素，而是取出队列中最小的元素。从这个意义上来看，PriorityQueue已经违反了队列的最基本规则：先进先出（FIFO）。

PriorityQueue不允许插入null元素，它还需要对队列元素进行排序，PriorityQueue的元素有两种排序方式。

➢ 自然排序：采用自然顺序的PriorityQueue集合中的元素必须实现了Comparable接口，而且应该是同一个类的多个实例，否则可能导致ClassCastException异常。

➢ 定制排序：创建PriorityQueue队列时，传入一个Comparator对象，该对象负责对队列中的所有元素进行排序。采用定制排序时不要求队列元素实现Comparable接口。PriorityQueue队列对元素的要求与TreeSet对元素的要求基本一致。

8.5.2 Deque接口与ArrayDeque实现类

Deque接口是Queue接口的子接口，它代表一个双端队列，Deque接口里定义了一些双端队列的方法，这些方法允许从两端来操作队列的元素。

➢ void addFirst(Object e)：将指定元素插入该双端队列的开头。

➢ void addLast(Object e)：将指定元素插入该双端队列的末尾。

➢ Iterator descendingIterator()：返回该双端队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。

➢ Object getFirst()：获取但不删除双端队列的第一个元素。

➢ Object getLast()：获取但不删除双端队列的最后一个元素。

➢ boolean offerFirst(Object e)：将指定元素插入该双端队列的开头。

➢ boolean offerLast(Object e)：将指定元素插入该双端队列的末尾。

➢ Object peekFirst()：获取但不删除该双端队列的第一个元素；如果此双端队列为空，则返回null。

➢ Object peekLast()：获取但不删除该双端队列的最后一个元素；如果此双端队列为空，则返回null。

➢ Object pollFirst()：获取并删除该双端队列的第一个元素；如果此双端队列为空，则返回null。

➢ Object pollLast()：获取并删除该双端队列的最后一个元素；如果此双端队列为空，则返回null。

➢ Object pop()（栈方法）：pop出该双端队列所表示的栈的栈顶元素。相当于removeFirst()。

➢ void push(Object e)（栈方法）：将一个元素push进该双端队列所表示的栈的栈顶。相当于addFirst（e）。

➢ Object removeFirst()：获取并删除该双端队列的第一个元素。

➢ Object removeFirstOccurrence(Object o)：删除该双端队列的第一次出现的元素o。

➢ Object removeLast()：获取并删除该双端队列的最后一个元素。

➢ boolean removeLastOccurrence(Object o)：删除该双端队列的最后一次出现的元素o。从上面方法中可以看出，Deque不仅可以当成双端队列使用，而且可以被当成栈来使用，因为该类里还包含了pop（出栈）、push（入栈）两个方法。

从上面方法中可以看出，Deque不仅可以当成双端队列使用，而且可以被当成栈来使用，因为该类里还包含了pop（出栈）、push（入栈）两个方法。

Deque的方法与Queue的方法对照表如表8.2所示。

Deque的方法与Stack的方法对照表如表8.3所示。

Deque接口提供了一个典型的实现类：ArrayDeque，从该名称就可以看出，它是一个基于数组实现的双端队列，创建Deque时同样可指定一个numElements参数，该参数用于指定Object[]数组的长度；如果不指定numElements参数，Deque底层数组的长度为16。

8.5.3 LinkedList实现类

LinkedList类是List接口的实现类——这意味着它是一个List集合，可以根据索引来随机访问集合中的元素。除此之外，LinkedList还实现了Deque接口，可以被当成双端队列来使用，因此既可以被当成“栈”来使用，也可以当成队列使用。

ArrayList、ArrayDeque内部以数组的形式来保存集合中的元素，因此随机访问集合元素时有较好的性能；而LinkedList内部以链表的形式来保存集合中的元素，因此随机访问集合元素时性能较差，但在插入、删除元素时性能比较出色（只需改变指针所指的地址即可）。需要指出的是，虽然Vector也是以数组的形式来存储集合元素的，但因为它实现了线程同步功能（而且实现机制也不好），所以各方面性能都比较差。

8.5.4 各种线性表的性能分析

Java提供的List就是一个线性表接口，而ArrayList、LinkedList又是线性表的两种典型实现：基于数组的线性表和基于链的线性表。

Queue代表了队列，Deque代表了双端队列（既可作为队列使用，也可作为栈使用），接下来对各种实现类的性能进行分析。初学者可以无须理会ArrayList和LinkedList之间的性能差异，只需要知道LinkedList集合不仅提供了List的功能，还提供了双端队列、栈的功能就行。一般来说，由于数组以一块连续内存区来保存所有的数组元素，所以数组在随机访问时性能最好，所有的内部以数组作为底层实现的集合在随机访问时性能都比较好；而内部以链表作为底层实现的集合在执行插入、删除操作时有较好的性能。但总体来说，ArrayList的性能比LinkedList的性能要好，因此大部分时候都应该考虑使用ArrayList。

关于使用List集合有如下建议。

➢ 如果需要遍历List集合元素，对于ArrayList、Vector集合，应该使用随机访问方法（get）来遍历集合元素，这样性能更好；对于LinkedList集合，则应该采用迭代器（Iterator）来遍历集合元素。

➢ 如果需要经常执行插入、删除操作来改变包含大量数据的List集合的大小，可考虑使用LinkedList集合。使用ArrayList、Vector集合可能需要经常重新分配内部数组的大小，效果可能较差。

➢ 如果有多个线程需要同时访问List集合中的元素，开发者可考虑使用Collections将集合包装成线程安全的集合。

8.6 增强的Map集合

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false。key和value之间存在单向一对一关系，即通过指定的key，总能找到唯一的、确定的value。从Map中取出数据时，只要给出指定的key，就可以取出对应的value。

8.6.1 Java 8为Map新增的方法

Java 8除为Map增加了remove（Object key，Object value）默认方法之外，还增加了如下方法。

 Object compute(Object key, BiFunction remappingFunction)、 Object computeIfAbsent(Object key, Function mappingFunction)、 Object computeIfPresent(Object key, BiFunction remappingFunction)、➢ void forEach(BiConsumer action)、➢ Object getOrDefault(Object key, V defaultValue)等。

8.6.2 改进的HashMap和Hashtable实现类

Java 8改进了HashMap的实现，使用HashMap存在key冲突时依然具有较好的性能。

此外，Hashtable和HashMap存在两点典型区别。

➢ Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点；但如果有多个线程访问同一个Map对象时，使用Hashtable实现类会更好。

➢ Hashtable不允许使用null作为key和value，如果试图把null值放进Hashtable中，将会引发NullPointerException异常；但HashMap可以使用null作为key或value。由于HashMap里的key不能重复，所以HashMap里最多只有一个key-value对的key为null，但可以有无数多个key-value对的value为null。下面程序示范了用null值作为HashMap的key和value的情形。

8.6.3 LinkedHashMap实现类

HashSet有一个LinkedHashSet子类，HashMap也有一个LinkedHashMap子类；LinkedHashMap也使用双向链表来维护key-value对的顺序（其实只需要考虑key的顺序），该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可），同时又可避免使用TreeMap所增加的成本。LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能；但因为它以链表来维护内部顺序，所以在迭代访问Map里的全部元素时将有较好的性能。

8.6.4 使用Properties读写属性文件

Properties类是Hashtable类的子类，正如它的名字所暗示的，该对象在处理属性文件时特别方便（Windows操作平台上的ini文件就是一种属性文件）。

Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件中，也可以把属性文件中的“属性名=属性值”加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以Properties里的key、value都是字符串类型。该类提供了如下三个方法来修改Properties里的key、value值。

➢ String getProperty(String key)：获取Properties中指定属性名对应的属性值，类似于Map的get（Object key）方法。

➢ String getProperty(String key, String defaultValue)：该方法与前一个方法基本相似。该方法多一个功能，如果Properties中不存在指定的key时，则该方法指定默认值。

➢ Object setProperty(String key, String value)：设置属性值，类似于Hashtable的put()方法。

除此之外，它还提供了两个读写属性文件的方法。

➢ void load(InputStream inStream)：从属性文件（以输入流表示）中加载key-value对，把加载到的key-value对追加到Properties里（Properties是Hashtable的子类，它不保证key-value对之间的次序）。

➢ void store(OutputStream out, String comments)：将Properties中的key-value对输出到指定的属性文件（以输出流表示）中。

8.6.5 SortedMap接口和TreeMap实现类

正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类。TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对（节点）时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。

TreeMap也有两种排序方式。

➢ 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException异常。

➢ 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。类似于TreeSet中判断两个元素相等的标准，TreeMap中判断两个key相等的标准是：两个key通过compareTo()方法返回0，TreeMap即认为这两个key是相等的。

如果使用自定义类作为TreeMap的key，且想让TreeMap良好地工作，则重写该类的equals()方法和compareTo()方法时应保持一致的返回结果：两个key通过equals()方法比较返回true时，它们通过compareTo()方法比较应该返回0。如果equals()方法与compareTo()方法的返回结果不一致，TreeMap与Map接口的规则就会冲突。

8.6.6 WeakHashMap实现类

WeakHashMap与HashMap的用法基本相似。与HashMap的区别在于，HashMap的key保留了对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap的所有key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对；但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些key所对应的key-value对。WeakHashMap中的每个key对象只持有对实际对象的弱引用，因此，当垃圾回收了该key所对应的实际对象之后，WeakHashMap会自动删除该key对应的key-value对。

8.6.7 IdentityHashMap实现类

在IdentityHashMap中，当且仅当两个key严格相等（key1==key2）时，IdentityHashMap才认为两个key相等；对于普通的HashMap而言，只要key1和key2通过equals()方法比较返回true，且它们的hashCode值相等即可。

IdentityHashMap提供了与HashMap基本相似的方法，也允许使用null作为key和value。与HashMap相似：IdentityHashMap也不保证key-value对之间的顺序，更不能保证它们的顺序随时间的推移保持不变。

8.6.8 EnumMap实现类

EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。

EnumMap具有如下特征。

➢ EnumMap在内部以数组形式保存，所以这种实现形式非常紧凑、高效。

➢ EnumMap根据key的自然顺序（即枚举值在枚举类中的定义顺序）来维护key-value对的顺序。当程序通过keySet()、entrySet()、values()等方法遍历EnumMap时可以看到这种顺序。

➢ EnumMap不允许使用null作为key，但允许使用null作为value。如果试图使用null作为key时将抛出NullPointerException异常。如果只是查询是否包含值为null的key，或只是删除值为null的key，都不会抛出异常。与创建普通的Map有所区别的是，创建EnumMap时必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来。

8.6.9 各Map实现类的性能分析

对于Map的常用实现类而言，虽然HashMap和Hashtable的实现机制几乎一样，但由于Hashtable是一个古老的、线程安全的集合，因此HashMap通常比Hashtable要快。

TreeMap通常比HashMap、Hashtable要慢（尤其在插入、删除key-value对时更慢），因为TreeMap底层采用红黑树来管理key-value对（红黑树的每个节点就是一个key-value对）。使用TreeMap有一个好处：TreeMap中的key-value对总是处于有序状态，无须专门进行排序操作。当TreeMap被填充之后，就可以调用keySet()，取得由key组成的Set，然后使用toArray()方法生成key的数组，接下来使用Arrays的binarySearch()方法在已排序的数组中快速地查询对象。对于一般的应用场景，程序应该多考虑使用HashMap，因为HashMap正是为快速查询设计的（HashMap底层其实也是采用数组来存储key-value对）。但如果程序需要一个总是排好序的Map时，则可以考虑使用TreeMap。

LinkedHashMap比HashMap慢一点，因为它需要维护链表来保持Map中key-value时的添加顺序。

IdentityHashMap性能没有特别出色之处，因为它采用与HashMap基本相似的实现，只是它使用==而不是equals()方法来判断元素相等。

EnumMap的性能最好，但它只能使用同一个枚举类的枚举值作为key。

8.7 HashSet和HashMap的性能选项

对于HashSet及其子类而言，它们采用hash算法来决定集合中元素的存储位置，并通过hash算法来控制集合的大小；对于HashMap、Hashtable及其子类而言，它们采用hash算法来决定Map中key的存储，并通过hash算法来增加key集合的大小。

hash表里可以存储元素的位置被称为“桶（bucket）”，在通常情况下，单个“桶”里存储一个元素，此时有最好的性能：hash算法可以根据hashCode值计算出“桶”的存储位置，接着从“桶”中取出元素。但hash表的状态是open的：在发生“hash冲突”的情况下，单个桶会存储多个元素，这些元素以链表形式存储，必须按顺序搜索。如图8.8所示是hash表保存各元素，且发生“hash冲突”的示意图。

因为HashSet和HashMap、Hashtable都使用hash算法来决定其元素（HashMap则只考虑key）的存储，因此HashSet、HashMap的hash表包含如下属性。

➢ 容量（capacity）：hash表中桶的数量。

➢ 初始化容量（initial capacity）：创建hash表时桶的数量。HashMap和HashSet都允许在构造器中指定初始化容量。

➢ 尺寸（size）：当前hash表中记录的数量。

➢ 负载因子（load factor）：负载因子等于“size/capacity”。负载因子为0，表示空的hash表，0.5表示半满的hash表，依此类推。轻负载的hash表具有冲突少、适宜插入与查询的特点（但是使用Iterator迭代元素时比较慢）。除此之外，hash表里还有一个“负载极限”，“负载极限”是一个0～1的数值，“负载极限”决定了hash表的最大填满程度。当hash表中的负载因子达到指定的“负载极限”时，hash表会自动成倍地增加容量（桶的数量），并将原有的对象重新分配，放入新的桶内，这称为rehashing。

HashSet和HashMap、Hashtable的构造器允许指定一个负载极限，HashSet和HashMap、Hashtable默认的“负载极限”为0.75，这表明当该hash表的3/4已经被填满时，hash表会发生rehashing。

“负载极限”的默认值（0.75）是时间和空间成本上的一种折中：较高的“负载极限”可以降低hash表所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的操作（HashMap的get()与put()方法都要用到查询）；较低的“负载极限”会提高查询数据的性能，但会增加hash表所占用的内存开销。

程序员可以根据实际情况来调整HashSet和HashMap的“负载极限”值。如果开始就知道HashSet和HashMap、Hashtable会保存很多记录，则可以在创建时就使用较大的初始化容量，如果初始化容量始终大于HashSet和HashMap、Hashtable所包含的最大记录数除以“负载极限”，就不会发生rehashing。使用足够大的初始化容量创建HashSet和HashMap、Hashtable时，可以更高效地增加记录，但将初始化容量设置太高可能会浪费空间，因此通常不要将初始化容量设置得过高。

8.8 操作集合的工具类：Collections

Java提供了一个操作Set、List和Map等集合的工具类：Collections，该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。

8.8.1 排序操作Collections

提供了如下常用的类方法用于对List集合元素进行排序。

➢ void reverse(List list)：反转指定List集合中元素的顺序。

➢ void shuffle(List list)：对List集合元素进行随机排序（shuffle方法模拟了“洗牌”动作）。

➢ void sort(List list)：根据元素的自然顺序对指定List集合的元素按升序进行排序。

➢ void sort(List list, Comparator c)：根据指定Comparator产生的顺序对List集合元素进行排序。

➢ void swap(List list, int i, int j)：将指定List集合中的i处元素和j处元素进行交换。

➢ void rotate(List list, int distance)：当distance为正数时，将list集合的后distance个元素“整体”移到前面；当distance为负数时，将list集合的前distance个元素“整体”移到后面。该方法不会改变集合的长度。

8.8.2 查找、替换操作

Collections还提供了如下常用的用于查找、替换集合元素的类方法。

➢ int binarySearch(List list, Object key)：使用二分搜索法搜索指定的List集合，以获得指定对象在List集合中的索引。如果要使该方法可以正常工作，则必须保证List中的元素已经处于有序状态。

➢ Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素。

➢ Object max(Collection coll, Comparator comp)：根据Comparator指定的顺序，返回给定集合中的最大元素。

➢ Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素。

➢ Object min(Collection coll, Comparator comp)：根据Comparator指定的顺序，返回给定集合中的最小元素。

➢ void fill(List list, Object obj)：使用指定元素obj替换指定List集合中的所有元素。

➢ int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数。

➢ int indexOfSubList(List source, List target)：返回子List对象在父List对象中第一次出现的位置索引；如果父List中没有出现这样的子List，则返回-1。

➢ int lastIndexOfSubList(List source, List target)：返回子List对象在父List对象中最后一次出现的位置索引；如果父List中没有出现这样的子List，则返回-1。

➢ boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值newVal替换List对象的所有旧值oldVal。

8.8.3 同步控制

Collections类中提供了多个synchronizedXxx()方法，该方法可以将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。Java中常用的集合框架中的实现类HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap和TreeMap都是线程不安全的。如果有多个线程访问它们，而且有超过一个的线程试图修改它们，则存在线程安全的问题。Collections提供了多个类方法可以把它们包装成线程同步的集合。

8.8.4 设置不可变集合

Collections提供了如下三类方法来返回一个不可变的集合。

➢ emptyXxx()：返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是SortedSet、Set，还可以是Map、SortedMap等。

➢ singletonXxx()：返回一个只包含指定对象（只有一个或一项元素）的、不可变的集合对象，此处的集合既可以是List，还可以是Map。

➢ unmodifiableXxx()：返回指定集合对象的不可变视图，此处的集合既可以是List，也可以是Set、SortedSet，还可以是Map、SorteMap等。上面三类方法的参数是原有的集合对象，返回值是该集合的“只读”版本。通过Collections提供的三类方法，可以生成“只读”的Collection或Map。

8.8.5 Java 9新增的不可变集合

Java 9终于增加这个功能了——以前假如要创建一个包含6个元素的Set集合，程序需要先创建Set集合，然后调用6次add()方法向Set集合中添加元素。Java 9对此进行了简化，程序直接调用Set、List、Map的of()方法即可创建包含N个元素的不可变集合，这样一行代码就可创建包含N个元素的集合。不可变意味着程序不能向集合中添加元素，也不能从集合中删除元素。

8.9 烦琐的接口：Enumeration

Enumeration接口是Iterator迭代器的“古老版本”，从JDK 1.0开始，Enumeration接口就已经存在了（Iterator从JDK 1.2才出现）。

Enumeration接口只有两个名字很长的方法。

➢ boolean hasMoreElements()：如果此迭代器还有剩下的元素，则返回true。

➢ Object nextElement()：返回该迭代器的下一个元素，如果还有的话（否则抛出异常）。通过这两个方法不难发现，Enumeration接口中的方法名称冗长，难以记忆，而且没有提供Iterator的remove()方法。

如果现在编写Java程序，应该尽量采用Iterator迭代器，而不是用Enumeration迭代器。

第9章 泛型

9.1 泛型入门

从Java 5以后，Java引入了“参数化类型（parameterized type）”的概念，允许程序在创建集合时指定集合元素的类型，如List，这表明该List只能保存字符串类型的对象。Java的参数化类型被称为泛型（Generic）。

在Java 7以前，如果使用带泛型的接口、类定义变量，那么调用构造器创建对象时构造器的后面也必须带泛型了。例如如下两条语句：

从Java 7开始，Java允许在构造器后不需要带完整的泛型信息，只要给出一对尖括号（<>）即可，Java可以推断尖括号里应该是什么泛型信息。即上面两条语句可以改写为如下形式：

把两个尖括号并排放在一起非常像一个菱形，这种语法也就被称为“菱形”语法。

需要说明的是，当使用var声明变量时，编译器无法推断泛型的类型。因此，若使用var声明变量，程序无法使用“菱形”语法。

Java 9再次增强了“菱形”语法，它甚至允许在创建匿名内部类时使用菱形语法，Java可根据上下文来推断匿名内部类中泛型的类型。

9.2 深入泛型

所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参（或叫泛型）将在声明变量、创建对象、调用方法时动态地指定（即传入实际的类型参数，也可称为类型实参）。

Java 5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参，这就是在前面程序中看到的List和ArrayList两种类型。

9.2.1 定义泛型接口、类

注意：当创建带泛型声明的自定义类，为该类定义构造器时，构造器名还是原来的类名，不要增加泛型声明。例如，为Apple类定义构造器，其构造器名依然是Apple，而不是Apple！调用该构造器时却可以使用Apple的形式，当然应该为T形参传入实际的类型参数。Java 7提供了“菱形”语法，允许省略<>中的类型实参。

9.2.2 从泛型类派生子类

当创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，或从该父类派生子类，需要指出的是，当使用这些接口、父类时不能再包含泛型形参。例如，下面代码就是错误的：

如果想从Apple类派生一个子类，则可以改为如下代码：

像这种使用Apple类时省略泛型的形式被称为原始类型（raw type）。

9.2.3 并不存在泛型类

看下面代码的打印结果是什么？

运行上面的代码片段，可能有读者认为应该输出false，但实际输出true。因为不管泛型的实际类型参数是什么，它们在运行时总有同样的类（class）。

不管为泛型形参传入哪一种类型实参，对于Java来说，它们依然被当成同一个类处理，在内存中也只占用一块内存空间，因此在静态方法、静态初始化块或者静态变量（它们都是类相关的）的声明和初始化中不允许使用泛型形参。

由于系统中并不会真正生成泛型类，所以instanceof运算符后不能使用泛型类。例如，下面代码是错误的。

9.3 类型通配符

问号（?）被称为通配符，它的元素类型可以匹配任何类型。

现在使用任何类型的List来调用它，程序依然可以访问集合c中的元素，其类型是Object，这永远是安全的，因为不管List的真实类型是什么，它包含的都是Object。

但这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素加入到其中。因为程序无法确定c集合中元素的类型，所以不能向其中添加对象。例如，如下代码将会引起编译错误。

9.3.2 设定类型通配符的上限

当直接使用List这种形式时，即表明这个List集合可以是任何泛型List的父类。但还有一种特殊的情形，程序不希望这个List是任何泛型List的父类，只希望它代表某一类泛型List的父类。

为了表示List集合的所有元素是Shape的子类，Java泛型提供了被限制的泛型通配符。被限制的泛型通配符表示如下：

List是受限制通配符的例子，此处的问号（?）代表一个未知的类型，就像前面看到的通配符一样。但是此处的这个未知类型一定是Shape的子类型（也可以是Shape本身），因此可以把Shape称为这个通配符的上限（upper bound）。

使用普通通配符相似的是，shapes.add()的第二个参数类型是？extends Shape，它表示Shape未知的子类，程序无法确定这个类型是什么，所以无法将任何对象添加到这种集合中。简而言之，这种指定通配符上限的集合，只能从集合中取元素（取出的元素总是上限的类型或其子类），不能向集合中添加元素（因为编译器没法确定集合元素实际是哪种子类型）。

对于更广泛的泛型类来说，指定通配符上限就是为了支持类型型变。比如Foo是Bar的子类，这样A就相当于A的子类，可以将A赋值给A类型的变量，这种型变方式被称为协变。

对于协变的泛型而言，它只能调用泛型类型作为返回值类型的方法（编译器会将该方法返回值当成通配符上限的类型）；而不能调用泛型类型作为参数的方法。口诀是：协变只出不进！

9.3.3 设定类型通配符的下限

除可以指定通配符的上限之外，Java也允许指定通配符的下限，通配符的下限用的方式来指定，通配符下限的作用与通配符上限的作用恰好相反。指定通配符的下限就是为了支持类型型变。

比如Foo是Bar的子类，当程序需要一个A变量时，程序可以将A、A