1.HashMap
特点：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）无序存储。性能主要受制于初始容量和加载因子两个参数。当需要进行rehash时，扩展为原来的两倍。
2.TreeMap
特点：基于红黑树的NavigableMap实现，该映射根据其键的自然顺序（升序）排序，或者根据创建映射时的Comparator排序。可以存放null的value，不可以存放null的key。并且提供了一些对键排序有关的方法。比如ceilingKey(key)(返回大于等于给定键的最小键）
floorKey(key)(返回小于等于给定键的最大键）等方法。
package com.java7.src.vector; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Set;
import java.util.TreeMap; import com.java7.src.proxy.Employee; public class VectorTest { public static void main(String[] args) {
Employee e1 = new Employee(1, "changming.liu");
Employee e2 = new Employee(2, "bhaoliang.song");
Employee e3 = new Employee(4, "lei.li");
Employee e6 = new Employee(5, "a.aefaw");
Employee e7 = new Employee(6, "z.afee3"); List<Employee> es = new ArrayList<>();
es.add(e1);
es.add(e2);
es.add(e3);
es.add(e6);
es.add(e7); //HashMap
System.out.println("----------HashMap--------");
Map<String,Employee> maps = new HashMap<>();
maps.put(null, e1);
for( Employee e: es){
maps.put(e.getName(), e);
}
Set<String> keys = maps.keySet();
for( String key:keys)
System.out.println(key);
//TreeMap
System.out.println("----------TreeMap--------");
System.out.println(" 没有使用自定义排序方式（升序）");
TreeMap<String,Employee> tmaps = new TreeMap<>();
for( Employee e: es){
tmaps.put(e.getName(), e);
}
Set<String> sets = tmaps.keySet();
for(String key:sets)
System.out.println(" "+key);
System.out.println(" 使用了自定义排序方式（降序）");
tmaps = new TreeMap<>(new MyComparator()) ;
for( Employee e: es){
tmaps.put(e.getName(), e);
}
sets = tmaps.keySet();
for(String key:sets)
System.out.println(" "+key);
System.out.println(" 大于等于'd'的最小键:"+tmaps.ceilingKey("d"));
}
}
3.ArrayList
特点：List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小（比如ensureCapacity(int capacity)。（此类大致上等同于 Vector类，除了此类是不同步的。）随着向 ArrayList 中不断添加元素，其容量也自动增长。当minCapacity - elementData.length > 0时，容量增长为原来的3倍。grow（）函数可以证明
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); //3倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
4.Vector
特点：Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}