Java数组与容器类分析资料--数组、List和Set、Map等

Java
数组与容器类分析资料--数组、List和Set
、Map等

数组是
Java

语言内置的类型，除此之外，
Java

有多种保存对象引用的方式。
Java

类库提供了一套相当完整的容器类，使用这些类的方法可以保存和操纵对象。下面分别进行讨论，在研究Java
容器类之前，先了解一下Java
数组的基本功能和特性。

1.

数组的基本特性

数组与其它种类的容器
(List/Set
/Map)
之间的区别在于效率、确定的类型和保存基本类型数据的能力。数组是一种高效的存储和随机访问对象引用序列的方式，使用数组可以快速的访问数组中的元素。但是当创建一个数组对象
(
注意和对象数组的区别
)
后，数组的大小也就固定了，当数组空间不足的时候就再创建一个新的数组，把旧的数组中所有的引用复制到新的数组中。

Java

中的数组和容器都需要进行边界检查，如果越界就会得到一个
RuntimeException
异常。这点和
C++
中有所不同，
C++
中
vector
的操作符
[]
不会做边界检查，这在速度上会有一定的提高，
Java

的数组和容器会因为时刻存在的边界检查带来一些性能上的开销。

Java

中通用的容器类不会以具体的类型来处理对象，容器中的对象都是以
Object
类型处理的，这是
Java

中所有类的基类。另外，数组可以保存基本类型，而容器不能，它只能保存任意的
Java

对象。

一般情况下，考虑到效率与类型检查，应该尽可能考虑使用数组。如果要解决一般化的问题，数组可能会受到一些限制，这时可以使用
Java

提供的容器类。

2.

操作数组的实用功能

在
java
.util.Arrays
类中，有许多
static
静态方法，提供了操作数组的一些基本功能：

equals()
方法
----
用于比较两个数组是否相等，相等的条件是两个数组的元素个数必须相等，并且对应位置的元素也相等。

fill()
方法
----
用以某个值填充整个数组，这个方法有点笨。

asList()
方法
----
接受任意的数组为参数，将其转变为
List
容器。

binarySearch()
方法
----
用于在已经排序的数组中查找元素，需要注意的是必须是已经排序过的数组。当
Arrays.binarySearch()
找到了查找目标时，该方法将返回一个等于或大于
0
的值，否则将返回一个负值，表示在该数组目前的排序状态下此目标元素所应该插入的位置。负值的计算公式是
“-x-1”
。
x
指的是第一个大于查找对象的元素在数组中的位置，如果数组中所有的元素都小于要查找的对象，则
x = a.size()
。如果数组中包含重复的元素，则无法保证找到的是哪一个元素，如果需要对没有重复元素的数组排序，可以使用
TreeSet
或者
LinkedHashSet
。另外，如果使用
Comparator
排序了某个对象数组，在使用该方法时必须提供同样的
Comparator
类型的参数。需要注意的是，基本类型数组无法使用
Comparator
进行排序。

sort()
方法
----
对数组进行升序排序。

在
Java

标准类库中，另有
static
方法
System.arraycopy()
用来复制数组，它针对所有类型做了重载。

3.

数组的排序

在
Java1.0
和
1.1
两个版本中，类库缺少基本的算法操作，包括排序的操作，
Java2
对
此进行了改善。在进行排序的操作时，需要根据对象的实际类型执行比较操作，如果为每种不同的类型各自编写一个不同的排序方法，将会使得代码很难被复用。一
般的程序设计目标应是“将保持不变的事物与会发改变的事物相分离”。在这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。

Java

有两种方式来实现比较的功能，一种是实现
java
.lang.Comparable
接口，该接口只有一个
compareTo()
方法，并以一个
Object
类为参数，如果当前对象小于参数则返回负值，如果相等返回零，如果当前对象大于参数则返回正值。另一种比较方法是采用策略
(strategy)
设计模式，将会发生变化的代码封装在它自己的类
(
策略对象
)
中，再将策略对象交给保持不变的代码中，后者使用此策略实现它的算法。因此，可以为不同的比较方式生成不同的对象，将它们用在同样的排序程序中。在此情况下，通过定义一个实现了
Comparator
接口的类而创建了一个策略，这个策略类有
compare()
和
equals()
两个方法，一般情况下实现
compare()
方法即可。

使用上述两种方法即可对任意基本类型的数组进行排序，也可以对任意的对象数组进行排序。再提示一遍，基本类型数组无法使用
Comparator
进行排序。

