集合讲解

最新推荐文章于 2022-10-31 23:06:10 发布

转载最新推荐文章于 2022-10-31 23:06:10 发布 · 559 阅读

本文深入探讨Java集合框架的核心概念、使用方法及其在实际编程中的应用，包括集合接口、迭代器、映射等关键组件。

本讲内容：集合 collection

讲集合collection之前，我们先分清三个概念：

colection 集合，用来表示任何一种数据结构
Collection 集合接口，指的是 java.util.Collection接口，是 Set、List 和 Queue 接口的超类接口
Collections 集合工具类，指的是 java.util.Collections 类。

SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个 Iterator 接口也是必须了解的。

SCJP考试要求了解的类有： HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays

下面给出一个集合之间的关系图：

上图中加粗线的ArrayList 和 HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。

我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。

List 关注事物的索引列表
Set 关注事物的唯一性
Queue 关注事物被处理时的顺序
Map 关注事物的映射和键值的唯一性

一、Collection 接口

Collection接口是 Set 、List 和 Queue 接口的父接口，提供了多数集合常用的方法声明，包括 add()、remove()、contains() 、size() 、iterator() 等。

add(E e)	将指定对象添加到集合中
remove(Object o)	将指定的对象从集合中移除，移除成功返回true,不成功返回false
contains(Object o)	查看该集合中是否包含指定的对象，包含返回true,不包含返回flase
size()	返回集合中存放的对象的个数。返回值为int
clear()	移除该集合中的所有对象，清空该集合。
iterator()	返回一个包含所有对象的iterator对象，用来循环遍历
toArray()	返回一个包含所有对象的数组,类型是Object
toArray(T[] t)	返回一个包含所有对象的指定类型的数组

我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：

 
import java.util.ArrayList;
 
import java.util.Collection;
 
 
 
public class CollectionTest {
 
 
 
    public static void main(String[] args) {
 
 
 
        String a = "a",b="b",c="c";
 
        Collection list = new ArrayList();
 
        list.add(a);
 
        list.add(b);
 
        list.add(c);
 
 
 
        String[] array =  list.toArray(new String[1]);
 
 
 
        for(String s : array){
 
            System.out.println(s);
 
        }
 
    }
 
}

编译并运行程序，检查结果：

二、几个比较重要的接口和类简介

1、List接口

List 关心的是索引，与其他集合相比，List特有的就是和索引相关的一些方法：get(int index) 、 add(int index,Object o) 、 indexOf(Object o) 。

ArrayList 可以将它理解成一个可增长的数组，它提供快速迭代和快速随机访问的能力。

LinkedList 中的元素之间是双链接的，当需要快速插入和删除时LinkedList成为List中的不二选择。

Vector 是ArrayList的线程安全版本，性能比ArrayList要低，现在已经很少使用

2、Set接口

Set关心唯一性，它不允许重复。

HashSet 当不希望集合中有重复值，并且不关心元素之间的顺序时可以使用此类。

LinkedHashset 当不希望集合中有重复值，并且希望按照元素的插入顺序进行迭代遍历时可采用此类。

TreeSet 当不希望集合中有重复值，并且希望按照元素的自然顺序进行排序时可以采用此类。（自然顺序意思是某种和插入顺序无关，而是和元素本身的内容和特质有关的排序方式，譬如“abc”排在“abd”前面。）

3、Queue接口

Queue用于保存将要执行的任务列表。

LinkedList 同样实现了Queue接口，可以实现先进先出的队列。

PriorityQueue 用来创建自然排序的优先级队列。番外篇中有个例子http://android.yaohuiji.com/archives/3454你可以看一下。

4、Map接口

Map关心的是唯一的标识符。他将唯一的键映射到某个元素。当然键和值都是对象。

HashMap 当需要键值对表示，又不关心顺序时可采用HashMap。

Hashtable 注意Hashtable中的t是小写的，它是HashMap的线程安全版本，现在已经很少使用。

LinkedHashMap 当需要键值对，并且关心插入顺序时可采用它。

TreeMap 当需要键值对，并关心元素的自然排序时可采用它。

三、ArrayList的使用

ArrayList是一个可变长的数组实现，读取效率很高，是最常用的集合类型。

1、ArrayList的创建

在Java5版本之前我们使用：

 
    1 List list = new ArrayList();

在Java5版本之后，我们使用带泛型的写法：

 
    1 List<String> list = new ArrayList<String>();

