Java集合框架基础总结
声明：本文仅仅是总结学习笔记，使用了以下4篇文章
1. Java集合类: Set、List、Map、Queue使用场景梳理
（http://www.cnblogs.com/LittleHann/p/3690187.html）
2. java集合框架及介绍
(http://wenku.baidu.com/link?url=4kq5yn0NpK_ijM24wC9vKfyyKn-8PMVysHRHgjQGbDlJWtQ5KcWhGxlKZAUmYZOAn6Fb7sSYVrVIemaIdDJRtj6YIxavFmZadNlRA0Cx_nS）
3. java中hashcode()和equals()的详解
（http://www.iteye.com/topic/257191）
4. Java中hashCode的作用
（http://blog.csdn.net/fenglibing/article/details/8905007）
一. 基本概念
在编程中，常常需要集中存放多个数据。从传统意义上讲，数组是我们的一个很好的选择，前提是我们事先已经明确知道我们将要保存的对象的数量。一旦在数组初始化时指定了这个数组长度，这个数组长度就是不可变的，如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量)，java的集合类就是一个很好的设计方案了。
集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。所以的集合类都位于java.util包下，后来为了处理多线程环境下的并发安全问题，java5还在java.util.concurrent包下提供了一些多线程支持的集合类。
在学习Java中的集合类的API、编程原理的时候，我们一定要明白，"集合"是一个很古老的数学概念，它远远早于Java的出现。从数学概念的角度来理解集合能帮助我们更好的理解编程中什么时候该使用什么类型的集合类。
Java集合框架的优点
1. 减少编程工作：通过提供数据结构和算法，集合框架让你专注于程序的重要部分，而不是专注于建设低级结构（plumbing）。通过促进无关API之间影响，java集合框架使你免于编写适配对象或者转码去联接API。 增加程序的速度和质量：集合框架提供高性能、高质质量的数据结构和算法的实现。每个接口有各种实现供选择，程序可以被简单的调优通过选择集合实现。因为你从写自己的数据结构的苦力中解放，你有很多时间致力于改善程序质量和性能。
2. 允许无关API之间的交互：集合接口通过本地API来回传递集合。如果我的网络管理API提供一个节点名集合，同时如果你的GUI工具期望一个列头集合，我们的API将无缝交互，甚至它们是独立开发的。
3. 减少学习使用新API的工作：很多API自然地提供输入集合和提供集合输出。过去，每个API有一个子API，用来操作它的集合，这些子APi没有什么一致性，需要从头学，很容易犯错。集合框架的出现，解决了这个问题。
4. 减少设计新API的工作：这个是以前优势的另一面。设计值和实现者不必每次都为自己的集合设计方法，而是使用标准集合接口。
5. 软件重用：符合标准集合接口的新数据结构被自然重用。新的算法也同样
Java容器类类库的用途是"保存对象"，并将其划分为两个不同的概念：
1)Collection
一组"对立"的元素，通常这些元素都服从某种规则
1.1) List必须保持元素特定的顺序
1.2) Set不能有重复元素
1.3) Queue保持一个队列(先进先出)的顺序
2) Map
一组成对的"键值对"对象
Collection和Map的区别在于容器中每个位置保存的元素个数:
1)Collection 每个位置只能保存一个元素(对象)
2) Map保存的是"键值对"，就像一个小型数据库。我们可以通过"键"找到该键对应的"值"
equals()和hashcode()
1. hashCode说明
以下是关于HashCode的官方文档定义：
hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。
hashCode 的常规协定是：
在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）
当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
以上这段官方文档的定义，我们可以抽出成以下几个关键点：
a.hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
b.如果两个对象相同，就是适用于equals(java.lang.Object)方法，那么这两个对象的hashCode一定要相同；
c.如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
d.两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。
2. 首先equals()和hashcode()这两个方法都是从object类中继承过来的。
equals()方法在object类中定义如下：
public boolean equals(Object obj) {
return (this == obj);
}
很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们必需清楚，当String 、Math、还有Integer、Double...等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。比如在String类中如下：
public booleanequals(Object anObject) {
if (this ==anObject) {
return true;
}
if(anObject instanceofString) {
String anotherString = (String)anObject;
int n = count;
if (n== anotherString.count) {
char v1[]= value;
char v2[]= anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n--!= 0) {
if(v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
很明显，这是进行的内容比较，而已经不再是地址的比较。依次类推Double、Integer、Math...等等这些类都是重写了equals()方法的，从而进行的是内容的比较。当然了基本类型是进行值的比较，这个没有什么好说的。
我们还应该注意，Java语言对equals()的要求如下，这些要求是必须遵循的：
• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
以上这五点是重写equals()方法时，必须遵守的准则，如果违反会出现意想不到的结果，请大家一定要遵守。
3. 其次是hashcode()方法，在object类中定义如下：
public native int hashCode();
说明是一个本地方法，它的实现是根据本地机器相关的。当然我们可以在自己写的类中覆盖hashcode()方法，比如String、Integer、Double。。。。等等这些类都是覆盖了hashcode()方法的。例如在String类中定义的hashcode()方法如下：
public inthashCode() {
int h = hash;
if (h== 0) {
int off= offset;
charval[] = value;
int len= count;
for (int i =0; i < len; i++) {
h = 31*h + val[off++];
}
hash= h;
}
return h;
}
解释一下这个程序（String的API中写到）：
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希码为 0。）
4. 这里我们首先要明白一个问题：
equals()相等的两个对象，hashcode()一定相等；
equals（）不相等的两个对象，却并不能证明他们的hashcode()不相等。换句话说，equals()方法不相等的两个对象，hashcode()有可能相等。（我的理解是由于哈希码在生成的时候产生冲突造成的）。
反过来：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。解释下第3点的使用范围，我的理解是在object、String等类中都能使用。在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时，
Hashcode()方法根据String类的重写（第2点里面已经分析了）代码的分析，也可知道hashcode()返回结果也会相等。以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。
二. 架构层次
Iterable |
迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。这个Iterable接口只 有一个方法: iterator()。它返回一个代表当前集合对象的泛型 |
Collection |
Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。Collection是一个接口，用以提供规范定义，不能被实例化使用 |
Set |
Set集合类似于一个罐子，"丢进"Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。 Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，我们在加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，则Set就会接受这个新元素对象，否则拒绝。 因为Set的这个制约，在使用Set集合的时候，应该注意两点：1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法、2) 对Set的构造函数，传入的Collection参数不能包含重复的元素 |
| HashSet |
| HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。 值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等 |
| LinkedHashSet |
| LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。 当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。 LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历) |
| SortedSet |
| 此接口主要用于排序操作，即实现此接口的子类都属于排序的子类 |
| TreeSet |
| TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态 |
| EnumSet |
| EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序 |
| List |
| 接口继承 Collection，允许重复，以元素安插的次序来放置元素，不会重新排列 List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引 |
| ArrayList |
| ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组 |
| Vector |
| Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将Vector改为实现List接口，统一归入集合框架体系中 |
| Stack |
| Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出) |
LinkedList |
implements List |
Queue |
Queue用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念 |
| PriorityQueue |
| PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以看出来 |
Deque |
Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用 |
| ArrayDeque |
| 一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重新分配一个Object[]数组来存储集合元素 |
| Map |
| Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。 关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合 Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复) Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找) |
| HashMap |
| 和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等 |
| LinkedHashMap |
| LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区分) |
| Hashtable |
| 是一个古老的Map实现类 |
Properties |
Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中 |
| SortedMap |
| 正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类 |
| TreeMap |
| TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序 |
| WeakHashMap |
| WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。 但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对 |
| IdentityHashMap |
| IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等 |
| EnumMap |
| EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序 (即枚举值在枚举类中的定义顺序) |
三. 应用示例
| Set |
|
| HashSet |
|
import java.util.*; //类A的equals方法总是返回true,但没有重写其hashCode()方法。不能保证当前对象是HashSet中的唯一对象 class A { public boolean equals(Object obj) { return true; } } //类B的hashCode()方法总是返回1,但没有重写其equals()方法。不能保证当前对象是HashSet中的唯一对象 class B { public int hashCode() { return 1; } } //类C的hashCode()方法总是返回2,且有重写其equals()方法 class C { public int hashCode() { return 2; } public boolean equals(Object obj) { return true; } } public class HashSetTest { public static void main(String[] args) { HashSet books = new HashSet(); //分别向books集合中添加两个A对象，两个B对象，两个C对象 books.add(new A()); books.add(new A()); books.add(new B()); books.add(new B()); books.add(new C()); books.add(new C()); System.out.println(books); } }
|
|
| 结果 |
[B@1, B@1, C@2, A@3bc257, A@785d65] |
| 说明 |
可以看到，如果两个对象通过equals()方法比较返回true，但这两个对象的hashCode()方法返回不同的hashCode值时，这将导致HashSet会把这两个对象保存在Hash表的不同位置，从而使对象可以添加成功，这就与Set集合的规则有些出入了。所以，我们要明确的是: equals()决定是否可以加入HashSet、而hashCode()决定存放的位置，它们两者必须同时满足才能允许一个新元素加入HashSet 但是要注意的是: 如果两个对象的hashCode相同，但是它们的equlas返回值不同，HashSet会在这个位置用链式结构来保存多个对象。而HashSet访问集合元素时也是根据元素的HashCode值来快速定位的，这种链式结构会导致性能下降。 所以如果需要把某个类的对象保存到HashSet集合中，我们在重写这个类的equlas()方法和hashCode()方法时，应该尽量保证两个对象通过equals()方法比较返回true时，它们的hashCode()方法返回值也相等 |
|
|
|
| LinkedHashSet |
|
import java.util.*; public class LinkedHashSetTest { public static void main(String[] args) { LinkedHashSet books = new LinkedHashSet(); books.add("Java"); books.add("LittleHann"); System.out.println(books); //删除 Java books.remove("Java"); //重新添加 Java books.add("Java"); System.out.println(books); } }
|
|
| 结果 |
|
| 说明 |
元素的顺序总是与添加顺序一致，同时要明白的是，LinkedHashSetTest是HashSet的子类，因此它不允许集合元素重复 |
|
|
|
| TreeSet |
|
| 1. 自然排序 |
|
| package com.xmm.trri;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
TreeSet nums = new TreeSet(); // 向TreeSet中添加四个Integer对象 nums.add(5); nums.add(2); nums.add(10); nums.add(-9);
// 输出集合元素，看到集合元素已经处于排序状态 System.out.println(nums); //[-9, 2, 5, 10]
// 输出集合里的第一个元素 System.out.println(nums.first()); //-9
// 输出集合里的最后一个元素 System.out.println(nums.last()); //10
// 返回小于4的子集，不包含4 System.out.println(nums.headSet(4)); //[-9, 2]
// 返回大于5的子集，如果Set中包含5，子集中还包含5 System.out.println(nums.tailSet(5)); //[5, 10]
// 返回大于等于-3，小于4的子集。 System.out.println(nums.subSet(-3, 4)); //[2] } }
|
|
| 结果 |
|
| 说明 |
与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方式: 自然排序、定制排序
TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排序，即自然排序。如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口，否则程序会抛出异常。 当把一个对象加入TreeSet集合中时，TreeSet会调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树结构找到它的存储位置。如果两个对象通过compareTo(Object obj)方法比较相等，新对象将无法添加到TreeSet集合中(牢记Set是不允许重复的概念)。 注意: 当需要把一个对象放入TreeSet中，重写该对象对应类的equals()方法时，应该保证该方法与compareTo(Object obj)方法有一致的结果，即如果两个对象通过equals()方法比较返回true时，这两个对象通过compareTo(Object obj)方法比较结果应该也为0(即相等) 看到这里，我们应该明白： A.对与Set来说，它定义了equals()为唯一性判断的标准，而对于到了具体的实现，HashSet、TreeSet来说，它们又会有自己特有的唯一性判断标准，只有同时满足了才能判定为唯一性 B.我们在操作这些集合类的时候，对和唯一性判断有关的函数重写要重点关注 |
| 2. 定制排序 |
|
| import java.util.Comparator; import java.util.TreeSet;
class Max { int age;
public Max(int age) { this.age = age; }
public String toString() { return "Max[age:" + age + "]"; } }
public class TreeSetTest {
@SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) { TreeSet ts = new TreeSet(new Comparator
// 根据Max对象的age属性来决定大小 public int compare(Max o1, Max o2) { Max m1 = (Max) o1; Max m2 = (Max) o2; return m1.age > m2.age ? -1 : m1.age < m2.age ? 1 : 0; }
}); ts.add(new Max(5)); ts.add(new Max(-3)); ts.add(new Max(9)); System.out.println(ts); } } |
|
| 结果 |
[M[age:9], M[age:5], M[age:-3]] |
| 说明 |
TreeSet的自然排序是根据集合元素的大小，TreeSet将它们以升序排序。如果我们需要实现定制排序，则可以通过Comparator接口的帮助(类似PHP中的array_map回调处理函数的思想)。该接口里包含一个int compare(T o1， T o2)方法，该方法用于比较大小
看到这里，我们需要梳理一下关于排序的概念 1) equals、compareTo决定的是怎么比的问题，即用什么field进行大小比较 2) 自然排序、定制排序、Comparator决定的是谁大的问题，即按什么顺序(升序、降序)进行排序 它们的关注点是不同的，一定要注意区分 |
|
|
|
| EnumSet |
|
| import java.util.*;
enum Season { SPRING,SUMMER,FALL,WINTER } public class EnumSetTest { @SuppressWarnings({ "rawtypes", "unchecked" }) public static void main(String[] args) { //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值 EnumSet es1 = EnumSet.allOf(Season.class); System.out.println(es1); //输出[SPRING,SUMMER,FALL,WINTER]
//创建一个EnumSet空集合，指定其集合元素是Season类的枚举值。 EnumSet es2 = EnumSet.noneOf(Season.class); System.out.println(es2); //输出[]
//手动添加两个元素 es2.add(Season.WINTER); es2.add(Season.SPRING); System.out.println(es2); //输出[SPRING,WINTER]
//以指定枚举值创建EnumSet集合 EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER); System.out.println(es3); //输出[SUMMER,WINTER]
//以指定的枚举范围创建EnumSet集合 EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER); System.out.println(es4); //输出[SUMMER,FALL,WINTER]
//以es4集合中不存在的枚举元素创建EnumSet集合 //es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值 EnumSet es5 = EnumSet.complementOf(es4); System.out.println(es5); //输出[SPRING] } }
|
|
| 以上就是Set集合类的编程应用场景。那么应该怎样选择何时使用这些集合类呢？ |
|
1) HashSet的性能总是比TreeSet好(特别是最常用的添加、查询元素等操作)，因为TreeSet需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet 2) 对于普通的插入、删除操作，LinkedHashSet比HashSet要略慢一点，这是由维护链表所带来的开销造成的。不过，因为有了链表的存在，遍历LinkedHashSet会更快 3) EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素 4) HashSet、TreeSet、EnumSet都是"线程不安全"的，通常可以通过Collections工具类的synchronizedSortedSet方法来"包装"该Set集合。 SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...)); |
|
|
|
|
| List |
|
| ArrayList |
|
| @SuppressWarnings("unchecked") public static void main(String[] args) {
List books = new ArrayList(); //向books集合中添加三个元素 books.add(new String("第 1 元素")); books.add(new String("第 2 元素")); books.add(new String("第 3 元素")); System.out.println(books); //[第 1 元素, 第 2 元素, 第 3 元素]
//将新字符串对象插入在第二个位置 books.add(1 , new String("第 2 元素 -- 替换元素")); System.out.println(books); //[第 1 元素, 第 2 元素 -- 替换元素, 第 2 元素, 第 3 元素]
//删除第三个元素 books.remove(2); System.out.println(books); //[第 1 元素, 第 2 元素 -- 替换元素, 第 3 元素]
//判断指定元素在List集合中位置：输出1，表明位于第二位 System.out.println(books.indexOf(new String("第 2 元素 -- 替换元素"))); //1
//将第二个元素替换成新的字符串对象 books.set(1, new String("LittleHann")); System.out.println(books); //[第 1 元素, LittleHann, 第 3 元素]
//将books集合的第二个元素（包括） //到第三个元素（不包括）截取成子集合 System.out.println(books.subList(1 , 2)); //[LittleHann]
} |
|
| 结果 |
|
| 说明 |
|
|
|
|
| Stack |
|
| @SuppressWarnings("unchecked") public static void main(String[] args) {
Stack v = new Stack(); //依次将三个元素push入"栈" v.push("第 1 元素"); v.push("第 2 元素"); v.push("第 3 元素");
System.out.println(v); //[第 1 元素, 第 2 元素, 第 3 元素]
System.out.println(v.peek()); //访问第一个元素，但并不将其pop出"栈"，输出：第 3 元素
System.out.println(v); //依然输出：[第 1 元素, 第 2 元素, 第 3 元素]
System.out.println(v.pop()); //pop出第一个元素，输出：第 3 元素
System.out.println(v); //输出：[第 1 元素, 第 2 元素]
} |
|
| 结果 |
|
| 说明 |
从结果的输出可以明显看到栈后进先出的特点 |
|
|
|
| LinkedList |
|
| @SuppressWarnings("unchecked") public static void main(String[] args) {
LinkedList books = new LinkedList();
//将字符串元素加入队列的尾部(双端队列) books.offer("尾部");
//将一个字符串元素加入栈的顶部(双端队列) books.push("顶部");
//将字符串元素添加到队列的头(相当于栈的顶部) books.offerFirst("头部");
System.out.println(books); //[头部, 顶部, 尾部]
//访问、并不删除栈顶的元素 System.out.println(books.peekFirst()); //头部
//访问、并不删除队列的最后一个元素 System.out.println(books.peekLast()); //尾部
//将栈顶的元素弹出"栈" System.out.println(books.pop()); //头部
//下面输出将看到队列中第一个元素被删除 System.out.println(books); //[顶部, 尾部]
//访问、并删除队列的最后一个元素 System.out.println(books.pollLast()); //尾部
System.out.println(books); //下面输出将看到队列中只剩下中间一个元素： //[顶部] } |
|
| 结果 |
|
| 说明 |
从代码中我们可以看到，LinkedList同时表现出了双端队列、栈的用法。功能非常强大 |
|
|
|
| Queue |
|
| PriorityQueue |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) {
PriorityQueue pq = new PriorityQueue(); //下面代码依次向pq中加入四个元素 pq.offer(6); pq.offer(-3); pq.offer(9); pq.offer(0);
//输出pq队列，并不是按元素的加入顺序排列， System.out.println(pq); //而是按元素的大小顺序排列，输出[-3, 0, 9, 6]
System.out.println(pq.poll()); //访问队列第一个元素，其实就是队列中 最小的元素：-3 } |
|
| 结果 |
|
| 说明 |
PriorityQueue不允许插入null元素，它还需要对队列元素进行排序，PriorityQueue的元素有两种排序方式 1) 自然排序: 采用自然顺序的PriorityQueue集合中的元素对象都必须实现了Comparable接口，而且应该是同一个类的多个实例，否则可能导致ClassCastException异常 2) 定制排序 创建PriorityQueue队列时，传入一个Comparator对象，该对象负责对队列中的所有元素进行排序关于自然排序、定制排序的原理和之前说的TreeSet类似 |
|
|
|
| ArrayDeque |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) {
ArrayDeque stack = new ArrayDeque(); //依次将三个元素push入"栈" stack.push("第 1 个元素"); stack.push("第 2 个元素"); stack.push("第 3 个元素");
System.out.println(stack); //输出：[第 3 个元素, 第 2 个元素, 第 1 个元素]
System.out.println(stack.peek()); //访问第一个元素，但并不将其pop出"栈"，输出：第 3 个元素
System.out.println(stack); //依然输出：[第 3 个元素, 第 2 个元素, 第 1 个元素]
System.out.println(stack.pop()); //pop出第一个元素，输出：第 3 个元素
System.out.println(stack); //输出：[第 2 个元素, 第 1 个元素] } |
|
| 结果 |
|
| 说明 |
|
| 以上就是List集合类的编程应用场景。我们来梳理一下思路 |
|
1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、LinkedList(基于链的线性表)是线性表的两种典型实现 2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用) 3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。所以的内部以数组作为底层实现的集合在随机访问时性能最好。 4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能 5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好 |
|
| 我们之前说过，Collection接口继承了Iterable接口，也就是说，我们以上学习到的所有的Collection集合类都具有"可遍历性" Iterable接口也是java集合框架的成员，它隐藏了各种Collection实现类的底层细节，向应用程序提供了遍历Collection集合元素的统一编程接口: 1) boolean hasNext(): 是否还有下一个未遍历过的元素 2) Object next(): 返回集合里的下一个元素 3) void remove(): 删除集合里上一次next方法返回的元素 |
|
| iterator实现遍历: |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) {
//创建一个集合 Collection items = new HashSet(); items.add("第 1 个元素"); items.add("第 2 个元素"); items.add("第 3 个元素");
//获取items集合对应的迭代器 Iterator it = items.iterator(); while(it.hasNext()) { //it.next()方法返回的数据类型是Object类型， //需要强制类型转换 String item = (String)it.next(); System.out.println(item); //第 2 个元素 //第 1 个元素 //第 3 个元素 if (item.equals("第 2 个元素")) { //从集合中删除上一次next方法返回的元素 it.remove(); } //对book变量赋值，不会改变集合元素本身 item = "测试字符串"; } System.out.println(items); //[第 1 个元素, 第 3 个元素] } |
|
| 从代码可以看出，iterator必须依附于Collection对象，若有一个iterator对象，必然有一个与之关联的Collection对象。 除了可以使用iterator接口迭代访问Collection集合里的元素之外，使用java5提供的foreach循环迭代访问集合元素更加便捷 |
|
| foreach实现遍历: |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) {
//创建一个集合 Collection items = new HashSet(); items.add("第 1 个元素"); items.add("第 2 个元素"); items.add("第 3 个元素");
for (Object obj : items) { //此处的item变量也不是集合元素本身 String item = (String)obj; System.out.println(item); //第 2 个元素 //第 1 个元素 //第 3 个元素 if (item.equals("第 2 个元素")) { //下面代码会引发ConcurrentModificationException异常 //books.remove(item); } } System.out.println(items); //[第 2 个元素, 第 1 个元素, 第 3 个元素] } |
|
| 除了Collection固有的iterator()方法，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的继承上增加了如下方法: 1) boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素 2) Object previous(): 返回该迭代器的上一个元素(向前迭代) 3) void add(): 在指定位置插入一个元素 |
|
| ListIterator实现遍历: |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) {
//创建一个集合 List items = new ArrayList(); items.add("第 1 个元素"); items.add("第 2 个元素");
//获得集合的ListIterator ListIterator lit = items.listIterator();
//正向迭代 while (lit.hasNext()) { System.out.println(lit.next()); //迭代同时添加元素 lit.add("-------分隔符-------"); } //第 1 个元素 //第 2 个元素
System.out.println("=======下面开始反向迭代=======");
//反向迭代 while (lit.hasPrevious()) { System.out.println(lit.previous()); } //-------分隔符------- //第 2 个元素 //-------分隔符------- //第 1 个元素 } |
|
|
|
|
| Map |
|
| HashMap、Hashtable |
|
| class A { int count; public A(int count) { this.count = count; } //根据count的值来判断两个对象是否相等。 public boolean equals(Object obj) { if (obj == this) { return true; } if (obj != null && obj.getClass() == A.class) { A a = (A)obj; return this.count == a.count; } return false; } //根据count来计算hashCode值。 public int hashCode() { return this.count; } } class B { //重写equals()方法，B对象与任何对象通过equals()方法比较都相等 public boolean equals(Object obj) { return true; } } public class Test { @SuppressWarnings({ "rawtypes", "unchecked" }) public static void main(String[] args) { Hashtable ht = new Hashtable(); ht.put(new A(60000) , "第 1 个元素"); ht.put(new A(87563) , "第 2 个元素"); ht.put(new A(1232) , new B()); System.out.println(ht);
//只要两个对象通过equals比较返回true， //Hashtable就认为它们是相等的value。 //由于Hashtable中有一个B对象， //它与任何对象通过equals比较都相等，所以下面输出true。 System.out.println(ht.containsValue("测试字符串")); //true /*{ * cn.javass.chapter2.web.controller.A@ea60=第 1 个元素, * cn.javass.chapter2.web.controller.A@1560b=第 2 个元素, * cn.javass.chapter2.web.controller.A@4d0=cn.javass.chapter2.web.controller.B@150bd4d * }*/
//只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等 //Hashtable即认为它们是相同的key，所以下面输出true。 System.out.println(ht.containsKey(new A(87563))); //true
//下面语句可以删除最后一个key-value对 ht.remove(new A(1232)); //③
//通过返回Hashtable的所有key组成的Set集合， //从而遍历Hashtable每个key-value对 for (Object key : ht.keySet()) { System.out.print(key + "---->"); System.out.print(ht.get(key) + "\n"); } //cn.javass.chapter2.web.controller.A@ea60---->第 1 个元素 //cn.javass.chapter2.web.controller.A@1560b---->第 2 个元素 } } |
|
| 结果 |
|
| 说明 |
当使用自定义类作为HashMap、Hashtable的key时，如果重写该类的equals(Object obj)和hashCode()方法，则应该保证两个方法的判断标准一致--当两个key通过equals()方法比较返回true时，两个key的hashCode()的返回值也应该相同 |
|
|
|
| LinkedHashMap |
|
| SuppressWarnings({ "rawtypes", "unchecked" }) public static void main(String[] args) { LinkedHashMap scores = new LinkedHashMap(); scores.put("语文" , 80); scores.put("英文" , 82); scores.put("数学" , 76); //遍历scores里的所有的key-value对 for (Object key : scores.keySet()) { System.out.println(key + "------>" + scores.get(key)); } //语文------>80 //英文------>82 //数学------>76 } |
|
| 结果 |
|
| 说明 |
|
|
|
|
| Properties |
|
| @SuppressWarnings({ "rawtypes", "unchecked" }) public static void main(String[] args) throws Exception { Properties props = new Properties(); //向Properties中增加属性 props.setProperty("username" , "yeeku"); props.setProperty("password" , "123456");
//将Properties中的key-value对保存到a.ini文件中 props.store(new FileOutputStream("a.ini"), "comment line");
//新建一个Properties对象 Properties props2 = new Properties(); //向Properties中增加属性 props2.setProperty("gender" , "male");
//将a.ini文件中的key-value对追加到props2中 props2.load(new FileInputStream("a.ini") ); System.out.println(props2); //{password=123456, gender=male, username=yeeku} } |
|
| 结果 |
|
| 说明 |
Properties还可以把key-value对以XML文件的形式保存起来，也可以从XML文件中加载key-value对 |
|
|
|
| TreeMap |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) { TreeMap tm = new TreeMap(); tm.put(new R(3) , "第 1 个元素"); tm.put(new R(-5) , "第 2 个元素"); tm.put(new R(9) , "第 3 个元素");
System.out.println(tm); //{R[count:-5]=第 2 个元素, R[count:3]=第 1 个元素, R[count:9]=第 3 个元素}
//返回该TreeMap的第一个Entry对象 System.out.println(tm.firstEntry()); //R[count:-5]=第 2 个元素
//返回该TreeMap的最后一个key值 System.out.println(tm.lastKey()); //R[count:9]
//返回该TreeMap的比new R(2)大的最小key值。 System.out.println(tm.higherKey(new R(2))); //R[count:3]
//返回该TreeMap的比new R(2)小的最大的key-value对。 System.out.println(tm.lowerEntry(new R(2))); //R[count:-5]=第 2 个元素
//返回该TreeMap的子TreeMap System.out.println(tm.subMap(new R(-1) , new R(4))); //{R[count:3]=第 1 个元素} } |
|
| 结果 |
|
| 说明 |
从代码中可以看出，类似于TreeSet中判断两个元素是否相等的标准，TreeMap中判断两个key相等的标准是: 1) 两个key通过compareTo()方法返回0 2) equals()放回true
我们在重写这两个方法的时候一定要保证它们的逻辑关系一致。 再次强调一下: Set和Map的关系十分密切，java源码就是先实现了HashMap、TreeMap等集合，然后通过包装一个所有的value都为null的Map集合实现了Set集合类 |
|
|
|
| WeakHashMap |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) { WeakHashMap whm = new WeakHashMap(); //将WeakHashMap中添加三个key-value对， //三个key都是匿名字符串对象（没有其他引用） whm.put(new String("语文") , new String("良好")); whm.put(new String("数学") , new String("及格")); whm.put(new String("英文") , new String("中等"));
//将WeakHashMap中添加一个key-value对， //该key是一个系统缓存的字符串对象。"java"是一个常量字符串强引用 whm.put("java" , new String("中等")); //输出whm对象，将看到4个key-value对。 System.out.println(whm); //{英文=中等, java=中等, 数学=及格, 语文=良好}
//通知系统立即进行垃圾回收 System.gc(); System.runFinalization(); //通常情况下，将只看到一个key-value对。 System.out.println(whm); //{java=中等} } |
|
| 结果 |
|
| 说明 |
如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让key所引用的对象具有任何强引用，否则将失去使用WeakHashMap的意义 |
|
|
|
| IdentityHashMap |
|
| @SuppressWarnings({ "unchecked", "rawtypes" }) public static void main(String[] args) { IdentityHashMap ihm = new IdentityHashMap(); //下面两行代码将会向IdentityHashMap对象中添加两个key-value对 ihm.put(new String("语文") , 89); ihm.put(new String("语文") , 78);
//下面两行代码只会向IdentityHashMap对象中添加一个key-value对 ihm.put("java" , 93); ihm.put("java" , 98); System.out.println(ihm); //{java=98, 语文=78, 语文=89} } |
|
| 结果 |
|
| 说明 |
|
|
|
|
| EnumMap |
|
| enum Season { SPRING,SUMMER,FALL,WINTER } public class Test { public static void main(String[] args) { //创建一个EnumMap对象，该EnumMap的所有key //必须是Season枚举类的枚举值 EnumMap enumMap = new EnumMap(Season.class); enumMap.put(Season.SUMMER , "夏日炎炎"); enumMap.put(Season.SPRING , "春暖花开");
System.out.println(enumMap); //{SPRING=春暖花开, SUMMER=夏日炎炎} } } |
|
| 结果 |
|
| 说明 |
|
| 与创建普通Map有所区别的是，创建EnumMap是必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来以上就是Map集合类的编程应用场景。我们来梳理一下思路 1) HashMap和Hashtable的效率大致相同，因为它们的实现机制几乎完全一样。但HashMap通常比Hashtable要快一点，因为Hashtable需要额外的线程同步控制 2) TreeMap通常比HashMap、Hashtable要慢(尤其是在插入、删除key-value对时更慢)，因为TreeMap底层采用红黑树来管理key-value对 3) 使用TreeMap的一个好处就是： TreeMap中的key-value对总是处于有序状态，无须专门进行排序操作 |
|