Java

标准类库中的排序算法针对排序的类型进行了优化——针对基本类型设计了“快速排序”，针对对象设计的“稳定归并排序”。一般不用担心其性能。

Java
容器分析--List和Set

容器类可以大大提高编程效率和编程能力，在Java2

中，所有的容器都由
SUN

公司的
Joshua Bloch

进行了重新设计，丰富了容器类库的功能。

Java2

容器类类库的用途是“保存对象”，它分为两类：

Collection

----

一组独立的元素，通常这些元素都服从某种规则。
List

必须保持元素特定的顺序，而
Set

不能有重复元素。

Map

----
一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，
Map
可以返回其所有键组成的
Set

和其所有值组成的
Collection
，或其键值对组成的
Set

，并且还可以像数组一样扩展多维
Map
，只要让
Map
中键值对的每个“值”是一个
Map
即可。

1.

迭代器

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

Java

中的
Iterator
功能比较简单，并且只能单向移动：

(1)

使用方法
iterator()
要求容器返回一个
Iterator
。第一次调用
Iterator
的
next()
方法时，它返回序列的第一个元素。

(2)

使用
next()
获得序列中的下一个元素。

(3)

使用
hasNext()
检查序列中是否还有元素。

(4)

使用
remove()
将迭代器新返回的元素删除。

Iterator
是
Java

迭代器最简单的实现，为
List
设计的
ListIterator
具有更多的功能，它可以从两个方向遍历
List
，也可以从
List
中插入和删除元素。

2.List
的功能方法

List(interface):

次序是
List
最重要的特点；它确保维护元素特定的顺序。
List
为
Collection
添加了许多方法，使得能够向
List
中间插入与移除元素
(
只推荐
LinkedList
使用
)
。一个
List
可以生成
ListIterator
，使用它可以从两个方向遍历
List
，也可以从
List
中间插入和删除元素。

ArrayList:

由数组实现的
List
。它允许对元素进行快速随机访问，但是向
List
中间插入与移除元素的速度很慢。
ListIterator
只应该用来由后向前遍历
ArrayList
，而不是用来插入和删除元素，因为这比
LinkedList
开销要大很多。

LinkedList:

对顺序访问进行了优化，向
List
中间插入与删除得开销不大，随机访问则相对较慢
(
可用
ArrayList
代替
)
。它具有方法
addFirst()
、
addLast()
、
getFirst()
、
getLast()
、
removeFirst()
、
removeLast()
，这些方法
(
没有在任何接口或基类中定义过
)
使得
LinkedList
可以当作堆栈、队列和双向队列使用。

3.Set

的功能方法

Set
(interface):

存入
Set

的每个元素必须是唯一的，因为
Set

不保存重复元素。加入
Set

的
Object
必须定义
equals()
方法以确保对象的唯一性。
Set

与
Collection
有完全一样的接口。
Set

接口不保证维护元素的次序。

HashSet:

为快速查找而设计的
Set

。存入
HashSet
的对象必须定义
hashCode()
。

TreeSet:

保持次序的
Set

，底层为树结构。使用它可以从
Set

中提取有序的序列。

LinkedHashSet:

具有
HashSet
的查询速度，且内部使用链表维护元素的顺序
(
插入的次序
)
。于是在使用迭代器遍历
Set

时，结果会按元素插入的次序显示。

HashSet
采用散列函数对元素进行排序，这是专门为快速查询而设计的；
TreeSet
采用红黑树的数据结构进行排序元素；
LinkedHashSet
内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，
Set

需要维护元素的存储顺序，因此要实现
Comparable
接口并定义
compareTo()
方法。

Java
容器分析--Map

标准的Java

类库中包含了几种类型的
Map
，它们都拥有同样的基本接口
Map
，但是行为特性各不相同，主要表现在效率、键值对的保存、元素呈现次序、对象的保存周期和判定键是否等价的策略等方面。

1.Map
的功能方法

Map(interface):

维护
label
和
value
的关联性，使得可以通过
label
查找
value
。

HashMap: Map
基于散列表的实现，取代了
Hashtable
。插入和查询
label/value
的开销是固定的，并且可以通过构造器设置容量和负载因子，以调整容器的性能。

LinkedHashMap:

在
HashMap
的基础上做了一些改进，在迭代遍历它时，取得
label/value
的顺序是其插入的次序，或者是最近最少使用
(LRU)
的次序，速度上比
HashMap
要慢一点，但在迭代访问时速度会更快，主要原因是它使用了链表维护内部次序。