上面的代码定义了一个只允许保存字符串的列表，尖括号括住的类型就是参数类型，也成泛型。带泛型的写法给了我们一个类型安全的集合。关于泛型的知识可以参见这里。

２、ArrayList的使用：

 
List<String> list = new ArrayList<String>();
 
list.add("nihao!");
 
list.add("hi!");
 
list.add("konikiwa!");
 
list.add("hola");
 
list.add("Bonjour");
 
System.out.println(list.size());
 
System.out.println(list.contains(21));
 
System.out.println(list.remove("hi!"));
 
System.out.println(list.size());

关于List接口中的方法和ArrayList中的方法，大家可以看看JDK中的帮助。

3、基本数据类型的的自动装箱：

我们知道集合中存放的是对象，而不能是基本数据类型，在Java5之后可以使用自动装箱功能，更方便的导入基本数据类型。

 
List<Integer> list = new ArrayList<Integer>();
 
list.add(new Integer(42));
 
list.add(43);

4、ArrayList的排序：

ArrayList本身不具备排序能力，但是我们可以使用Collections类的sort方法使其排序。我们看一个例子：

 
import java.util.ArrayList;
 
import java.util.Collections;
 
import java.util.List;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
        List<String> list = new ArrayList<String>();
 
        list.add("nihao!");
 
        list.add("hi!");
 
        list.add("konikiwa!");
 
        list.add("hola");
 
        list.add("Bonjour");
 
 
 
        System.out.println("排序前："+ list);
 
 
 
        Collections.sort(list);
 
 
 
        System.out.println("排序后："+ list);
 
    }
 
 
 
}

编译并运行程序查看结果：

排序前：[nihao!, hi!, konikiwa!, hola, Bonjour]

排序后：[Bonjour, hi!, hola, konikiwa!, nihao!]

5、数组和List之间的转换

从数组转换成list，可以使用Arrays类的asList()方法：

 
import java.util.ArrayList;
 
import java.util.Collections;
 
import java.util.List;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
 
 
            String[] sa = {"one","two","three","four"};
 
            List list = Arrays.asList(sa);
 
            System.out.println("list:"+list);
 
            System.out.println("list.size()="+list.size());
 
    }
 
 
 
}

6、Iterator和for-each

在for-each出现之前，我们想遍历ArrayList中的每个元素我们会使用Iterator接口：

 
import java.util.Arrays;
 
import java.util.Iterator;
 
import java.util.List;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
 
 
        // Arrays类为我们提供了一种list的便捷创建方式
 
        List<String> list = Arrays.asList("one", "two", "three", "four");
 
 
 
        // 转换成Iterator实例
 
        Iterator<String> it = list.iterator();
 
 
 
        //遍历
 
        while (it.hasNext()) {
 
            System.out.println(it.next());
 
        }
 
 
 
    }
 
 
 
}

在for-each出现之后，遍历变得简单一些：

`01`	`import` `java.util.Arrays;`

`02`	`import` `java.util.Iterator;`

`03`	`import` `java.util.List;`

04

`05`	`public` `class` `Test {`

06

`07`	`public` `static` `void` `main(String[] args) {`

08

`09`	`// Arrays类为我们提供了一种list的便捷创建方式`

`10`	`List<String> list = Arrays.asList("one",` `"two",` `"three",` `"four");`

11

`12`	`for` `(String s : list) {`

`13`	`System.out.println(s);`

14 }

15

16 }

17

18 }

本讲内容：Map HashMap

前面课程中我们知道Map是个接口，它关心的是映射关系，它里面的元素是成对出现的，键和值都是对象且键必须保持唯一。这一点上看它和Collection是很不相同的。

一、Map接口

Map接口的常用方法如下表所示：

put(K key, V value)	向集合中添加指定的键值对
putAll(Map <? extends K,? extends V> t)	把一个Map中的所有键值对添加到该集合
containsKey(Object key)	如果包含该键，则返回true
containsValue(Object value)	如果包含该值，则返回true
get(Object key)	根据键,返回相应的值对象
keySet()	将该集合中的所有键以Set集合形式返回
values()	将该集合中所有的值以Collection形式返回
remove(Object key)	如果存在指定的键，则移除该键值对，返回键所对应的值，如果不存在则返回null
clear()	移除Map中的所有键值对，或者说就是清空集合
isEmpty()	查看Map中是否存在键值对
size()	查看集合中包含键值对的个数，返回int类型

