1.List
（1）ArrayList 与 Vector
共同点:a.这两个类都实现了List接口，都是有序集合，数据可以重复，可以简单理解为动态数组。
b.初始容量都是10
不同点:a.ArrayList的增长率是1.5，即下一次的容量是当前容量的1.5倍，而Vector是2.
b.从安全性考虑，ArrayList是线程不同步的，而Vector是线程同步的。
在对ArrayList和Vector的增加数据进行时间测试后，如果是在非多线程环境下，最好使用ArrayList，不单节省了时间 ，而且还在数据量非常大时，还能节省大量空间（因为Vector的增量比例是2.0）
常用方法:因为两者大同小异，所以对ArrayList测试就行，而最常见的add(),remove()之类的方法就看API。
a. toArray(); 返回一个按照正确的顺序包含此列表中所有元素的数组。
Object[] a = list.toArray();
因为list.toArray()返回的是一个Object[]数组，所以也需要用Object[]接收
但如果使用list.toArray(T[]),则可以避免这种情况。
Integer[] b = new Integer[list.size()];
list.toArray(b);
b. addAll(T);
按照指定Collection的迭代器所返回的元素顺序，将该Collection中的所有元素追加到此列表的尾部
对于实现了Collection接口的类的对象，都可以add。
ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
TreeSet<Integer> set = new TreeSet<Integer>();
Stack<Integer> stack = new Stack<Integer>();
for(int i=0; i<10; i++){
list.add(i);
list2.add(i);
set.add(i);
stack.add(i);
}
System.out.println(list.size()); //输出10
list.addAll(list2);
System.out.println(list.size()); //输出20
list.addAll(set);
System.out.println(list.size()); //输出30
list.addAll(stack);
System.out.println(list.size()); //输出40
c.remove();
remove()方法被重载了，即有remove(int index):移除index处的数据， remove(Object o)移除o这个元素。
如果ArrayList存储的是Integer类型的元素，而且要移除的位置（index）与某个元素(o)相等了怎么处理？？ 按API描述，后者是可选的，即如果冲突了，则优先选择前者。
（2）ArrayList 与 LinkedList
既然ArrayList能看成动态数组，那么LinkedList也可以简单理解为链表，那么他们之间的区别就可以很容易看出。
ArrayList是采用数组来保存对象，放在连续的位置中，那么插入，删除操作将会非常耗时；
而LinkedList的对象是放在独立的空间中，空间中同时保存下一个位置的链接，所以查找则会非常耗时，然而插入，删除则更加方便。
//在n个数据中，在第0个位置插入m个数据
ArrayList<Integer> list = new ArrayList<Integer>();
int n = 1000000;
int m = 1000;
for(int i=0; i<n; i++){
list.add(i);
}
long t1 = System.currentTimeMillis();
for(int i=0; i<m; i++){
int num = (int)(Math.random()*list.size());
list.add(0, num);
}
long t2 = System.currentTimeMillis();
System.out.println("耗时: "+(t2-t1));
//最终的测试数据是这个
ArrayList LinkedList
第一次 第二次 第三次 第一次 第二次 第三次
966 978 1334 3 2 2
然而在最开始时，我写的是在随机位置插入随机数，可不管怎么测试，最终都是ArrayList的时间小于LinkedList，后来 才反应过来，每次插入时，LinkedList都要从0开始数，到达指定位置再插入，时间都浪费在了查找上。
对于查找的测试程序最后的测试时间如下(从n个数据中随机查找m个数据):
查找 ArrayList LinkedList
n=1000000 第一次 第二次 第三次 第一次 第二次 第三次
m=1000 1392 1370 1285 3544 3273 3319
可以看出LinkedList的查找时间远远大于ArrayList的查找时间。
LinkedList的方法的使用跟ArrayList相差不大,但多了跟链表特性有关的一些方法，例如: addFirst()...在头部插入元 素，addLast()...在末尾追加元素之类的，但又因为同时实现了List接口与Collection接口的缘故，方法中出现了功能 一样的方法:
例如: getFirst() 和 peek()都是找到第一个元素，poll(),remove()和removeFirst()都是找到并且移除第一个元 素。
（3）Stack Stack 类表示后进先出（LIFO）的对象堆栈。
使用范围很广,例如浏览器的后退按钮。
基本方法(API):
empty()
测试堆栈是否为空。
peek()
查看栈顶对象而不移除它。
pop()
移除栈顶对象并作为此函数的值返回该对象。
push(E item)
把项压入栈顶。
search(Object o)
返回对象在栈中的位置，以 1 为基数。
而关于栈的题目，一般都是此种类型:
一个栈的入栈序列为ABCDE，则不可能的出栈序列为?
1.ECDBA
2.DCEAB
3.DECBA
4.ABCDE
5.EDCBA
2.Set
一个不包含重复元素（重要功能）的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和e2，并且最多 包含一个 null 元素。(API)
实现了Set接口了最常用的两个类是: HashSet和TreeSet.
两者包含的方法差不多，都是add(),contains(),clear(),remove()之类的，需要注意的是iterator()方法的使用。
Iterator不做介绍，只需要知道可以用来取出Set中的值就好:
Iterator<Integer> iter = hash.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
而对于取值则还有另外一种方法:
for(Integer i : hash){
System.out.println(i);
}
TreeSet与HashSet的不同之处在于:此类保证排序后的 set 按照升序排列元素，根据使用的构造方法不同，可能会按照元素的自 然顺序 进行排序（参见 Comparable），或按照在创建 set 时所提供的比较器进行排序。(API)
自然顺序是指(以如下代码为例):
TreeSet<Integer> treeset = new TreeSet<Integer>();
for(int i=0; i<10; i++){
treeset.add((int)(Math.random()*100));
}
for(Integer i : treeset){
System.out.println(i);
}
将输出:7 21 25 30 72 74 86 89 92 93(从小到大)
而String类型将使用自己的默认接口，
treeset.add("abc");
treeset.add("ABC");
treeset.add("HIJ");
treeset.add("xyz");
则输出 ABC HIJ abc xyz。
3.Map
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。(API)
HashMap:K则相当于一个HashSet
TreeSet:K则相当于一个TreeSet
所有的K不能重复，每个K都对应一个value
如果在加入数据的时候，出现相同的key，则替换掉原有的value。
由于Map的特性，可以用于数某篇文章中出现的单词的种类及每种的个数。
举个简单例子（每个字符出现的次数）:
String str = "abbcccddddeeeeeffffffggggggg";
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (!map.containsKey(ch)) {
map.put(ch, 1);
} else {
int num = map.get(ch);
num++;
map.put(ch, num);
}
}