TreeMap:

查看
label
或
label/value
时，元素会被排序，其次序由
Comparable
或
Comparator
决定，因此查询所得到的结果是经过排序的。另外，它是唯一带有
subMap()
方法的
Map
具体类，即返回一个子树。它也是
SortedMap
接口的唯一实现，
subMap()
方法也是从该接口继承的。

WeakHashMap: Weak Key
映射，允许释放映射所指向的对象。当映射之外没有引用指向某个
label
时，此
label
可以被垃圾收集器回收。

IdentityHashMap:

使用
==
代替
equals()
对
label
进行比较的散列映射。

2.hashCode()

当使用标准库中的类
Integer
作为
HashMap
的
label
时，程序能够正常运行，但是使用自己创建的类作为
HashMap
的
label
时，通常犯一个错误。

在
HashMap
中通过
label
查找
value
时，实际上是计算
label
对象地址的散列码来确定
value
的。一般情况下，我们是使用基类
Object
的方法
hashCode()
来生成散列码，它默认是使用对象的地址来计算的，因此由第一个对象
new Apple(5)
和第二个对象
new Apple(5)
生成的散列码是不同的，不能完成正确的查找。通常，我们可以编写自己的
hashCode()
方法来覆盖基类的原始方法，但与此同时，我们必须同时实现
equals()
方法来判断当前的
label
是否与表中存在的
label
相同。正确的
equals()
方法满足五个条件：

(1)

自反性。对于任意的
x
，
x.equals(x)
一定返回
true
。

(2)

对称性。对于任意的
x
和
y
，如果
y.equals(x)
返回
true
，则
x.equals(y)
也返回
true
。

(3)

传递性。对于任意的
x
、
y
、
z
，如果有
x.equals(y)
返回
true
，
y.equals(z)
返回
true
，则
x.equals(z)
一定返回
true
。

(4)

一致性。对于任意的
x
和
y
，如果对象中用于等价比较的信息没有改变，那么无论调用
x.equals(y)
多少次，返回的结果应该保持一致，要么一直是
true
，要么一直是
false
。

(5)

对任何不是
null
的
x
，
x.equals(null)
一定返回
false
。

equals()
比较的是对象的地址，如果要使用自己的类作为
HashMap
的
label
，必须同时重载
hashCode()
和
equals()
方法。

使用散列的目的：想要使用一个对象来查找另一个对象。使用
TreeSet
或
TreeMap
也能实现此目的。另外，还可以自己实现一个
Map
，此时，必须提供
Map.entrySet()
方法来生成
Map.Entry
对象的
Set

。

使用散列的价值：速度，散列使得查询可以快速进行。散列将
label
保存载数组中方便快速查询，因为存储一组元素最快的数据结构是数组，用它来表示
label
的信息
(
后面有信息的描述
)
，而不是
label
本身。通过
label
对象计算得到一个数字，作为数组的下标，这个数字就是散列码
(
即前面所述的信息
)
。该散列码具体是通过定义在基类
Object
中，可能由程序员自定义的类覆盖的
hashCode()
方法，即散列函数生成。为了解决数组容量带来的限制，可以使不同的
label
生成相同的下标，保存在一个链表
list
中，每一个链表就是数组的一个元素。查询
label
时就可以通过对
list
中的信息进行查找，当散列函数比较好，数组的每个位置中的
list
长度较短，则可以快速查找到数组元素
list
中的某个位置，提高了整体速度。

散列表中的
slot
通常称为
bucket
，为了使散列分步均匀，
bucket
的值一般取质数。但事实证明，质数实际上并不是散列
bucket
的理想容量，近来
Java

散列实现都使用
2
的幂，具体如何验证以后再续。

3.HashMap
的性能因子

容量
(capacity):

散列表中
bucket
的数量。

初始化容量
(initial capacity):

创建散列表时
bucket
的数量。可以在构造方法中指定
HashMap
和
HashSet
的初始化容量。

尺寸
(size):

散列表中记录的数量。
(
数组的元素个数，非
list
中元素总和
)

负载因子
(load factor):

尺寸
/
容量。负载因子为
0
，表示空的散列表，
0.5
表示半满的散列表。轻负载的散列表具有冲突少，适宜插入与查询的特点，但是使用迭代器遍历会比较慢。较高的负载会减少所需空间大小。当负载达到指定值时，容器会自动成倍地增加容量，并将原有的对象重新分配，存入新的
bucket
中，这个过程称为“重散列”。