因为Map中的键必须是唯一的，所以虽然键可以是null，只能由一个键是null，而Map中的值可没有这种限制，值为null的情况经常出现，因此get(Object key)方法返回null,有两种情况一种是确实不存在该键值对，二是该键对应的值对象为null。为了确保某Map中确实有某个键，应该使用的方法是 containsKey(Object key) 。

二、HashMap

HashMap是最常用的Map集合，它的键值对在存储时要根据键的哈希码来确定值放在哪里。

1、HashMap的基本使用：

 
import java.util.Collection;
 
import java.util.HashMap;
 
import java.util.Map;
 
import java.util.Set;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
 
 
        Map<Integer,String> map = new HashMap<Integer,String>();
 
 
 
        map.put(1, "白菜");
 
        map.put(2, "萝卜");
 
        map.put(3, "茄子");
 
        map.put(4, null);
 
        map.put(null, null);
 
        map.put(null, null);
 
 
 
        System.out.println("map.size()="+map.size());
 
        System.out.println("map.containsKey(1)="+map.containsKey(2));
 
        System.out.println("map.containsKey(null)="+map.containsKey(null));
 
        System.out.println("map.get(null)="+map.get(null));
 
 
 
        System.out.println("map.get(2)="+map.get(2));
 
        map.put(null, "黄瓜");
 
        System.out.println("map.get(null)="+map.get(null));
 
 
 
        Set set = map.keySet();
 
        System.out.println("set="+set);
 
 
 
        Collection<String> c = map.values();
 
 
 
        System.out.println("Collection="+c);
 
 
 
    }
 
 
 
}

编译并运行程序，查看结果：

 
map.size()=5
 
map.containsKey(1)=true
 
map.containsKey(null)=true
 
map.get(null)=null
 
map.get(2)=萝卜
 
map.get(null)=黄瓜
 
set=[null, 1, 2, 3, 4]
 
Collection=[黄瓜, 白菜, 萝卜, 茄子, null]

2、HashMap 中作为键的对象必须重写Object的hashCode()方法和equals()方法

下面看一个我花了1个小时构思的例子，熟悉龙枪的朋友看起来会比较亲切，设定了龙和龙的巢穴，然后把它们用Map集合对应起来，我们可以根据龙查看它巢穴中的宝藏数量，例子只是为了说明hashCode这个知识点，所以未必有太强的故事性和合理性，凑合看吧：

 
import java.util.HashMap;
 
import java.util.Map;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
 
 
        // 龙和它的巢穴映射表
 
        Map<dragon , Nest> map = new HashMap<dragon , Nest>();
 
 
 
        // 在Map中放入四只克莱恩大陆上的龙
 
        map.put(new Dragon("锐刃", 98), new Nest(98));
 
        map.put(new Dragon("明镜", 95), new Nest(95));
 
        map.put(new Dragon("碧雷", 176), new Nest(176));
 
        map.put(new Dragon("玛烈", 255), new Nest(255));
 
 
 
        // 查看宝藏
 
        System.out.println("碧雷巢穴中有多少宝藏：" + map.get(new Dragon("碧雷", 176)).getTreasure());
 
    }
 
 
 
}
 
 
 
// 龙
 
class Dragon {
 
 
 
    Dragon(String name, int level) {
 
        this.level = level;
 
        this.name = name;
 
    }
 
 
 
    // 龙的名字
 
    private String name;
 
 
 
    // 龙的级别
 
    private int level;
 
 
 
    public int getLevel() {
 
        return level;
 
    }
 
 
 
    public void setLevel(int level) {
 
        this.level = level;
 
    }
 
 
 
    public String getName() {
 
        return name;
 
    }
 
 
 
    public void setName(String name) {
 
        this.name = name;
 
    }
 
 
 
}
 
 
 
// 巢穴
 
class Nest {
 
 
 
    //我研究的龙之常数
 
    final int DRAGON_M = 4162;
 
 
 
    // 宝藏
 
    private int treasure;
 
 
 
    // 居住的龙的级别
 
    private int level;
 
 
 
    Nest(int level) {
 
        this.level = level;
 
        this.treasure = level * level * DRAGON_M;
 
    }
 
 
 
    int getTreasure() {
 
        return treasure;
 
    }
 
 
 
    public int getLevel() {
 
        return level;
 
    }
 
 
 
    public void setLevel(int level) {
 
        this.level = level;
 
        this.treasure = level * level * DRAGON_M;
 
    }
 
 
 
}

编译并运行查看结果：

 
Exception in thread "main" java.lang.NullPointerException
 
    at Test.main(Test.java:18)

我们发现竟然报了错误，第18行出了空指针错误，也就是说get方法竟然没有拿到预期的巢穴对象。

