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