JDK1.7源码阅读tools包之------ArrayList,LinkedList,HashMap,TreeMap

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);
     }