在这里我们就要研究一下为什么取不到了。我们这里先解释一下HashMap的工作方式。

假设现在有个6张中奖彩票的存根，放在5个桶里（彩票首位只有1-5，首位是1的就放在一号桶，是2的就放在2号桶，依次类推），现在你拿了3张彩票来兑奖，一个号码是113，一个号码是213，一个号码是313。那么现在先兑第一张，取出一号桶里的存根发现存根号码和你的号码不符，所以你第一张没中奖。继续兑第二张，二号桶里就没存根所以就直接放弃了，把三号桶里的所有彩票存根都拿出来对应一番，最后发现有一个存根恰好是313，那么恭喜你中奖了。

HashMap在确定一个键对象和另一个键对象是否是相同时用了同样的方法，每个桶就是一个键对象的散列码值，桶里放的就是散列码相同的彩票存根，如果散列码不同，那么肯定没有相关元素存在，如果散列码相同，那么还要用键的equals()方法去比较是否相同，如果相同才认为是相同的键。简单的说就是 hashCode()相同 && equals()==true 时才算两者相同。

到了这里我们应该明白了，在没有重写一个对象的hashcode()和equals()方法之前，它们执行的是Object中对应的方法。而 Object的hashcode()是用对象在内存中存放的位置计算出来的，每个对象实例都不相同。Object的equals()的实现更简单就是看两个对象是否==，也就是两个对象除非是同一个对象，否则根本不会相同。因此上面的例子虽然都是名字叫碧雷的龙，但是HashMap中却无法认可它们是相同的。

因此我们只有重写Key对象的hashCode()和equals()方法，才能避免这种情形出现，好在Eclipse可以帮我们自动生成一个类的hashCode()和equals()，我们把上面的例子加上这两个方法再试试看：

 
import java.util.HashMap;
 
import java.util.Map;
 
 
 
public class Test {
 
 
 
    public static void main(String[] args) {
 
 
 
        // 龙和它的巢穴映射表
 
        Map<dragon , Nest> map = new HashMap<dragon , Nest>();
 
 
 
        // 在Map中放入四只克莱恩大陆上的龙
 
        map.put(new Dragon("锐刃", 98), new Nest(98));
 
        map.put(new Dragon("明镜", 95), new Nest(95));
 
        map.put(new Dragon("碧雷", 176), new Nest(176));
 
        map.put(new Dragon("玛烈", 255), new Nest(255));
 
 
 
        // 查看宝藏
 
        System.out.println("碧雷巢穴中有多少宝藏：" + map.get(new Dragon("碧雷", 176)).getTreasure());
 
    }
 
 
 
}
 
 
 
// 龙
 
class Dragon {
 
 
 
    Dragon(String name, int level) {
 
        this.level = level;
 
        this.name = name;
 
    }
 
 
 
    // 龙的名字
 
    private String name;
 
 
 
    // 龙的级别
 
    private int level;
 
 
 
    public int getLevel() {
 
        return level;
 
    }
 
 
 
    public void setLevel(int level) {
 
        this.level = level;
 
    }
 
 
 
    public String getName() {
 
        return name;
 
    }
 
 
 
    public void setName(String name) {
 
        this.name = name;
 
    }
 
 
 
    @Override
 
    public int hashCode() {
 
        final int PRIME = 31;
 
        int result = 1;
 
        result = PRIME * result + level;
 
        result = PRIME * result + ((name == null) ? 0 : name.hashCode());
 
        return result;
 
    }
 
 
 
    @Override
 
    public boolean equals(Object obj) {
 
        if (this == obj)
 
            return true;
 
        if (obj == null)
 
            return false;
 
        if (getClass() != obj.getClass())
 
            return false;
 
        final Dragon other = (Dragon) obj;
 
        if (level != other.level)
 
            return false;
 
        if (name == null) {
 
            if (other.name != null)
 
                return false;
 
        } else if (!name.equals(other.name))
 
            return false;
 
        return true;
 
    }
 
 
 
}
 
 
 
// 巢穴
 
class Nest {
 
 
 
    //我研究的龙之常数
 
    final int DRAGON_M = 4162;
 
 
 
    // 宝藏
 
    private int treasure;
 
 
 
    // 居住的龙的级别
 
    private int level;
 
 
 
    Nest(int level) {
 
        this.level = level;
 
        this.treasure = level * level * DRAGON_M;
 
    }
 
 
 
    int getTreasure() {
 
        return treasure;
 
    }
 
 
 