4.
重写
hashCode()
的关键

(1)

对同一个对象调用
hashCode()
都应该生成同样的值。

(2)

hashCode()
方法不要依赖于对象中易变的数据，当数据发生变化时，
hashCode()
就会生成一个不同的散列码，即产生了一个不同的
label
。

(3)

hashCode()
不应依赖于具有唯一性的对象信息，例如对象地址。

(4)

散列码应该更关心速度，而不是唯一性，因为散列码不必是唯一的。

(5)

好的
hashCode()
应该产生分步均匀的散列码。在
Effective Java
(Addison-Wesley 2001)
中，
Joshua Bloch
给
hashCode()
给出了设计指导，可以参考。

编写正确高效的
hashCode()
和
equals()
可以参考
Apache
的
Jakarta Commons
项目中的工具。

java
集合类总结

对象的集合

如果程序的对象数量有限，且寿命可知，那么这个程序是相当简单的。
数组

数组与其它容器的区别体现在三个方面：效率，类型识别以及可以持有primitives。数组是Java
提
供的，能随机存储和访问reference序列的诸多方法中的，最高效的一种。数组是一个简单的线性序列，所有它可以快速的访问其中的元素。但是速度是有
代价的；当你创建了一个数组之后，它的容量就固定了，而且在其生命周期里不能改变。也许你会提议先创建一个数组，等到快不够用的时候，再创建一个新的，然
后将旧的数组里的reference全部导到新的里面。其实（我们以后会讲的）ArrayList就是这么做的。但是这种灵活性所带来的开销，使得
ArrayList的效率比起数组有了明显下降。

Java
对数组和容器都做边界检查；如果过了界，它旧会给一个RuntimeException。这种异常表明这个错误是由程序员造成的，这样你就用不着再在程序里面检查了。

还有一些泛型容器类包括List，Set
和Map。他们处理对象的时候就好像这些对象都没有自己的具体类型一样。也就是说，容器将它所含的元素都看成是（Java
中所有类的根类）Object的。这样你只需要建一种容器，就能把所有类型的对象全都放进去。从这个角度来看，这种做法很不错（只是苦了 primitive。如果是常量，你还可以用Java
的
primitive的Wrapper类；如果是变量，那就只能放在你自己的类里了）。与其他泛型容器相比，这里体现数组的第二革优势：创建数组的时候，你
也同时指明了它所持有的对象的类型（这又引出了第三点－－数组可以持有primitives，而容器却不行）。也就是说，它会在编译的时候作类型检查，从
而防止你插入错误类型的对象，或者是在提取对象的时候把对象的类型给搞错了。Java
在编译和运行时都能阻止你将一个不恰当的消息传给对象。所有这并不是说使用容器就有什么危险，只是如果编译器能够帮你指定，那么程序运行会更快，最终用户也会较少收到程序运行异常的骚扰。

从效率和类型检查的角度来看，使用数组总是没错的。但是，如果你在解决一个更为一般的问题，那数组就会显得功能太弱了点。
数组是第一流的对象

不
管你用的是那种类型的数组，数组的标识符实际上都是一个“创建在堆（heap）里的实实在在的对象的”reference。实际上是那个对象持有其他对象
的reference。你即可以用数组的初始化语句，隐含地创建这个对象，也可以用new表达式，明确地创建这个对象，只读的length属性能告诉你数
组能存储多少元素。它是数组对象的一部分（实际上也是你唯一能访问的属性或方法）。‘[]’语法是另一条访问数组对象的途径。

你没法知道数组里面
究竟放了多少元素，因为length只是告诉你数组能放多少元素，也就是说是数组对象的容量，而不是它真正已经持有的元素的数量。但是，创建数组对象的时
候，它所持有的reference都会被自动地初始化为null，所以你可以通过检查数组的某个“槽位”是否为null，来判断它是否持有对象。以此类
推，primitive的数组，会自动来数字初始化为零，字符初始化为(char)0，boolean初始化为false。
primitive容器

容
器类只能持有Object对象的reference。而数组除了能持有Objects的reference之外，还可以直接持有primitive。当然
可以使用诸如Integer，Double之类的wrapper类。把primitive的值放到容器中，淡这样总有点怪怪的。此外，
primitive数组的效率要比wrapper类容器的高出许多。

当然，如果你使用primitive的时候，还需要那种“能随需要自动扩展的”容器类的灵活性，那就不能用数组了。你只能用容器来存储primitive的wrapper类。
返回一个数组

