Java.集合 框架，接口，常用集合特点比对

框架

接口 Iterable

可迭代接口

获取迭代器方法(Iterator iterator();)，使用该方法进行遍历。

迭代器实现Iterator接口。

boolean hasNext();

E next();

List 列表(有序允许重复)

列表

是集合，是有序的集合。所以在Collection基础上增加了 按照位置 *** 作的方法。

比如：

1. 根据下标遍历，获取某个位置的元素
2. 添加到或者编辑某个位置的元素
3. 删除某个位置的元素
4. 查找某元素是否存在也扩展了indexof，返回的是下标。区别于Collection.contain返回的boolean类型

 Collection 集合 根接口

集合

此集合只是广义上的集合，就是一堆数据，就是一个结合。比如：一群人，没有顺序，也没序号，只能判断有没有某人，不能获取第几个人。

注意：Collection中是集合的抽象接口，有的实现可以重复，有的不可以重复。所以这里就没法放一下对有序的 *** 作方法，并不代表他的实现类 都不支持有序，上面的那个例子只是用来说明问题。

方法：

1. 集合相关：判空，大小，清空
2. 元素相关：添加，查找元素是否，删除
3. 遍历：迭代遍历，转为数组

可以看出，没法定位到元素的位置的。

 Queue 单向队列

队列

FIFO的集合，在Collection的基础上增加了对先进先出的 *** 作。

方法：

1. 添加元素到队尾(空报异常)
2. 从队首获取或者删除元素(移除,空报异常)
   1. Deque 双向队列

是集合，也是队列。

在Collection和Queue的基础上，多了对头和队尾的 *** 作函数。

方法：

1. 队首添加元素到(空报异常)
2. 从队首获取或者删除元素(移除,空报异常)
3. 添加元素到队尾(空报异常)
4. 从队尾获取或者删除元素(移除,空报异常)

Set 无重复集合

是集合

是不允许重复元素，且无序(指存取无序)。

只是对：无重复的集合 抽象， 不对应具体的数据结构。即：只要输出的结合是没有重复元素的集合，就可以实现该接口。

继承Collection接口，没有扩展方法，只是对方法在意义上做了限制。同样继承Collection接口的特征，部分实现类有序，部分无序。所以这里也没有针对有序预留接口方法。

Map 映射集合

映射的集合

Key-Value，Key和Value 都无序，Key不允许重复，重复则覆盖映射的Value。

方法：

1. 大小，判空，清空
2. 添加映射对
3. 遍历：根据entityset，keyset或者直接遍历value集合
4. 按照key获取value，更新value，判断是否包含，移除entity

Map & Collection

Map是映射的集合，每个Entity都包含：key-value，Entity是一个集合，从key维度也是一个集合，从value维度看也是一个集合。

这三个集合只不过都是无序的，entity和key的集合不允许重复(一般用Set)，value是可以重复的(用Collection)。

可见Set和Map是基本数据结构抽象概念的更高层应用，只是对一组特定数据的集合抽象。而这个抽象的某一个维度又可能跟上面的某个集合特征相同。

Set & Map

逻辑上：

Set在逻辑上跟Map没有关系，Set是 单个无重复元素，且不保证存取顺序的集合的抽象。而Map本质是key-value映射对的集合。只不过Map的这个映射对 也 是不允许有重复key，以及存取顺序保证不了的。

实现上：

       Map的实现是使用数组和链表的组合。鉴于Map的Key也有类似无存取顺序，不可以重复的特点，就使用Map的实现来实现Set。

抽象类

接口说清楚有什么功能，抽象类是该接口抽象逻辑的实现，并没有实际的实现。

比如：

接口中包括：contains，containsAll

抽象类中：

1. 实现contains方法，不依赖具体的实现。
2. containsAll是contains的封装的方法。

比如：(红色的就是依赖的接口)

contains

    public boolean contains(Object o) {
        Iterator it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
}

containsAll

    public boolean containsAll(Collection c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

AbstractCollection

Collection接口的抽象类。

AbstractList

List接口的抽象类，继承AbstractCollection。

列表的抽象实现。

AbstractQueue

Queue接口的抽象类，继承AbstractCollection。

队列的抽象实现。

AbstractSequentialList

列表，只能按照顺序访问的列表，不支持随机访问RandomAccess(ArrayList就实现了该)。，所以遍历 AbstractSequentialList 的子类，使用 for 循环 get() 的效率要 <= 迭代器遍历

继承自AbstractList，并做了约束。

而数据结构中的链表不就是，只支持顺序访问，不支持随机访问吗。

AbstractSet

不重复，无序的Set接口的抽象类，继承AbstractCollection。

AbstractMap

Map的抽象类，只是对Map接口做了抽象实现。

集合 Vector

定义：

public class Vector
    extends AbstractList
    implements List, RandomAccess, Cloneable, java.io.Serializable

实现：

基础数据结构：数组

扩容：初始10，可以设置；超过长度，数组翻倍，复制元素。增加的元素数量也可以设置。

线程安全：只是在方法维度加了synchronized关键字 和 数组。

ArrayList

定义：

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable

实现：

数据结构：数组

扩容：初始空数组，第一次添加元素扩容10个，以后都是当前的1.5倍或者当前要求的最小空间大小，下次再扩容。

线程安全：不安全，没有做任何线程控制

LinkedList

定义：

public class LinkedList
    extends AbstractSequentialList
    implements List, Deque, Cloneable, java.io.Serializable

实现：

数据结构：不可以随机访问的 双向链表

扩容： 直接链接到列表尾部即可

线程安全：不安全，没有做任何线程控制

HashMap

定义：

public class HashMap extends AbstractMap
    implements Map, Cloneable, Serializable {

实现：

数据结构：数组+链表/树

扩容： 容量占比超过加载因子(默认0.75)，就做re哈希

线程安全：不安全，没有做任何线程控制

HashSet

使用HashMap构建的Set。

TreeMap

使用二叉树构建的Map

TreeSet

使用二叉树构建的Set

其他接口 接口分类

标志接口：就是一个标记，instanceof 来判断

方法接口：里边有具体方法

Cloneable

标志接口

表明可被克隆接口

调用Object.clone()接口

Serializable

标志接口

表明可被序列号接口

RandomAccess

标记接口

List实现，表明可以该List支持 快速随机访问 策略。

使用 for (int i=0, n=list.size(); i < n; i++) 比for (Iterator i=list.iterator(); i.hasNext(); )这种访问速度快。

Comparable

compareTo方法来比较二者的大小。

---