    public int getLevel() {
 
        return level;
 
    }
 
 
 
    public void setLevel(int level) {
 
        this.level = level;
 
        this.treasure = level * level * DRAGON_M;
 
    }
 
 
 
    113

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。

让我们转到对框架实现的研究，具体的集合类遵循命名约定，并将基本数据结构和框架接口相结合。除了四个历史集合类外，Java 2 框架还引入了六个集合实现，如下表所示。关于历史集合类如何转换、比如说，如何修改Hashtable 并结合到框架中，请参阅历史集合类。

接口	实现	历史集合类
`Set`	`HashSet`
	`TreeSet`
`List`	`ArrayList`	`Vector`
	`LinkedList`	`Stack`
`Map`	`HashMap`	`Hashtable`
	`TreeMap`	`Properties`

这里没有 Collection 接口的实现。历史集合类，之所以这样命名是因为从 Java 类库 1.0 发行版就开始沿用至今了。

如果从历史集合类转换到新的框架类，主要差异之一在于所有的操作都和新类不同步。您可以往新类中添加同步的实现，但您不能把它从旧的类中除去。

Collection collection = new ArrayList();（这样写的好处在于，以后如果要理性不同的集合，可以省略很多麻烦。因为都是用Collection接口里的方法，）

boolean add(E o)
确保此 collection 包含指定的元素（可选操作）。

boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

void clear()
移除此 collection 中的所有元素（可选操作）。

boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回true。

boolean equals(Object o)
比较此 collection 与指定对象是否相等。

int hashCode()
返回此 collection 的哈希码值。

boolean isEmpty()
如果此 collection 不包含元素，则返回 true。

Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。

boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

int size()
返回此 collection 中的元素数。

Object[] toArray()
返回包含此 collection 中所有元素的数组。

<T> T[]

toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

*All方法参数的类型都为Collection ，大多数方法都是返回boolean类型值，Collection 接口用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时，就使用这一接口。（如，可以直接add（100），可以是普通数据类型）。

容器类对象在调用remove,contains等方法时需要比较对象是否相等地，这会涉及到对象类型的equals方法和hashcode方法。即，相等的对象应该有相等的hashcode.当然，如果是自定义的类型，需要重写这两个方法。

iterator接口

`boolean`	`hasNext()` 如果仍有元素可以迭代，则返回 `true`。
`E`	`next()` 返回迭代的下一个元素。
`void`	`remove()` 从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。

Set

Set接口同样是Collection接口的一个子接口，它表示数学意义上的集合概念。Set中不包含重复的元素，即Set中不存两个这样的元素e1和e2，使得e1.equals(e2)为true。由于Set接口提供的数据结构是数学意义上集合概念的抽象，因此它需要支持对象的添加、删除，而不需提供随机访问。故Set接口与Collection 的接口相同，在此对里面的方法不作介绍。

boolean add(E o)
如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。

boolean addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。

void clear()
移除 set 中的所有元素（可选操作）。

boolean contains(Object o)
如果 set 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。

boolean equals(Object o)
比较指定对象与此 set 的相等性。

int hashCode()
返回 set 的哈希码值。

boolean isEmpty()
如果 set 不包含元素，则返回 true。

Iterator<E> iterator()
返回在此 set 中的元素上进行迭代的迭代器。

boolean remove(Object o)
如果 set 中存在指定的元素，则将其移除（可选操作）。

boolean removeAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可选操作）。

boolean retainAll(Collection<?> c)
仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。

int size()
返回 set 中的元素数（其容量）。

Object[] toArray()
返回一个包含 set 中所有元素的数组。

<T> T[]

toArray(T[] a)
返回一个包含 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

按照定义，Set 接口继承 Collection 接口，而且它不允许集合中存在重复项。所有原始方法都是现成的，没有引入新方法。具体的Set 实现类依赖添加的对象的 equals()方法来检查等同性。

HashSet 类和 TreeSet 类

“集合框架”支持 Set 接口两种普通的实现：HashSet 和TreeSet。在更多情况下，您会使用 HashSet 存储重复自由的集合。考虑到效率，添加到 HashSet 的对象需要采用恰当分配散列码的方式来实现hashCode() 方法。虽然大多数系统类覆盖了 Object 中缺省的hashCode()实现，但创建您自己的要添加到 HashSet 的类时，别忘了覆盖 hashCode()。当您要从集合中以有序的方式抽取元素时，TreeSet 实现会有用处。为了能顺利进行，添加到TreeSet 的元素必须是可排序的。 “集合框架”添加对 Comparable 元素的支持，在排序的“可比较的接口”部分中会详细介绍。我们暂且假定一棵树知道如何保持java.lang 包装程序器类元素的有序状态。一般说来，先把元素添加到 HashSet，再把集合转换为TreeSet 来进行有序遍历会更快。

为优化 HashSet 空间的使用，您可以调优初始容量和负载因子。TreeSet 不包含调优选项，因为树总是平衡的，保证了插入、删除、查询的性能为log(n)。

HashSet 和 TreeSet 都实现 Cloneable 接口。

集的使用示例

为演示具体 Set 类的使用，下面的程序创建了一个 HashSet，并往里添加了一组名字，其中有个名字添加了两次。接着，程序把集中名字的列表打印出来，演示了重复的名字没有出现。接着，程序把集作为TreeSet 来处理，并显示有序的列表。

import java.util.*;

public class SetExample {
  public static void main(String args[]) {
    Set set = new HashSet();
    set.add("Bernadine");
    set.add("Elizabeth");
    set.add("Gene");
    set.add("Elizabeth");
    set.add("Clara");
    System.out.println(set);
    Set sortedSet = new TreeSet(set);
    System.out.println(sortedSet);
  }
}

运行程序产生了以下输出。请注意重复的条目只出现了一次，列表的第二次输出已按字母顺序排序。

[Gene, Clara, Bernadine, Elizabeth]
[Bernadine, Clara, Elizabeth, Gene]

List 接口

List 接口继承了 Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

与 set 不同，列表通常允许重复的元素。更正式地说，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。

List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明。

List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用方不知道实现，那么在列表元素上迭代通常优于用索引遍历列表。

List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。

List 接口提供了两种搜索指定对象的方法。从性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。

List 接口提供了两种在列表的任意位置高效插入和移除多个元素的方法。

注意：尽管列表允许把自身作为元素包含在内，但建议要特别小心：在这样的列表上，equals 和 hashCode 方法不再是定义良好的。

某些列表实现对列表可能包含的元素有限制。例如，某些实现禁止 null 元素，而某些实现则对元素的类型有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在列表中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。

面向位置的操作包括插入某个元素或 Collection 的功能，还包括获取、除去或更改元素的功能。在 List 中搜索元素可以从列表的头部或尾部开始，如果找到元素，还将报告元素所在的位置。

void add(int index, Object element)
boolean addAll(int index, Collection collection)
Object get(int index)
int indexOf(Object element)
int lastIndexOf(Object element)
Object remove(int index)
Object set(int index, Object element)

List 接口不但以位置友好的方式遍历整个列表，还能处理集合的子集：

ListIterator listIterator()
ListIterator listIterator(int startIndex)
List subList(int fromIndex, int toIndex)

处理 subList() 时，位于 fromIndex 的元素在子列表中，而位于 toIndex 的元素则不是，提醒这一点很重要。以下 for-loop 测试案例大致反映了这一点：

for (int i=fromIndex; i<toIndex; i++) {
  // process element at position i
}

此外，我们还应该提醒的是 ― 对子列表的更改（如 add()、remove() 和 set() 调用）对底层 List 也有影响。

boolean add(E o)
向列表的尾部追加指定的元素（可选操作）。

void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。

boolean addAll(Collection<? extends E> c)
追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

void clear()
从列表中移除所有元素（可选操作）。

boolean contains(Object o)
如果列表包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。

boolean equals(Object o)
比较指定的对象与列表是否相等。

E get(int index)
返回列表中指定位置的元素。

int hashCode()
返回列表的哈希码值。

int indexOf(Object o)
返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。

boolean isEmpty()
如果列表不包含元素，则返回 true。

Iterator<E> iterator()
返回以正确顺序在列表的元素上进行迭代的迭代器。

int lastIndexOf(Object o)
返回列表中最后出现指定元素的索引，如果列表不包含此元素，则返回 -1。

ListIterator<E> listIterator()
返回列表中元素的列表迭代器（以正确的顺序）。

ListIterator<E> listIterator(int index)
返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置开始。

E remove(int index)
移除列表中指定位置的元素（可选操作）。

boolean remove(Object o)
移除列表中出现的首个指定元素（可选操作）。

boolean removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的所有元素（可选操作）。

boolean retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素（可选操作）。

E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。

int size()
返回列表中的元素数。

List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

Object[] toArray()
返回以正确顺序包含列表中的所有元素的数组。

<T> T[]

toArray(T[] a)
返回以正确顺序包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

其中set方法返回的是被替换的内容。

Linked 改快读慢

Array 读快改慢

Hash 两都之间

Collection是集合接口
|————Set子接口:无序，不允许重复。
|————List子接口:有序，可以有重复元素。

区别：Collections是集合类

