Java中的集合类
package pattern.collation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.WeakHashMap;
/**
*
*
类层次关系如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector（线程安全）
│ └Stack
|Set
| |-HashSet
| |-TreeSet
| └LinkedHashSet
Map
├Hashtable（线程安全的）
├HashMap
└WeakHashMap
List，Set，Map将持有对象一律视为Object型别。
Collection、List、Set、Map都是接口，不能实例化。
继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。
vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。
*
* @author Yuanyuan
*/
public class TestCollation
{
public static void main(String[] args)
{
List<String> list1 = new ArrayList();
List<String> list2 = new LinkedList();
testList(list1);
testList(list2);
Set<String> set1 = new HashSet<>();
Set<String> set2 = new TreeSet<>();
Set<String> set3 = new LinkedHashSet<>();
testSet(set1);
testSet(set2);
testSet(set3);
Map<Integer, String> map1 = new HashMap<>();
Map<Integer, String> map2 = new TreeMap<>();
Map<Integer, String> map3 = new LinkedHashMap<>();
Map<Integer, String> map4 = new WeakHashMap<>();
Map<Integer, String> map5 = new IdentityHashMap<>();
testMap(map1);
testMap(map2);
testMap(map3);
testMap(map4);
testMap(map5);
Hashtable<Integer, String> table1 = new Hashtable<>();
testTable(table1);
}
/*
List：有序的 collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。
可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。
有序的、线性的、长度可变的、有下标的、先进先出.
ArrayList：可以对元素进行随机的访问，向ArrayList()中插入与删除元素的速度慢。
LinkedList:对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢.
*/
private static void testList(List<String> list)
{
for(int i=0;i<10;i++)
{
list.add("value"+i);
}
// 遍历1
for (int j = 0; j < list.size(); j++)
{
System.out.print(list.get(j)+",");
}
System.out.println();
//遍历2
for(String v : list)
{
System.out.print(v+",");
}
System.out.println();
//遍历3
//得到队列的迭代器对象
java.util.Iterator<String> iter = list.iterator();
//判断是否有数据可以迭代
while (iter.hasNext())
{
System.out.print(iter.next()+",");
}
System.out.println();
}
/*
Set:Set保存的是对象的引用，因此Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
HashSet: HashSet类按照哈希算法来存取集合中的对象，存取速度比较快
TreeSet: 底层为树结构.TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。
LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(按插入次序)。
于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
*/
private static void testSet( Set<String> sets)
{
// 装入10个元素
for (int i = 0; i < 10; i++)
{
String s = "元素" + i;
sets.add(s);
}
//检验若输入加入重复的元素，在集合中的是原来的还是新加入的（结果表明是原来的）
boolean b = sets.add("新来的");
boolean b1 = sets.add("新来的");
System.out.println(b + "<>" + b1);
// 遍历1
// 得到迭代器对象
java.util.Iterator<String> iter = sets.iterator();
while (iter.hasNext())
{
System.out.print(iter.next() + "\t");
}
System.out.println();
//遍历2
for (String str : sets)
{
System.out.print(str + "\t");
}
System.out.println();
}
/*
Map:存入的对象是一对一对的，一个键（key）只能对应一个值（value）,反则不然。
HashMap:Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。
TreeMap:基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。
TreeMap的特点在于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
LinkedHashMap： 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。
只比HashMap慢一点。而在迭代访问时反而更快，因为它使用链表维护内部次序
WeakHashMao ：弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。
IdentifyHashMap：使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。
*/
private static void testMap(Map<Integer, String> maps)
{
// 装入键值对
for (int i = 0; i < 20; i++)
{
// 装入一个键值对
maps.put(i, "学生" + i);
}
//增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对
maps.put(30000, "新学生");
maps.put(40000, "新学生");
maps.put(40000, "又来一个");
//遍历
//得到K的Set集合
java.util.Set<Integer> set = maps.keySet();
//遍历K的集合，得到set的迭代器
java.util.Iterator<Integer> iter = set.iterator();
while (iter.hasNext())
{
//取出一个key
int num = iter.next();
//根据key得到对应的Value
String name = maps.get(num);
System.out.print(num + "=" + name + "\t");
}
System.out.println();
}
/*
Hashtable是JDK 5之前Map唯一线程安全的内置实现（Collections.synchronizedMap不算）。
特别说明的是Hashtable的t是小写的（不知道为啥），Hashtable继承的是Dictionary（Hashtable是其唯一公开的子类），并不继承AbstractMap或者HashMap。
尽管Hashtable和HashMap的结构非常类似，但是他们之间并没有多大联系
无序、不重复
*/
private static void testTable(Hashtable<Integer, String> tables)
{
// 装入键值对
for (int i = 0; i < 20; i++)
{
// 装入一个键值对
tables.put(i, "学生" + i);
}
//增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对
tables.put(30000, "新学生");
tables.put(40000, "新学生");
tables.put(40000, "又来一个");
//遍历
//得到K的Set集合
java.util.Set<Integer> set = tables.keySet();
//遍历K的集合，得到set的迭代器
java.util.Iterator<Integer> iter = set.iterator();
while (iter.hasNext())
{
//取出一个key
int num = iter.next();
//根据key得到对应的Value
String name = tables.get(num);
System.out.print(num + "=" + name + "\t");
}
System.out.println();
}
}
JAVA中Collections.sort()排序：http://my.oschina.net/liuyuanyuangogo/blog/151628
HashMap与ConcurrentMap（线程安全的）：http://www.blogjava.net/xylz/archive/2010/07/19/326527.html
以下参考资料：http://blog.csdn.net/speedme/article/details/22398395
总结
1. 如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
2. 如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
3. 在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。
4. 要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
5. 容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内，便损失了该对象的型别信息。
6. 尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。
注意
1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
2、Set和Collection拥有一模一样的接口。
3、List，可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)
4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。
5、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。
HashMap会利用对象的hashCode来快速找到key。
6、Map中元素，可以将key序列、value序列单独抽取出来。
使用keySet()抽取key序列，将map中的所有keys生成一个Set。
使用values()抽取value序列，将map中的所有values生成一个Collection。
为什么一个生成Set，一个生成Collection？那是因为，key总是独一无二的，value允许重复。