一、集合框架图
说明：对于以上的框架图有如下几点说明
1、所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。
2、集合接口：6个接口（短虚线表示），表示不同集合类型，是集合框架的基础。
3、抽象类：5个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。
4、实现类：8个实现类（实线表示），对接口的具体实现。
5、Collection 接口是一组允许重复的对象。
6、Set 接口继承 Collection，集合元素不重复。
7、List 接口继承 Collection，允许重复，维护元素插入顺序。
8、Map接口是键－值对象，与Collection接口没有什么关系。
9、Set、List和Map可以看做集合的三大类：
- List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。
- Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是集合里元素不允许重复的原因）。
- Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。
简化图：
二、总体分析
大致说明：
看上面的框架图，先抓住它的主干，即Collection和Map。
1、Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性。Collection包含了List和Set两大分支。
- List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0。List的实现类有LinkedList, ArrayList, Vector, Stack。
- Set是一个不允许有重复元素的集合。Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。
2、Map是一个映射接口，即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。Hashtable虽然继承于Dictionary，但它实现了Map接口。
3、接下来，再看Iterator。它是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。ListIterator是专门为遍历List而存在的。
4、再看Enumeration，它是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少。在上面的框图中，Enumeration只能在Hashtable, Vector, Stack中使用。
5、最后，看Arrays和Collections。它们是操作数组、集合的两个工具类。
有了上面的整体框架之后，我们接下来对每个类分别进行分析。
三、Collection接口
Collection接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法。Collection接口有两个主要的子接口List和Set，注意Map不是Collection的子接口，这个要牢记。
Collection接口中的方法如下:
其中，有几个比较常用的方法，比如方法add()添加一个元素到集合中，addAll()将指定集合中的所有元素添加到集合中，contains()方法检测集合中是否包含指定的元素，toArray()方法返回一个表示集合的数组。
另外，Collection中有一个iterator()函数，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合。ListIterator是List接口所特有的，在List接口中，通过ListIterator()返回一个ListIterator对象。
Collection接口有两个常用的子接口，下面详细介绍。
1.List接口
List集合代表一个有序集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。
List接口继承于Collection接口，它可以定义一个允许重复的有序集合。因为List中的元素是有序的，所以我们可以通过使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。
（1）ArrayList
ArrayList是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。
size、isEmpty、get、set、iterator和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。
ArrayList擅长于随机访问。同时ArrayList是非同步的。
添加元素
ArrayList 类提供了很多有用的方法，添加元素到 ArrayList 可以使用 add() 方法:
实例
**
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Taobao, Weibo]
访问元素
访问 ArrayList 中的元素可以使用 get() 方法：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites.get(1)); *// 访问第二个元素*
}
}
注意：数组的索引值从 0 开始。
以上实例，执行输出结果为：
Runoob
修改元素
如果要修改 ArrayList 中的元素可以使用 set() 方法：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.set(2, "Wiki"); *// 第一个参数为索引位置，第二个为要修改的值*
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Wiki, Weibo]
删除元素
如果要删除 ArrayList 中的元素可以使用 remove() 方法：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.remove(3); *// 删除第四个元素*
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Taobao]
计算大小
如果要计算 ArrayList 中的元素数量可以使用 size() 方法：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites.size());
}
}
以上实例，执行输出结果为：
4
迭代数组列表
我们可以使用 for 来迭代数组列表中的元素：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
**for** (**int** i = 0; i < sites.size(); i++) {
System.out.println(sites.get(i));
}
}
}
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo
也可以使用 for-each 来迭代元素：
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
**for** (String i : sites) {
System.out.println(i);
}
}
}
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo
其他的引用类型
ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。
如果我们要存储其他类型，而 只能为引用数据类型，这时我们就需要使用到基本类型的包装类。
基本类型对应的包装类表如下：
| 基本类型 | 引用类型 |
|---|---|
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。
ArrayList<Integer> li=new ArrayList<>(); // 存放整数元素
ArrayList<Character> li=new ArrayList<>(); // 存放字符元素
以下实例使用 ArrayList 存储数字(使用 Integer 类型):
实例
import** java.util.ArrayList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<Integer> myNumbers = **new** ArrayList<Integer>();
myNumbers.add(10);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(25);
**for** (**int** i : myNumbers) {
System.out.println(i);
}
}
}
以上实例，执行输出结果为：
10
15
20
25
ArrayList 排序
Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。
以下实例对字母进行排序：
实例
import** java.util.ArrayList;
**import** java.util.Collections; *// 引入 Collections 类*
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<String> sites = **new** ArrayList<String>();
sites.add("Taobao");
sites.add("Wiki");
sites.add("Runoob");
sites.add("Weibo");
sites.add("Google");
Collections.sort(sites); *// 字母排序*
**for** (String i : sites) {
System.out.println(i);
}
}
}
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo
Wiki
以下实例对数字进行排序：
实例
import** java.util.ArrayList;
**import** java.util.Collections; *// 引入 Collections 类*
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
ArrayList<Integer> myNumbers = **new** ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);
Collections.sort(myNumbers); *// 数字排序*
**for** (**int** i : myNumbers) {
System.out.println(i);
}
}
}
以上实例，执行输出结果为：
8
12
15
20
33
34
Java ArrayList 方法
Java ArrayList 常用方法列表如下：
| 方法 | 描述 |
|---|---|
| add() | 将元素插入到指定位置的 arraylist 中 |
| addAll() | 添加集合中的所有元素到 arraylist 中 |
| clear() | 删除 arraylist 中的所有元素 |
| clone() | 复制一份 arraylist |
| contains() | 判断元素是否在 arraylist |
| get() | 通过索引值获取 arraylist 中的元素 |
| indexOf() | 返回 arraylist 中元素的索引值 |
| removeAll() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| remove() | 删除 arraylist 里的单个元素 |
| size() | 返回 arraylist 里元素数量 |
| isEmpty() | 判断 arraylist 是否为空 |
| subList() | 截取部分 arraylist 的元素 |
| set() | 替换 arraylist 中指定索引的元素 |
| sort() | 对 arraylist 元素进行排序 |
| toArray() | 将 arraylist 转换为数组 |
| toString() | 将 arraylist 转换为字符串 |
| ensureCapacity() | 设置指定容量大小的 arraylist |
| lastIndexOf() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| retainAll() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| containsAll() | 查看 arraylist 是否包含指定集合中的所有元素 |
| trimToSize() | 将 arraylist 中的容量调整为数组中的元素个数 |
| removeRange() | 删除 arraylist 中指定索引之间存在的元素 |
| replaceAll() | 将给定的操作内容替换掉数组中每一个元素 |
| removeIf() | 删除所有满足特定条件的 arraylist 元素 |
| forEach() | 遍历 arraylist 中每一个元素并执行特定操作 |
（2）LinkedList
同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。
由于实现的方式不同，LinkedList不能随机访问，它所有的操作都是要按照双重链表的需要执行。在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。
与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(...));
创建一个简单的链表实例：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Taobao, Weibo]
更多的情况下我们使用 ArrayList 访问列表中的随机元素更加高效，但以下几种情况 LinkedList 提供了更高效的方法。
在列表开头添加元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
*// 使用 addFirst() 在头部添加元素*
sites.addFirst("Wiki");
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Wiki, Google, Runoob, Taobao]
在列表结尾添加元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
*// 使用 addLast() 在尾部添加元素*
sites.addLast("Wiki");
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Taobao, Wiki]
在列表开头移除元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
*// 使用 removeFirst() 移除头部元素*
sites.removeFirst();
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Runoob, Taobao, Weibo]
在列表结尾移除元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
*// 使用 removeLast() 移除尾部元素*
sites.removeLast();
System.out.println(sites);
}
}
以上实例，执行输出结果为：
[Google, Runoob, Taobao]
获取列表开头的元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
*// 使用 getFirst() 获取头部元素*
System.out.println(sites.getFirst());
}
}
以上实例，执行输出结果为：
Google
获取列表结尾的元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
*// 使用 getLast() 获取尾部元素*
System.out.println(sites.getLast());
}
}
以上实例，执行输出结果为：
Weibo
迭代元素
我们可以使用 for 配合 size() 方法来迭代列表中的元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
**for** (**int** size = sites.size(), i = 0; i < size; i++) {
System.out.println(sites.get(i));
}
}
}
size() 方法用于计算链表的大小。
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo
也可以使用 for-each 来迭代元素：
实例
// 引入 LinkedList 类*
**import** java.util.LinkedList;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
LinkedList<String> sites = **new** LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
**for** (String i : sites) {
System.out.println(i);
}
}
}
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo
常用方法
| 方法 | 描述 |
|---|---|
| public boolean add(E e) | 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public void add(int index, E element) | 向指定位置插入元素。 |
| public boolean addAll(Collection c) | 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。 |
| public boolean addAll(int index, Collection c) | 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。 |
| public void addFirst(E e) | 元素添加到头部。 |
| public void addLast(E e) | 元素添加到尾部。 |
| public boolean offer(E e) | 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerFirst(E e) | 头部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerLast(E e) | 尾部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public void clear() | 清空链表。 |
| public E removeFirst() | 删除并返回第一个元素。 |
| public E removeLast() | 删除并返回最后一个元素。 |
| public boolean remove(Object o) | 删除某一元素，返回是否成功，成功为 true，失败为 false。 |
| public E remove(int index) | 删除指定位置的元素。 |
| public E poll() | 删除并返回第一个元素。 |
| public E remove() | 删除并返回第一个元素。 |
| public boolean contains(Object o) | 判断是否含有某一元素。 |
| public E get(int index) | 返回指定位置的元素。 |
| public E getFirst() | 返回第一个元素。 |
| public E getLast() | 返回最后一个元素。 |
| public int indexOf(Object o) | 查找指定元素从前往后第一次出现的索引。 |
| public int lastIndexOf(Object o) | 查找指定元素最后一次出现的索引。 |
| public E peek() | 返回第一个元素。 |
| public E element() | 返回第一个元素。 |
| public E peekFirst() | 返回头部元素。 |
| public E peekLast() | 返回尾部元素。 |
| public E set(int index, E element) | 设置指定位置的元素。 |
| public Object clone() | 克隆该列表。 |
| public Iterator descendingIterator() | 返回倒序迭代器。 |
| public int size() | 返回链表元素个数。 |
| public ListIterator listIterator(int index) | 返回从指定位置开始到末尾的迭代器。 |
| public Object[] toArray() | 返回一个由链表元素组成的数组。 |
| public T[] toArray(T[] a) | 返回一个由链表元素转换类型而成的数组。 |
（3）Vector
与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。
（4）Stack
Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
2.Set接口
Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同样允许null的存在但是仅有一个。由于Set接口的特殊性，所有传入Set集合中的元素都必须不同，同时要注意任何可变对象，如果在对集合中元素进行操作时，导致e1.equals(e2)==true，则必定会产生某些问题。Set接口有三个具体实现类，分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。
Set是一种不包含重复的元素的Collection，无序，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
需要注意的是：虽然Set中元素没有顺序，但是元素在set中的位置是由该元素的HashCode决定的，其具体位置其实是固定的。
此外需要说明一点，在set接口中的不重复是有特殊要求的。
举一个例子：对象A和对象B，本来是不同的两个对象，正常情况下它们是能够放入到Set里面的，但是如果对象A和B的都重写了hashcode和equals方法，并且重写后的hashcode和equals方法是相同的话。那么A和B是不能同时放入到Set集合中去的，也就是Set集合中的去重和hashcode与equals方法直接相关。
为了更好地理解，请看下面的例子：
public class Test{
public static void main(String[] args) {
Set<String> set=new HashSet<String>();
set.add("Hello");
set.add("world");
set.add("Hello");
System.out.println("集合的尺寸为:"+set.size());
System.out.println("集合中的元素为:"+set.toString());
}
}
运行结果：
集合的尺寸为:2
集合中的元素为:[world, Hello]
分析：由于String类中重写了hashcode和equals方法，用来比较指向的字符串对象所存储的字符串是否相等。所以这里的第二个Hello是加不进去的。
再看一个例子：
public class TestSet {
public static void main(String[] args){
Set<String> books = new HashSet<String>();
//添加一个字符串对象
books.add(new String("Struts2权威指南"));
//再次添加一个字符串对象，
//因为两个字符串对象通过equals方法比较相等，所以添加失败，返回false
boolean result = books.add(new String("Struts2权威指南"));
System.out.println(result);
//下面输出看到集合只有一个元素
System.out.println(books);
}
}
运行结果：
false [Struts2权威指南]
说明：程序中，book集合两次添加的字符串对象明显不是一个对象（程序通过new关键字来创建字符串对象），当使用==运算符判断返回false，使用equals方法比较返回true，所以不能添加到Set集合中，最后只能输出一个元素。
（1）HashSet
HashSet 是一个没有重复元素的集合。它是由HashMap实现的，不保证元素的顺序(这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致)，而且HashSet允许使用null 元素。HashSet是非同步的，如果多个线程同时访问一个哈希set，而其中至少一个线程修改了该set，那么它必须保持外部同步。 HashSet按Hash算法来存储集合的元素，因此具有很好的存取和查找性能。
HashSet的实现方式大致如下，通过一个HashMap存储元素，元素是存放在HashMap的Key中，而Value统一使用一个Object对象。
HashSet使用和理解中容易出现的误区:
**a.HashSet中存放null值。**HashSet中是允许存入null值的，但是在HashSet中仅仅能够存入一个null值。
**b.HashSet中存储元素的位置是固定的。**HashSet中存储的元素的是无序的，这个没什么好说的，但是由于HashSet底层是基于Hash算法实现的，使用了hashcode，所以HashSet中相应的元素的位置是固定的。
c.必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
（2）LinkedHashSet
LinkedHashSet继承自HashSet，其底层是基于LinkedHashMap来实现的，有序，非同步。LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
（3）TreeSet
TreeSet是一个有序集合，其底层是基于TreeMap实现的，非线程安全。TreeSet可以确保集合元素处于排序状态。**TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。**当我们构造TreeSet时，若使用不带参数的构造函数，则TreeSet的使用自然比较器；若用户需要使用自定义的比较器，则需要使用带比较器的参数。
注意：TreeSet集合不是通过hashcode和equals函数来比较元素的.它是通过compare或者comparaeTo函数来判断元素是否相等.compare函数通过判断两个对象的id，相同的id判断为重复元素，不会被加入到集合中。
HashSet 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。
基本类型对应的包装类表如下：
| 基本类型 | 引用类型 |
|---|---|
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
HashSet 类位于 java.util 包中，使用前需要引入它，语法格式如下：
import java.util.HashSet; // 引入 HashSet 类
以下实例我们创建一个 HashSet 对象 sites，用于保存字符串元素：
HashSet<String> sites = new HashSet<String>();
添加元素
HashSet 类提供了很多有用的方法，添加元素可以使用 add() 方法:
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
System.out.println(sites);
}
}
执行以上代码，输出结果如下：
[Google, Runoob, Zhihu, Taobao]
在上面的实例中，Runoob 被添加了两次，它在集合中也只会出现一次，因为集合中的每个元素都必须是唯一的。
判断元素是否存在
我们可以使用 contains() 方法来判断元素是否存在于集合当中:
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
System.out.println(sites.contains("Taobao"));
}
}
执行以上代码，输出结果如下：
true
删除元素
我们可以使用 remove() 方法来删除集合中的元素:
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
sites.remove("Taobao"); *// 删除元素，删除成功返回 true，否则为 false*
System.out.println(sites);
}
}
执行以上代码，输出结果如下：
[Google, Runoob, Zhihu]
删除集合中所有元素可以使用 clear 方法：
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
sites.clear();
System.out.println(sites);
}
}
执行以上代码，输出结果如下：
[]
计算大小
如果要计算 HashSet 中的元素数量可以使用 size() 方法：
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
System.out.println(sites.size());
}
}
执行以上代码，输出结果如下：
4
迭代 HashSet
可以使用 for-each 来迭代 HashSet 中的元素。
实例
// 引入 HashSet 类*
**import** java.util.HashSet;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
HashSet<String> sites = **new** HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); *// 重复的元素不会被添加*
**for** (String i : sites) {
System.out.println(i);
}
}
}
执行以上代码，输出结果如下：
Google
Runoob
Zhihu
Taobao
四、Map接口
Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。
1.HashMap
以哈希表数据结构实现，查找对象时通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可能通过查看HashMap.Entry的源码它是一个单链表结构。
2.LinkedHashMap
LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。
**LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。**此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。
注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。由于LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。
3.TreeMap
**TreeMap 是一个有序的key-value集合，非同步，基于红黑树（Red-Black tree）实现，每一个key-value节点作为红黑树的一个节点。**TreeMap存储时会进行排序的，会根据key来对key-value键值对进行排序，其中排序方式也是分为两种，一种是自然排序，一种是定制排序，具体取决于使用的构造方法。
**自然排序：**TreeMap中所有的key必须实现Comparable接口，并且所有的key都应该是同一个类的对象，否则会报ClassCastException异常。
**定制排序：**定义TreeMap时，创建一个comparator对象，该对象对所有的treeMap中所有的key值进行排序，采用定制排序的时候不需要TreeMap中所有的key必须实现Comparable接口。
TreeMap判断两个元素相等的标准：两个key通过compareTo()方法返回0，则认为这两个key相等。
如果使用自定义的类来作为TreeMap中的key值，且想让TreeMap能够良好的工作，则必须重写自定义类中的equals()方法，TreeMap中判断相等的标准是：两个key通过equals()方法返回为true，并且通过compareTo()方法比较应该返回为0。
HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。
基本类型对应的包装类表如下：
| 基本类型 | 引用类型 |
|---|---|
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：
import java.util.HashMap; // 引入 HashMap 类
以下实例我们创建一个 HashMap 对象 Sites， 整型（Integer）的 key 和字符串（String）类型的 value：
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
添加元素
HashMap 类提供了很多有用的方法，添加键值对(key-value)可以使用 put() 方法:
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
System.out.println(Sites);
}
}
执行以上代码，输出结果如下：
{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
以下实例创建一个字符串（String）类型的 key 和字符串（String）类型的 value：
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<String, String> Sites = **new** HashMap<String, String>();
*// 添加键值对*
Sites.put("one", "Google");
Sites.put("two", "Runoob");
Sites.put("three", "Taobao");
Sites.put("four", "Zhihu");
System.out.println(Sites);
}
}
执行以上代码，输出结果如下：
{four=Zhihu, one=Google, two=Runoob, three=Taobao}
访问元素
我们可以使用 get(key) 方法来获取 key 对应的 value:
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
System.out.println(Sites.get(3));
}
}
执行以上代码，输出结果如下：
Taobao
删除元素
我们可以使用 remove(key) 方法来删除 key 对应的键值对(key-value):
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
Sites.remove(4);
System.out.println(Sites);
}
}
执行以上代码，输出结果如下：
{1=Google, 2=Runoob, 3=Taobao}
删除所有键值对(key-value)可以使用 clear 方法：
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
Sites.clear();
System.out.println(Sites);
}
}
执行以上代码，输出结果如下：
{}
计算大小
如果要计算 HashMap 中的元素数量可以使用 size() 方法：
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
System.out.println(Sites.size());
}
}
执行以上代码，输出结果如下：
4
迭代 HashMap
可以使用 for-each 来迭代 HashMap 中的元素。
如果你只想获取 key，可以使用 keySet() 方法，然后可以通过 get(key) 获取对应的 value，如果你只想获取 value，可以使用 values() 方法。
实例
// 引入 HashMap 类*
**import** java.util.HashMap;
**public** **class** RunoobTest {
**public** **static** **void** main(String[] args) {
*// 创建 HashMap 对象 Sites*
HashMap<Integer, String> Sites = **new** HashMap<Integer, String>();
*// 添加键值对*
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
*// 输出 key 和 value*
**for** (Integer i : Sites.keySet()) {
System.out.println("key: " + i + " value: " + Sites.get(i));
}
*// 返回所有 value 值*
**for**(String value: Sites.values()) {
*// 输出每一个value*
System.out.print(value + ", ");
}
}
}
执行以上代码，输出结果如下：
key: 1 value: Google
key: 2 value: Runoob
key: 3 value: Taobao
key: 4 value: Zhihu
Google, Runoob, Taobao, Zhihu,
Java HashMap 方法
hashmap
Java HashMap 常用方法列表如下：
| 方法 | 描述 |
|---|---|
| clear() | 删除 hashMap 中的所有键/值对 |
| clone() | 复制一份 hashMap |
| isEmpty() | 判断 hashMap 是否为空 |
| size() | 计算 hashMap 中键/值对的数量 |
| put() | 将键/值对添加到 hashMap 中 |
| putAll() | 将所有键/值对添加到 hashMap 中 |
| putIfAbsent() | 如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。 |
| remove() | 删除 hashMap 中指定键 key 的映射关系 |
| containsKey() | 检查 hashMap 中是否存在指定的 key 对应的映射关系。 |
| containsValue() | 检查 hashMap 中是否存在指定的 value 对应的映射关系。 |
| replace() | 替换 hashMap 中是指定的 key 对应的 value。 |
| replaceAll() | 将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。 |
| get() | 获取指定 key 对应对 value |
| getOrDefault() | 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值 |
| forEach() | 对 hashMap 中的每个映射执行指定的操作。 |
| entrySet() | 返回 hashMap 中所有映射项的集合集合视图。 |
| keySet() | 返回 hashMap 中所有 key 组成的集合视图。 |
| values() | 返回 hashMap 中存在的所有 value 值。 |
| merge() | 添加键值对到 hashMap 中 |
| compute() | 对 hashMap 中指定 key 的值进行重新计算 |
| computeIfAbsent() | 对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中 |
| computeIfPresent() | 对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。 |
集合接口
集合框架定义了一些接口。本节提供了每个接口的概述：
| 序号 | 接口描述 |
|---|---|
| 1 | Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。Collection 接口存储一组不唯一，无序的对象。 |
| 2 | List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。List 接口存储一组不唯一，有序（插入顺序）的对象。 |
| 3 | Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。Set 接口存储一组唯一，无序的对象。 |
| 4 | SortedSet 继承于Set保存有序的集合。 |
| 5 | Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。 |
| 6 | Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。 |
| 7 | SortedMap 继承于 Map，使 Key 保持在升序排列。 |
| 8 | Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。 |
Set和List的区别
- \1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
- \2. Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
- \3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
集合实现类（集合类）
Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。
标准集合类汇总于下表：
| 序号 | 类描述 |
|---|---|
| 1 | AbstractCollection 实现了大部分的集合接口。 |
| 2 | AbstractList 继承于AbstractCollection 并且实现了大部分List接口。 |
| 3 | AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。 |
| 4 | LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：List list=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。 |
| 5 | ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。 |
| 6 | AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。 |
| 7 | HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。 |
| 8 | LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。 |
| 9 | TreeSet 该类实现了Set接口，可以实现排序等功能。 |
| 10 | AbstractMap 实现了大部分的Map接口。 |
| 11 | HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。 |
| 12 | TreeMap 继承了AbstractMap，并且使用一颗树。 |
| 13 | WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。 |
| 14 | LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序. |
| 15 | IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。 |
在前面的教程中已经讨论通过java.util包中定义的类，如下所示：
| 序号 | 类描述 |
|---|---|
| 1 | Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。 |
| 2 | Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。 |
| 3 | Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。 |
| 4 | Hashtable Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。 |
| 5 | Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。 |
| 6 | BitSet 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。 |
集合算法
集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。
在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。
集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。
| 序号 | 算法描述 |
|---|---|
| 1 | Collection Algorithms 这里是一个列表中的所有算法实现。 |
如何使用迭代器
通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。
一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。
迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。
| 序号 | 迭代器方法描述 |
|---|---|
| 1 | 使用 Java Iterator 这里通过实例列出 Iterator 和 ListIterator 接口提供的所有方法。 |
遍历 ArrayList
实例
import java.util.*;
public class Test{
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");
//第一种遍历方法使用 For-Each 遍历 List
for (String str : list) { //也可以改写 for(int i=0;i<list.size();i++) 这种形式
System.out.println(str);
}
//第二种遍历，把链表变为数组相关的内容进行遍历
String[] strArray=new String[list.size()];
list.toArray(strArray);
for(int i=0;i<strArray.length;i++) //这里也可以改写为 for(String str:strArray) 这种形式
{
System.out.println(strArray[i]);
}
//第三种遍历 使用迭代器进行相关遍历
Iterator<String> ite=list.iterator();
while(ite.hasNext())//判断下一个元素之后有值
{
System.out.println(ite.next());
}
}
}
解析：
三种方法都是用来遍历ArrayList集合，第三种方法是采用迭代器的方法，该方法可以不用担心在遍历的过程中会超出集合的长度。
遍历 Map
实例
import java.util.*;
public class Test{
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第一种：普遍使用，二次取值
System.out.println("通过Map.keySet遍历key和value：");
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}
//第二种
System.out.println("通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第三种：推荐，尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第四种
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
System.out.println("value= " + v);
}
}
}
五、Iterator 与 ListIterator详解
1.Iterator
Iterator的定义如下：
public interface Iterator<E> {}
Iterator是一个接口，它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。
Iterator提供的API接口如下：
- boolean hasNext()：判断集合里是否存在下一个元素。如果有，hasNext()方法返回 true。
- Object next()：返回集合里下一个元素。
- void remove()：删除集合里上一次next方法返回的元素。
使用示例：
public class IteratorExample {
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>();
a.add("aaa");
a.add("bbb");
a.add("ccc");
System.out.println("Before iterate : " + a);
Iterator<String> it = a.iterator();
while (it.hasNext()) {
String t = it.next();
if ("bbb".equals(t)) {
it.remove();
}
}
System.out.println("After iterate : " + a);
}
}
输出结果如下：
Before iterate : [aaa, bbb, ccc]
After iterate : [aaa, ccc]
注意：
- Iterator只能单向移动。
- Iterator.remove()是唯一安全的方式来在迭代过程中修改集合；如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。而且每调用一次
next()方法，remove()方法只能被调用一次，如果违反这个规则将抛出一个异常。
2.ListIterator
**ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口，**只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。
ListIterator接口定义如下:
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();
E next();
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void remove();
void set(E e);
void add(E e);
}
由以上定义我们可以推出ListIterator可以:
- 双向移动（向前/向后遍历）.
- 产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.
- 可以使用
set()方法替换它访问过的最后一个元素. - 可以使用
add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.
使用示例：
public class ListIteratorExample {
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>();
a.add("aaa");
a.add("bbb");
a.add("ccc");
System.out.println("Before iterate : " + a);
ListIterator<String> it = a.listIterator();
while (it.hasNext()) {
System.out.println(it.next() + ", " + it.previousIndex() + ", " + it.nextIndex());
}
while (it.hasPrevious()) {
System.out.print(it.previous() + " ");
}
System.out.println();
it = a.listIterator(1);
while (it.hasNext()) {
String t = it.next();
System.out.println(t);
if ("ccc".equals(t)) {
it.set("nnn");
} else {
it.add("kkk");
}
}
System.out.println("After iterate : " + a);
}
}
输出结果如下：
Before iterate : [aaa, bbb, ccc]
aaa, 0, 1
bbb, 1, 2
ccc, 2, 3
ccc bbb aaa
bbb
ccc
After iterate : [aaa, bbb, kkk, nnn]
六、异同点
1.ArrayList和LinkedList
- ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
- 对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。
- 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
这一点要看实际情况的。**若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。**但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。
2.HashTable与HashMap
相同点：
- 都实现了
Map、Cloneable、java.io.Serializable接口。 - 都是存储"键值对(key-value)"的散列表，而且都是采用拉链法实现的。
不同点：
**（1）历史原因：**HashTable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 。
**（2）同步性：**HashTable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 。
**（3）对null值的处理：**HashMap的key、value都可为null，HashTable的key、value都不可为null 。
**（4）基类不同：**HashMap继承于AbstractMap，而Hashtable继承于Dictionary。
- Dictionary是一个抽象类，它直接继承于Object类，没有实现任何接口。Dictionary类是JDK 1.0的引入的。虽然Dictionary也支持“添加key-value键值对”、“获取value”、“获取大小”等基本操作，但它的API函数比Map少；而且Dictionary一般是通过Enumeration(枚举类)去遍历，Map则是通过Iterator(迭代M器)去遍历。然而由于Hashtable也实现了Map接口，所以，它即支持Enumeration遍历，也支持Iterator遍历。
- AbstractMap是一个抽象类，它实现了Map接口的绝大部分API函数；为Map的具体实现类提供了极大的便利。它是JDK 1.2新增的类。
**（5）支持的遍历种类不同：**HashMap只支持Iterator(迭代器)遍历。而Hashtable支持Iterator(迭代器)和Enumeration(枚举器)两种方式遍历。
3.HashMap、Hashtable、LinkedHashMap和TreeMap比较
Hashmap 是一个最常用的Map，它根据键的HashCode 值存储数据，根据键可以直接获取它的值，具有很快的访问速度。遍历时，取得数据的顺序是完全随机的。**HashMap最多只允许一条记录的键为Null；允许多条记录的值为Null；HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap；可能会导致数据的不一致。**如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力。
Hashtable 与 HashMap类似，不同的是：它不允许记录的键或者值为空；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢。
LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的，也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。
如果需要输出的顺序和输入的相同，那么用LinkedHashMap可以实现，它还可以按读取顺序来排列，像连接池中可以应用。LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。对于LinkedHashMap而言，它继承与HashMap、底层使用哈希表与双向链表来保存所有元素。其基本操作与父类HashMap相似，它通过重写父类相关的方法，来实现自己的链接列表特性。
**TreeMap实现SortMap接口，内部实现是红黑树。**能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
一般情况下，我们用的最多的是HashMap，HashMap里面存入的键值对在取出的时候是随机的，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。
LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同，那么用LinkedHashMap可以实现，它还可以按读取顺序来排列，像连接池中可以应用。
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.TreeMap;
public class MapTest {
public static void main(String[] args) {
//HashMap
HashMap<String,String> hashMap = new HashMap();
hashMap.put("4", "d");
hashMap.put("3", "c");
hashMap.put("2", "b");
hashMap.put("1", "a");
Iterator<String> iteratorHashMap = hashMap.keySet().iterator();
System.out.println("HashMap-->");
while (iteratorHashMap.hasNext()){
Object key1 = iteratorHashMap.next();
System.out.println(key1 + "--" + hashMap.get(key1));
}
//LinkedHashMap
LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap();
linkedHashMap.put("4", "d");
linkedHashMap.put("3", "c");
linkedHashMap.put("2", "b");
linkedHashMap.put("1", "a");
Iterator<String> iteratorLinkedHashMap = linkedHashMap.keySet().iterator();
System.out.println("LinkedHashMap-->");
while (iteratorLinkedHashMap.hasNext()){
Object key2 = iteratorLinkedHashMap.next();
System.out.println(key2 + "--" + linkedHashMap.get(key2));
}
//TreeMap
TreeMap<String,String> treeMap = new TreeMap();
treeMap.put("4", "d");
treeMap.put("3", "c");
treeMap.put("2", "b");
treeMap.put("1", "a");
Iterator<String> iteratorTreeMap = treeMap.keySet().iterator();
System.out.println("TreeMap-->");
while (iteratorTreeMap.hasNext()){
Object key3 = iteratorTreeMap.next();
System.out.println(key3 + "--" + treeMap.get(key3));
}
}
}
输出结果：
HashMap-->
3--c
2--b
1--a
4--d
LinkedHashMap-->
4--d
3--c
2--b
1--a
TreeMap-->
1--a
2--b
3--c
4--d
4.HashSet、LinkedHashSet、TreeSet比较
Set接口
Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。
**Set判断两个对象相同不是使用==运算符，而是根据equals方法。**也就是说，只要两个对象用equals方法比较返回true，Set就不会接受这两个对象。
HashSet
HashSet有以下特点：
- 不能保证元素的排列顺序，顺序有可能发生变化。
- 不是同步的。
- 集合元素可以是null，但只能放入一个null。
当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值也相等。
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。
LinkedHashSet
LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。
TreeSet类
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0。
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个
compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是负数，则表明obj1小于obj2。如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0。
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。
package com.test;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
/**
* @description 几个set的比较
* HashSet：哈希表是通过使用称为散列法的机制来存储信息的，元素并没有以某种特定顺序来存放；
* LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代；
* TreeSet：提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快。
* @author Zhou-Jingxian
*
*/
public class SetDemo {
public static void main(String[] args) {
HashSet<String> hs = new HashSet<String>();
hs.add("B");
hs.add("A");
hs.add("D");
hs.add("E");
hs.add("C");
hs.add("F");
System.out.println("HashSet 顺序:\n"+hs);
LinkedHashSet<String> lhs = new LinkedHashSet<String>();
lhs.add("B");
lhs.add("A");
lhs.add("D");
lhs.add("E");
lhs.add("C");
lhs.add("F");
System.out.println("LinkedHashSet 顺序:\n"+lhs);
TreeSet<String> ts = new TreeSet<String>();
ts.add("B");
ts.add("A");
ts.add("D");
ts.add("E");
ts.add("C");
ts.add("F");
System.out.println("TreeSet 顺序:\n"+ts);
}
}
输出结果：
HashSet 顺序:[D, E, F, A, B, C]
LinkedHashSet 顺序:[B, A, D, E, C, F]
TreeSet 顺序:[A, B, C, D, E, F]
5、Iterator和ListIterator区别
我们在使用List，Set的时候，为了实现对其数据的遍历，我们经常使用到了Iterator(迭代器)。使用迭代器，你不需要干涉其遍历的过程，只需要每次取出一个你想要的数据进行处理就可以了。但是在使用的时候也是有不同的。
List和Set都有iterator()来取得其迭代器。对List来说，你也可以通过listIterator()取得其迭代器，两种迭代器在有些时候是不能通用的，Iterator和ListIterator主要区别在以下方面：
- ListIterator有
add()方法，可以向List中添加对象，而Iterator不能 - ListIterator和Iterator都有
hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。 - ListIterator可以定位当前的索引位置，
nextIndex()和previousIndex()可以实现。Iterator没有此功能。 - 都可实现删除对象，但是ListIterator可以实现对象的修改，
set()方法可以实现。Iierator仅能遍历，不能修改。
因为ListIterator的这些功能，可以实现对LinkedList等List数据结构的操作。其实，数组对象也可以用迭代器来实现。
6、Collection 和 Collections区别
**（1）java.util.Collection 是一个集合接口（集合类的一个顶级接口）。**它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
**（2）java.util.Collections 是一个包装类（工具类/帮助类）。**它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，用于对集合中元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。
代码示例：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestCollections {
public static void main(String args[]) {
//注意List是实现Collection接口的
List list = new ArrayList();
double array[] = { 112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
System.out.println(list.get(i));
}
// 结果：23.0 111.0 112.0 231.0 456.0
}
}
