The Collection Interfaces in Java

开发中几乎离不开集合，虽然平时用到的就那么几个，对它的了解还是知之甚少，遂有了整理一下的想法，但看到Java中的集合非常的庞杂，因此，只对接口做了一些简单的梳理，下面步入正题：
谓之集合，指可以盛放多个对象，也可以把它称之为容器，集合类和数组不同，数组元素既可以是基本类型的值，也可以是对象；而集合里只能保存对象。一般大家把Collections分成三个体系：Set、List和Map，但从下面的图来看，也可以分为两个体系：Collection和Map，如果掌握了每个集合的特点，怎么分也就看个人喜好了。（该静下心来好好看看下图）



先来看Collection这一支：
Interface java.util.Iterable
此为集合根接口，如果有一个集合为Iterable，那么可以通过它获取一个Iterator，并且利用它作为目标来迭代。

public interface Iterable<T> {
Iterator<T> iterator();
}

Interface java.util.Collection
该接口中定义的方法可以操作Set、List和Queue集合，当使用System.out的println方法来输出集合对象时，将输出[ele1,ele2...]的形式，这显然是因为Collection的实现类重写了toString()方法，所有的Collection都重写了toString()方法，该方法可以一次性数据集合中的元素。至于遍历的方式就不做介绍了。

public interface Collection<E> extends Iterable<E> {
Iterator<E> iterator();
int size();
boolean isEmpty();
boolean contains(Object o);
boolean add(E e);
boolean remove(Object element);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
Object[] toArray();
<T> T[] toArray(T[] a);
}

Interface java.util.Set
Set类似一个罐子，一旦把对象“丢进”Set集合，集合里多个对象之间没有明显的顺序，Set集合与Collection基本完全一样，他没有提供额外的方法，实际上Set就是Collection，知识行为不同。Set集合不容许包含相同的元素，如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add方法返回false，且新元素不会被加入。
Set判断两个对象相同不是使用==运算符，而是根据equals方法。如果两个对象用equals方法比较返回true，Set就不会接受这两个对象；反之亦然。

public interface Set<E> extends Collection<E> {
}

Interface java.util.SortedSet
SortedSet进一步保证了Set内的元素按照升序排列，排序的规则是按照自然排序进行，如果需要自定义排序方法，那么就需要借助comparator接口了。每个方法的用法请详见API。

public interface SortedSet<E> extends Set<E> {
Comparator<? super E> comparator();
E first();
E last();
SortedSet<E> subSet(E fromElement, E toElement);
SortedSet<E> headSet(E toElement);
SortedSet<E> tailSet(E fromElement);
}

Interface java.util.List
List作为Collection接口的子接口，可以使用Collection接口的全部方法，而且由于List是有序集合，因此List集合里增加了一些根据索引操作集合元素的方法，List中允许重复元素。
List额外提供了一个listIterator()方法，它继承自Iterator接口，拥有向前迭代的功能，还可以通过add方法向List集合中添加元素。

public interface List<E> extends Collection<E> {
E get(int index);
E set(int index, E e);
void add(int index, E e);
E remove(int index);
boolean addAll(int index, Collection<? extends E> c);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
List<E> subList(int from, int to);
}

Interface java.util.Queue
Queue用于模拟队列数据结构，通常指FIFO的容器，访问元素操作会返回队列头部的元素，通常，队列不允许随机访问队列的元素。

public interface Queue<E> extends Collection<E> {
boolean offer(E o);  // adds if possible
E poll(); // retrieve and remove head (return null if empty)
E remove(); // retrieve and remove head (throw if empty)
E peek(); // retrieve but do not remove head (return null if empty)
E element(); // retrieve but do not remove head (throw if empty)
}

Interface java.util.concurrent.BlockingQueue
此接口用到的不多，首先它是一个队列，那和上面介绍的队列有何区别呢？如果BlockingQueue为空，从BlockingQueue取元素将会被阻断进入等待状态，知道BlockingQueue放入元素才会被唤醒，同样，如果BlockingQueue是满的，任何试图放入元素的操作也会被阻断进入等待状态，知道BlockingQueue有空间才会被唤醒。

public interface BlockingQueue<E> extends Queue<E> {
boolean offer(E o, long timeout, TimeUnit unit) throws InterruptedException;
void put(E o) throws InterruptedException;
boolean add(E e);
E poll(long timeout, TimeUnit unit) throws InterruptedException;
E take() throws InterruptedException;
int drainTo(Collection<? super E> c);
int drainTo(Collection<? super E> c, int maxElements);
int remainingCapacity();
}

再来看Map这一支：
Interface java.util.Map
Map中把Key放在一起看，组成了一个Set集合，是不能重复的，Map确实包含一个keySet()方法，用于返回所有的key组成的set集合；如果把Map所有的value放在一起看，他非常类似于List，元素键可以重复，因此，Map也被称作字典。
Map提供了大量的实现类，Entry为Map内部类，因此通过entrySet()方法可以取出包含key-value的Map.Entry对象。

public interface Map<K,V> {
boolean containsKey(Object key);
boolean containsValue(Object value);
V put(K key, V value);
V get(Object key);
V remove(Object key);
void putAll(Map<? extends K, ? extends V> t);
void clear();
public Set<K> keySet();
public Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
public interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
}
}

Interface java.util.SortedMap
正如Set接口派生出SortedSet子接口，SortedSet有一个TreeSet实现类，Map接口也派生了一个SortedMap子接口，SortedMap也有一个TreeMap实现类。与TreeSet类似的是，TreeMap也是基于红黑树对TreeMap所有key进行排序，从而保证TreeMap中所有key-value处于有序状态。
排序方法分自然排序和定制排序，如果自然排序可以必须实现Comparable接口，且所有的key是同一个类对象，定制排序则需要借助Compatator对象。

public interface SortedMap<K, V> extends Map<K, V> {
Comparator<? super E> comparator();
K firstKey();
K lastKey();
SortedMap<K,V> subMap(K fromKey, K toKey);
SortedMap<K,V> headMap(K toKey);
SortedMap<K,V> tailMap(K fromKey);
}

Interface java.util.concurrent.ConcurrentMap
对于很多并发应用程序来说是一个非常有用的接口，对并发有所了解的童鞋可进一步了解。本人只能写到这里了。

public interface ConcurrentMap<K, V> extends Map<K, V> {
V putIfAbsent(K key, V value);
boolean remove(Object key, Object value);
boolean replace(K key, V oldValue, V newValue);
V replace(K key, V value);
}

  至于实现类，在用到时可以百度或API查询即可，没必要一一列举，这里没有谈到线程安全和泛型，以后有时间再做梳理。（为后面Bean的注入做个铺垫）