假设你写了一个方法，它返回的不是一个而是一组东西。那么在Java
中就可以返回的“就是一个数组”。与C++不同，你永远也不必为Java
的数组操心－－只要你还需要它，它就还在；一旦你用完了，垃圾回收器会帮你把它打扫干净。
Arrays类

java
.util
里面有一个Arrays类，它包括了一组可用于数组的static方法，这些方法都是一些实用工具。其中有四个基本方法：用来比较两个数组是否相等的
equals()；用来填充的fill()；用来对数组进行排序的sort()；以及用于在一个已排序的数组中查找元素的
binarySearch()。所有这些方法都对primitive和Object进行了重载。此外还有一个asList()方法，它接受一个数组，然后
把它转成一个List容器。

虽然Arrays还是有用的，但它的功能并不完整。举例来说，如果它能让我们不用写for循环就能直接打印数组，那就好了。此外，正如你所看到的fill()只能用一个值填数组。所以，如果你想把随即生成的数字填进数组的话，fill()是无能为力的。
复制一个数组

Java
标准类库提供了一个System.arraycopy()的static方法。相比for循环，它能以更快的速度拷贝数组。System.arraycopy()对所有类型都作了重载。

对象数组和primitive数组都能拷贝。但是如果你拷贝的是对象数组，那么你只拷贝了它们的reference－－对象本身不会被拷贝。这被成为浅拷贝（shallow copy）。
数组的比较

为
了能比较数组是否完全相等，Arrays提供了经重载的equals()方法。当然，也是针对各种primitive以及Object的。两个数组要想完
全相等，他们必须有相同数量的元素，而且数组的每个元素必须与另一个数组的相对应的位置上的元素相等。元素的相等姓，用equals()判断。（对于
primitive，它会使用其wrapper类的equals()；比如int使用Integer.equals()。）。
数组元素的比较

Java
里面有两种能让你实现比较功能的方法。一是实现java
.lang.Comparable
接口，并以此实现类“自有的”比较方法。这是一个很简单的接口，它只有一个方法compareTo()。这个方法能接受另一个对象作为参数，如果现有对象
比参数小，它就会返回一个负数，如果相同则返回零，如果现有的对象比参数大，它就返回一个正数。

static randInt()方法会生成一个介于0到100之间的正数。

现在架设，有人给你一个没有实现Comparable接口的类，或者这个类实现了Comparable接口，但是你发现它的工作方式不是你所希望的，于是要重新定义一个新的比较方法。Java
没
有强求你一定要把比较代码塞进类里，它的解决方案是使用“策略模式（strategy design
pattern）”。有了策略之后，你就能把会变的代码封装到它自己的类里（即所谓的策略对象strategy
object）。你把策略对象交给不会变的代码，然后用它运用策略完成整个算法。这样，你就可以用不同的策略对象来表示不同的比较方法，然后把它们都交给
同一个排序程序了。接下来就要“通过实现Comparator接口”来定义策略对象了。这个接口有两个方法compare()和equals()。但是除
非是有特殊的性能要求，否则你用不着去实现equals()。因为只要是类，它就都隐含地继承自Object，而Object里面已经有了一个
equals()了。所以你尽可以使用缺省的Object的equals()，这样就已经满足接口的要求了。

Collections类里专门有一个会返回与对象自有的比较法相反的Comparator的方法。它能很轻易地被用到CompType上面。

Collections.reverseOrder()返回了一个Comparator的reference。

compare()方法会根据第一个参数是小于，等于还是大于第二个参数，分别返回负整数，零或是正整数。
数组的排序

有了内置的排序方法之后，你就能对任何数组排序了，不论是primitive的还是对象数组的，只要它实现了Comparable接口或有一个与之相关的Comparator对象就行了。

Java
标准类库所用的排序算法已经作了优化－－对primitive，它用的是“快速排序（Quicksort）”，对对象，它用的是“稳定合并排序（stable merge sort）”。所以除非是prolier表明排序算法是瓶颈，否则你不用为性能担心。
查询有序数组

一旦数组排完序，你就能用Arrays.binarySearch()进行快速查询了。但是切忌对一个尚未排序的数组使用binarySearch()；因为这么做的结果是没意义的。

如果Arrays.binarySearch()找到了，它就返回一个大于或等于0的值。否则它就返回一个负值，而这个负值要表达的意思是，如果你手动维护这个数组的话，这个值应该插在哪个为