Java基础知识（18）- Java 集合框架 (Collection Framework)

1. Java 集合简介

Java 的初期版本提供了 Dictionary, Vector, Stack, 和 Properties 等类用来存储和操作对象组。

这些类的功能很有用，但是它们缺少一个核心的、统一的主题（或基类），相互之间缺乏互操作性。比如，使用 Vector 类和使用 Properties 类的方式有很大的不同，两者的兼容性很差。

之后 Java 的版本提供了集合，集合就是一个用来存放对象的容器，比如 ArrayList、HashMap 等。

1) 集合的特点：

(1) 长度可以发生改变；
(2) 只能存储对象；
(3) 可以存储多种类型对象；

2) 集合与数组区别：

	数组	集合
长度	固定	可变
存储元素	基本类型/引用类型	引用类型
元素类型的一致性	必须一致	可以不一致

2. Java 集合框架

3. Collection 接口

    Collection 接口是 Java 集合框架的一个基础接口，Collection 也称为单列集合，一次可以添加一个元素。

    Collection 接口有 3 种子类型集合: List、Set 和 Queue，常用的实现类有 ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue 等。

    Collection 的方法：

方法	描述
boolean add(Object obj)	向集合中添加一个元素
boolean addAll(Collection c)	向集合中添加一个集合的元素
void clear()	删除集合中的所有元素
boolean remove(Object obj)	从集合中删除指定的元素
boolean removeAll(Collection c)	从集合中删除一个指定的集合元素
boolean isEmpty()	判断集合是否为空
boolean contains(Object obj)	判断集合中是否存在指定的元素
boolean containsAll(Collection c)	判断集合中是否存在指定的一个集合中的元素
Iterator iterator()	迭代器，用来遍历集合中每一个元素
int size()	获取集合中的元素个数
boolean retainAll(Collection c)	判断两个集合中是否有相同的元素
Object[] toArray()	把集合变成数组

4. Map 接口

    Map 接口也是 Java 集合框架的一个基础接口，Map 也被称为双列集合，每次可以添加一对元素。双列集合就是以键值对的形式存储数据，键不能重复，键具有唯一性。

    Map 保存具有映射关系的数据，因此 Map 集合里保存着两组数，一组值是 Map 里的 key，另一组是 Map 里的 value，key 和 value 都可以是任何引用类型的数据。

    Map 的方法：

方法	描述
Object put(Object k, Object v)	将指定的值与此映射中的指定键关联（可选操作）
void putAll(Map m)	从指定映射中将所有映射关系复制到此映射中（可选操作）
void clear()	从此映射中移除所有映射关系（可选操作）
Object remove(Object k)	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
boolean isEmpty()	如果此映射未包含键-值映射关系，则返回 true
boolean containsKey(Object k)	如果此映射包含指定键的映射关系，则返回 true
boolean containsValue(Object v)	如果此映射将一个或多个键映射到指定值，则返回 true
boolean equals(Object obj)	比较指定的对象与此映射是否相等
Object get(Object k)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
int size()	返回此映射中的键-值映射关系数
int hashCode()	返回此映射的哈希码值
Set entrySet()	返回此映射中包含的映射关系的 Set 视图
Set keySet()	返回此映射中包含的键的 Set 视图
Collection values()	返回此映射中包含的值的 Collection 视图

5. Iterator（迭代器）

    Java 集合框架的集合类(或称为容器)，容器的种类有很多种，比如 ArrayList、LinkedList、HashSet 等，每种容器都有自己的特点，每种容器都有自己特有的数据结构。

    因为容器的内部结构不同，很多时候可能不知道该怎样去遍历一个容器中的元素。所以为了使对容器内元素的操作更为简单，Java引入了迭代器模式！把访问逻辑从不同类型的集合类中抽取出来，从而避免向外部暴露集合的内部结构。

    迭代器模式：就是提供一种方法对一个容器对象中的各个元素进行访问，而又不暴露该对象容器的内部细节。

    Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，Iterator 是 Java 迭代器最简单的实现。

    Iterator（迭代器）的基本操作：

        (1) next 返回迭代器的下一个元素，并且更新迭代器的状态;
        (2) hasNext() 用于检测集合中是否还有元素;
        (3) remove() 将迭代器返回的元素删除;

    这里以 ArrayList 为例，操作迭代器：

 1         // 创建 ArrayList 集合
 2         ArrayList<String> testList = new ArrayList<String>();
 3         testList.add("Array List");
 4         testList.add("Tree Set");
 5         testList.add("Hash Map");
 6 
 7         // 获取迭代器
 8         Iterator<String> it = testList.iterator();
 9 
10         // 遍历集合
11         while(it.hasNext()) {
12             System.out.println(it.next());
13         }

　　实例：

 1     import java.util.ArrayList;
 2     import java.util.Iterator;
 3     import java.util.HashMap;
 4 
 5     public class App {
 6         public static void main( String[] args ) {
 7 
 8             // 创建 ArrayList 集合
 9             ArrayList<String> arrayList = new ArrayList<String>();
10             arrayList.add("Array List");
11             arrayList.add("Tree Set");
12             arrayList.add("Hash Map");
13             System.out.println(arrayList);
14 
15             // 用迭代器遍历集合
16             Iterator<String> it = arrayList.iterator();
17             while (it.hasNext()) {
18                 System.out.println("arrayList(iterator): " + it.next());
19             }
20 
21             // 用 for 循环遍历集合
22             for (String str : arrayList) {
23                 System.out.println("arrayList(for): " + str);
24             }
25 
26             // 删除元素
27             arrayList.remove(1);
28             System.out.println(arrayList);
29 
30             System.out.println("-------------------------------------------------");
31 
32             // 创建 HashMap 集合
33             HashMap<Integer, String> map = new HashMap<Integer, String>();
34             map.put(1, "Hash Map");
35             map.put(2, "Hash Set");
36             map.put(3, "String Map");
37             map.put(4, "String Set");
38 
39             // 输出 key 和 value
40             for (Integer i : map.keySet()) {
41                 System.out.println("key: " + i + ", value: " + map.get(i));
42             }
43 
44             // 输出 value
45             for (String value: map.values()) {
46                 System.out.println(value);
47             }
48 
49         }
50     }

　　输出：

    [Array List, Tree Set, Hash Map]
    arrayList(iterator): Array List
    arrayList(iterator): Tree Set
    arrayList(iterator): Hash Map
    arrayList(for): Array List
    arrayList(for): Tree Set
    arrayList(for): Hash Map
    [Array List, Hash Map]
    -------------------------------------------------
    key: 1, value: Hash Map
    key: 2, value: Hash Set
    key: 3, value: String Map
    key: 4, value: String Set
    Hash Map
    Hash Set
    String Map
    String Set