序言
List、Set、Map可以看做集合的三大类
java集合就像一个容器，可以将多个对象的引用丢进该容器中。
Collection和Map是java集合的根接口。
List
List代表一种线性表的数据结构， List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。
ArrayList则是一种顺序存储的线性表。ArrayList 底层采用数组来保存每个集合元素。线程不安全。ArrayList源码分析
遍历List集合的三种方法
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//方法一：foreach
for(String attribute : list) {
System.out.println(attribute);
}
//方法二：对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
System.out.println(list.get(i));
}
//方法三：集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
LinkedList 则是一种链式存储的线性表。其本质上就是一个双向链表，但它不仅实现了 List 接口，还实现了 Deque 接口。
也就是说LinkedList既可以当成双向链表使用，也可以当成队列使用，还可以当成栈来使用（Deque 代表双端队列，既具有队列的特征，也具有栈的特征）。线程不安全。
@Test
public void test2(){
Queue<String> queue = new LinkedList<String>();
queue.offer("Hello");
queue.offer("World!");
queue.offer("你好！");
System.out.println("队列长度："+queue.size());
String str;
while((str=queue.poll())!=null){
System.out.println(str);
}
System.out.println("队列长度："+queue.size());
}
Queue 队列
Arraylist和Linklist区别：Java 的 List 集合本身就是线性表的实现，其中 ArrayList是线性表的顺序存储实现；而 LinkedList 则是线性表的链式存储实现。
1、Arraylist（优点）：它是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。
（缺点）：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。
2、Linklist（优点）：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。
LinkedList 适用于要头尾操作或插入指定位置的场景
（缺点）：因为LinkedList要移动指针,所以查询操作性能比较低。
适用场景分析：当需要对数据进行多次访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。
Vector向量类具体类：底层数据结构是数组。线程安全。
Vector 其实就是 ArrayList 的线程安全版本， ArrayList 和 Vector 绝大部分方法的实现都是相同的，只是 Vector 的方法增加了 synchronized 修饰。
ArrayList 的序列化实现比 Vector 的序列化实现更安全，因此 Vector 基本上已经被ArrayList 所代替了。 Vector 唯一的好处是它是线程安全的。
Stack具体类
public class Stack<E> extends Vector<E>
@Test
public void test2(){
Stack<String> stack = new Stack<String>();
System.out.println("now the stack is " + isEmpty(stack));
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
stack.push("5");
System.out.println("now the stack is " + isEmpty(stack));
System.out.println(stack.peek()); //peek 不改变栈的值(不删除栈顶的值)
System.out.println(stack.pop()); //pop会把栈顶的值删除
System.out.println(stack.search("1")); //方法调用返回从堆栈中，对象位于顶部的基于1的位置。
}
public static String isEmpty(Stack<String> stack) {
return stack.empty() ? "empty" : "not empty";
}
Stack
Deque双端队列
Java 也不再推荐使用 Stack 类，而是推荐使用 Deque 实现类。
在无需保证线程安全的情况下，程序完全可以使用ArrayDueue来代替Stack 类。
从 JDK 1.6 开始，Java 为 Deque提供了一个常用的实现类ArrayDeque。就像List集合拥有 ArrayList 实现类一样，Deque集合则拥有ArrayDeque 实现类。
@Test
public void test1() {
ArrayDeque stack = new ArrayDeque();
// 依次将三个元素push入“栈”，先进后出
stack.push("疯狂Java讲义");
stack.push("轻量级Java EE企业应用实战");
stack.push("疯狂Android讲义");
System.out.println(stack); // [疯狂Android讲义, 轻量级Java EE企业应用实战, 疯狂Java讲义]
System.out.println(stack.peek()); // 疯狂Android讲义
System.out.println(stack); // [疯狂Android讲义, 轻量级Java EE企业应用实战, 疯狂Java讲义]
System.out.println(stack.pop()); // 疯狂Android讲义
System.out.println(stack);// [轻量级Java EE企业应用实战, 疯狂Java讲义] // 当做队列来使用,先进先出
ArrayDeque queue = new ArrayDeque();
queue.offer("疯狂Java讲义");
queue.offer("轻量级JavaEE企业应用实践");
queue.offer("疯狂Android讲义");
System.out.println(queue); // [疯狂Java讲义, 轻量级JavaEE企业应用实践, 疯狂Android讲义]
// 访问队列头部元素，但不将其poll出队列
System.out.println(queue.peek());
System.out.println(queue);
// poll出第一个元素
System.out.println(queue.poll());
System.out.println(queue);// [轻量级JavaEE企业应用实践, 疯狂Android讲义]
}
ArrayDeque--stack || queue
Deque 接口代表双端队列这种数据结构。 双端队列已经不再是简单的队列了，它既具有队列的性质先进先出（ FIFO），也具有栈的性质（ FILO），也就是说双端队列既是队列，也是栈。
@Test
public void test1(){
Deque<String> deque = new LinkedList<String>();
deque.add("d");
deque.add("e");
deque.add("f"); //从队首取出元素，不会删除
System.out.println("队首取出元素:"+deque.peek());
System.out.println("队列为:"+deque); //从队首加入元素(队列有容量限制时用，无则用addFirst)
deque.offerFirst("c");
System.out.println("队首加入元素后为："+deque);
//从队尾加入元素(队列有容量限制时用，无则用addLast)
deque.offerLast("g");
System.out.println("队尾加入元素后为："+deque); //队尾加入元素
deque.offer("h");
System.out.println("队尾加入元素后为："+deque); //获取并移除队列第一个元素,pollFirst()也是，区别在于队列为空时,removeFirst会抛出NoSuchElementException异常，后者返回null
deque.removeFirst();
System.out.println("获取并移除队列第一个元素后为:"+deque); //获取并移除队列第一个元素,此方法与pollLast 唯一区别在于队列为空时,removeLast会抛出NoSuchElementException异常，后者返回null
deque.removeLast();
System.out.println("获取并移除队列最后一个元素后为:"+deque); //获取队列第一个元素.此方法与 peekFirst 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
System.out.println("获取队列第一个元素为:"+deque.getFirst());
System.out.println("获取队列第一个元素后为:"+deque); //获取队列最后一个元素.此方法与 peekLast 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
System.out.println("获取队列最后一个元素为:"+deque.getLast());
System.out.println("获取队列第一个元素后为:"+deque); //循环获取元素并在队列移除元素
while(deque.size()>0){
System.out.println("获取元素为："+ deque.pop()+" 并删除");
}
System.out.println("队列为:"+deque);
}
Deque--LinkedList
继承关系是：deque => queue => collection=》Iterable
1.使用队列的时候，new LinkedList的时候为什么用deque接收，不用LinkedList呢？
答：deque继承queue接口，因为它有两个实现，LinkedList与ArrayDeque。用deque接收是因为向上转型(子类往父类转，会丢失子类的特殊功能)了。可以试试，用get()方法，LinkedList接收才有。
2.为什么有一个实现还不够，还弄两个呢，它们总有区别吧？
答：ArrayDeque是基于头尾指针来实现的Deque，意味着不能访问除第一个和最后一个元素。想访问得用迭代器，可以正反迭代。
ArrayDeque一般优于链表队列/双端队列，有限数量的垃圾产生（旧数组将被丢弃在扩展），建议使用deque，ArrayDeque优先。
Set
Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。
HashSet集合:底层数据结构是哈希表(是一个元素为链表的数组)
如何正确地重写某个类的 hashCode()方法和 equals()方法？
TreeSet集合:底层数据结构是红黑树(是一个自平衡的二叉树);保证元素的排序方式
LinkedHashSet集合:底层数据结构由哈希表和链表组成。
Map
Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。
HashMap类
HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。
当创建 HashMap 时，有一个默认的负载因子（ load factor），其默认值为 0.75。这是时间和空间成本上的一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，
但会增加查询数据的时间开销，
而查询是最频繁的的操作 （ HashMap 的 get()与 put()方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。
package com.pb.collection; import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map.Entry; public class HashMapDemo { public static void main(String[] args) { HashMap<String, String> hashMap = new HashMap<String, String>();
hashMap.put("cn", "中国");
hashMap.put("jp", "日本");
hashMap.put("fr", "法国"); System.out.println(hashMap);
System.out.println("cn:" + hashMap.get("cn"));
System.out.println(hashMap.containsKey("cn"));
System.out.println(hashMap.keySet());
System.out.println(hashMap.isEmpty()); hashMap.remove("cn");
System.out.println(hashMap.containsKey("cn")); //采用Iterator遍历HashMap
Iterator it = hashMap.keySet().iterator();
while(it.hasNext()) {
String key = (String)it.next();
System.out.println("key:" + key);
System.out.println("value:" + hashMap.get(key));
} //遍历HashMap的另一个方法
Set<Entry<String, String>> sets = hashMap.entrySet();
for(Entry<String, String> entry : sets) {
System.out.print(entry.getKey() + ", ");
System.out.println(entry.getValue());
}
}
}
HashMap
LinkedHashMap类
Hashtable
TreeMap类
对于 TreeMap 而言，它采用一种被称为“红黑树”的排序二叉树来保存 Map中每个Entry—每个 Entry 都被当成“红黑树”的一个节点对待。
Iterator(迭代器)
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
迭代器应用：
list l = new ArrayList();
l.add("aa");
l.add("bb");
l.add("cc");
for (Iterator iter = l.iterator(); iter.hasNext();) {
String str = (String)iter.next();
System.out.println(str);
}
//迭代器用于while循环
Iterator iter = l.iterator();
while(iter.hasNext()){
String str = (String) iter.next();
System.out.println(str);
}
总结
关于集合中List、Map、Set这三个的总结如下:
List：List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 。
ArrayList：非线程安全，适合随机查找和遍历，不适合插入和删除。
LinkedList : 非线程安全，适合插入和删除，不适合查找。
Vector : 线程安全。不过不推荐。
Map：一个key到value的映射的类 。
HashMap：非线程安全，键和值都允许有null值存在。
TreeMap：非线程安全，按自然顺序或自定义顺序遍历键(key)。
LinkedHashMap：非线程安全，维护一个双链表，可以将里面的数据按写入的顺序读出。写入比HashMap强，新增和删除比HashMap差。
Hashtable：线程安全，键和值不允许有null值存在。不推荐使用。
ConcurrentHashMap：线程安全，Hashtable的升级版。推荐多线程使用。
Set：不允许重复的数据 。检索效率低下，删除和插入效率高。
HashSet： 非线程安全、无序、数据可为空。
TreeSet： 非线程安全、有序、数据不可为空。
LinkedHashSet：非线程安全、无序、数据可为空。写入比HashSet强，新增和删除比HashSet差。
虽然集合号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入 Set 集合中，而只是在 Set 集合中保留这些对象的引用而已。
也就是说，Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java 对象。
就像引用类型的数组一样，当把 Java 对象放入数组之时，并不是真正把 Java 对象放入数组中，而只是把对象的引用放入数组中，每个数组元素都是一个引用变量。
对于每个 Java 集合来说，其实它只是多个引用变量的集合.
资料
ArrayList,LinkedList,Vector集合的认识
http://www.cnblogs.com/Java3y/p/8782788.html
https://www.cnblogs.com/Java3y/p/8808818.html