    Set和List对比：
    Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
    List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

    Set和List具体子类：
    Set
     |————HashSet：以哈希表的形式存放元素，插入删除速度很快。

    List
     |————ArrayList：动态数组
     |————LinkedList：链表、队列、堆栈。

Array和java.util.Vector
Vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。

Map 接口

Map 接口不是 Collection 接口的继承。而是从自己的用于维护键-值关联的接口层次结构入手。按定义，该接口描述了从不重复的键到值的映射。

我们可以把这个接口方法分成三组操作：改变、查询和提供可选视图。

改变操作允许您从映射中添加和除去键-值对。键和值都可以为 null。但是，您不能把Map 作为一个键或值添加给自身。

Object put(Object key, Object value)返回值是被替换的值。
Object remove(Object key)
void putAll(Map mapping)
void clear()

查询操作允许您检查映射内容：

Object get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
boolean isEmpty()

最后一组方法允许您把键或值的组作为集合来处理。

public Set keySet()
public Collection values()
public Set entrySet()

因为映射中键的集合必须是唯一的，您用 Set 支持。因为映射中值的集合可能不唯一，您用Collection 支持。最后一个方法返回一个实现 Map.Entry 接口的元素 Set。

Map.Entry 接口

Map 的 entrySet() 方法返回一个实现Map.Entry 接口的对象集合。集合中每个对象都是底层 Map 中一个特定的键-值对。

通过这个集合迭代，您可以获得每一条目的键或值并对值进行更改。但是，如果底层 Map 在Map.Entry 接口的setValue() 方法外部被修改，此条目集就会变得无效，并导致迭代器行为未定义。

HashMap 类和 TreeMap 类

“集合框架”提供两种常规的 Map 实现：HashMap 和TreeMap。和所有的具体实现一样，使用哪种实现取决于您的特定需要。在Map 中插入、删除和定位元素，HashMap 是最好的选择。但如果您要按顺序遍历键，那么TreeMap 会更好。根据集合大小，先把元素添加到 HashMap，再把这种映射转换成一个用于有序键遍历的 TreeMap 可能更快。使用HashMap 要求添加的键类明确定义了 hashCode() 实现。有了TreeMap 实现，添加到映射的元素一定是可排序的。我们将在排序中详细介绍。

为了优化 HashMap 空间的使用，您可以调优初始容量和负载因子。这个TreeMap 没有调优选项，因为该树总处于平衡状态。

HashMap 和 TreeMap 都实现Cloneable 接口。

Hashtable 类和 Properties 类是Map 接口的历史实现。我们将在Dictionary 类、Hashtable 类和 Properties 类中讨论。

映射的使用示例

以下程序演示了具体 Map 类的使用。该程序对自命令行传递的词进行频率计数。HashMap 起初用于数据存储。后来，映射被转换为TreeMap 以显示有序的键列列表。

import java.util.*;

public class MapExample {
  public static void main(String args[]) {
    Map map = new HashMap();
    Integer ONE = new Integer(1);
    for (int i=0, n=args.length; i<n; i++) {
      String key = args[i];
      Integer frequency = (Integer)map.get(key);
      if (frequency == null) {
        frequency = ONE;
      } else {
        int value = frequency.intValue();
        frequency = new Integer(value + 1);
      }
      map.put(key, frequency);
    }
    System.out.println(map);
    Map sortedMap = new TreeMap(map);
    System.out.println(sortedMap);
  }
}

用 Bill of Rights 的第三篇文章的文本运行程序产生下列输出，请注意有序输出看起来多么有用！

无序输出：

{prescribed=1, a=1, time=2, any=1, no=1, shall=1, nor=1, peace=1, owner=1, soldier=1, to=1, the=2, law=1, but=1, manner=1, without=1, house=1, in=4, by=1, consent=1, war=1, quartered=1, be=2, of=3}

有序输出：

{a=1, any=1, be=2, but=1, by=1, consent=1, house=1, in=4, law=1, manner=1, no=1, nor=1, of=3, owner=1, peace=1, prescribed=1, quartered=1, shall=1, soldier=1, the=2, time=2, to=1, war=1, without=1}

　Java集合框架是最常被问到的Java面试问题，要理解Java技术强大特性就有必要掌握集合框架。这里有一些实用问题，常在核心Java面试中问到。

　　1、什么是Java集合API

　　Java集合框架API是用来表示和操作集合的统一框架，它包含接口、实现类、以及帮助程序员完成一些编程的算法。简言之，API在上层完成以下几件事：

　　● 编程更加省力，提高城程序速度和代码质量

　　● 非关联的API提高互操作性

　　● 节省学习使用新API成本

　　● 节省设计新API的时间

　　● 鼓励、促进软件重用

　　具体来说，有6个集合接口，最基本的是Collection接口，由三个接口Set、List、SortedSet继承，另外两个接口是Map、SortedMap，这两个接口不继承Collection，表示映射而不是真正的集合。

　　2、什么是Iterator

　　一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用 Iterators时，在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本省。

　　3、Iterator与ListIterator有什么区别？

　　Iterator：只能正向遍历集合，适用于获取移除元素。ListIerator：继承Iterator，可以双向列表的遍历，同样支持元素的修改。

　　4、什么是HaspMap和Map？

　　Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类。

　　5、HashMap与HashTable有什么区别？对比Hashtable VS HashMap

　　两者都是用key-value方式获取数据。Hashtable是原始集合类之一（也称作遗留类）。HashMap作为新集合框架的一部分在Java2的1.2版本中加入。它们之间有一下区别：

　　● HashMap和Hashtable大致是等同的，除了非同步和空值（HashMap允许null值作为key和value，而Hashtable不可以）。

　　● HashMap没法保证映射的顺序一直不变，但是作为HashMap的子类LinkedHashMap，如果想要预知的顺序迭代（默认按照插入顺序），你可以很轻易的置换为HashMap，如果使用Hashtable就没那么容易了。

　　● HashMap不是同步的，而Hashtable是同步的。

　　● 迭代HashMap采用快速失败机制，而Hashtable不是，所以这是设计的考虑点。

　　6、在Hashtable上下文中同步是什么意思？

　　同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其他线程等待锁的释放。

　　7、什么叫做快速失败特性

　　从高级别层次来说快速失败是一个系统或软件对于其故障做出的响应。一个快速失败系统设计用来即时报告可能会导致失败的任何故障情况，它通常用来停止正常的操作而不是尝试继续做可能有缺陷的工作。当有问题发生时，快速失败系统即时可见地发错错误告警。在Java中，快速失败与iterators有关。如果一个iterator在集合对象上创建了，其它线程欲“结构化”的修改该集合对象，并发修改异常（ConcurrentModificationException）抛出。

　　8、怎样使Hashmap同步？

　　HashMap可以通过Map m = Collections.synchronizedMap（hashMap）来达到同步的效果。

　　9、什么时候使用Hashtable，什么时候使用HashMap

　　基本的不同点是Hashtable同步HashMap不是的，所以无论什么时候有多个线程访问相同实例的可能时，就应该使用Hashtable，反之使用HashMap。非线程安全的数据结构能带来更好的性能。

　　如果在将来有一种可能—你需要按顺序获得键值对的方案时，HashMap是一个很好的选择，因为有HashMap的一个子类 LinkedHashMap。所以如果你想可预测的按顺序迭代（默认按插入的顺序），你可以很方便用LinkedHashMap替换HashMap。反观要是使用的Hashtable就没那么简单了。同时如果有多个线程访问HashMap，Collections.synchronizedMap（）可以代替，总的来说HashMap更灵活。

　　10、为什么Vector类认为是废弃的或者是非官方地不推荐使用？或者说为什么我们应该一直使用ArrayList而不是Vector

　　你应该使用ArrayList而不是Vector是因为默认情况下你是非同步访问的，Vector同步了每个方法，你几乎从不要那样做，通常有想要同步的是整个操作序列。同步单个的操作也不安全（如果你迭代一个Vector，你还是要加锁，以避免其它线程在同一时刻改变集合）.而且效率更慢。当然同样有锁的开销即使你不需要，这是个很糟糕的方法在默认情况下同步访问。你可以一直使用Collections.sychronizedList来装饰一个集合。

　　事实上Vector结合了“可变数组”的集合和同步每个操作的实现。这是另外一个设计上的缺陷。Vector还有些遗留的方法在枚举和元素获取的方法，这些方法不同于List接口，如果这些方法在代码中程序员更趋向于想用它。尽管枚举速度更快，但是他们不能检查如果集合在迭代的时候修改了，这样将导致问题。尽管以上诸多原因，oracle也从没宣称过要废弃Vector。