Java集合框架整理

Java集合框架中的泛型有什么优点

• 泛型是一种编译时的安全机制。避免了在运行时出现ClassCastExeption
• 是的代码整洁，不需要显示转换和instanceOf操作指令

Java集合框架的基础接口有哪些？

Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。

Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。

List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。

Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。

一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。

　为何Collection不从Cloneable和Serializable继承？

• Collection接口指定一组对象，对象即为它的元素，如何维护这些元素由Collection的具体实现决定而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。

当与具体实现打交道的时候，克隆或者序列化的语义和含义才发挥作用。而在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。

Enumeration和Iterator接口的区别？

Emumeration速度是Iterator的两倍，也使用更少的内存，但是，与Emumeration相比，Iterator类型的对象正在被遍历的时候，它会阻止其他线程去修改集合

在迭代一个集合的时候，如何避免ConcurrentModificationException？

在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList

HashMap和HashTable有何不同

• HashMap允许key和value为null，而HashTable不允许。
• HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。
• 在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你很容易从HashMap转向LinkedHashMap，但是HashTable不是这样的，它的顺序是不可预知的。
• HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不支持fail-fast。
• HashTable被认为是个遗留的类，如果你寻求在迭代的时候修改Map，你应该使用CocurrentHashMap。

为何Iterator接口没有具体的实现？

实现交由子类。
允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的

Comparable和Comparator接口有何区别

-Comparable是一个对象本身就已经支持自比较所需要实现的接口，如String、Integer自己就实现了Comparable接口，可完成比较大小操作。自定义类要在加入list容器中后能够排序，也可以实现Comparable接口，在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。

Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。

ArrayList的扩容

public static void main(String[] args) {  
        StudentVO student = null;  
        long begin1 = System.currentTimeMillis();  
        List<StudentVO> list1 = new ArrayList<>();  
        for(int i = 0 ; i < 1000000; i++){  
            student = new StudentVO(i,"chenssy_"+i,i);  
            list1.add(student);  
        }  
        long end1 = System.currentTimeMillis();  
        System.out.println("list1 time：" + (end1 - begin1));  

        long begin2 = System.currentTimeMillis();  
        List<StudentVO> list2 = new ArrayList<>(1000000);  
        for(int i = 0 ; i < 1000000; i++){  
            student = new StudentVO(i,"chenssy_"+i,i);  
            list2.add(student);  
        }  
        long end2 = System.currentTimeMillis();  
        System.out.println("list2 time：" + (end2 - begin2));  
    }  

上面代码两个list都是插入1000000条数据，只不过list1没有没有申请初始化容量，而list2初始化容量1000000。那运行结果如下：

list1 time：1638  
list2 time：921  

为什么差别这么大？
这与ArrayList的扩容机制有关：

public boolean add(E e) {    
        ensureCapacity(size + 1);     
        elementData[size++] = e;    
        return true;    
    }    

    public void ensureCapacity(int minCapacity) {    
        modCount++;         //修改计数器  
        int oldCapacity = elementData.length;      
        //当前需要的长度超过了数组长度，进行扩容处理  
        if (minCapacity > oldCapacity) {    
            Object oldData[] = elementData;    
            //新的容量 = 旧容量 * 1.5 + 1  
            int newCapacity = (oldCapacity * 3)/2 + 1;    
                if (newCapacity < minCapacity)    
                    newCapacity = minCapacity;    
          //数组拷贝，生成新的数组   
          elementData = Arrays.copyOf(elementData, newCapacity);    
        }    
    }  

ArrayList每次新增体格元素，就会检测ArrayList的当前容量是否已经到达临界点，如果到达临界点，则会扩容1.5倍。

ArrayList的扩容是通过数组的拷贝以及新增数组来扩容的，这是相当耗费资源的。

出处：http://blog.csdn.net/chenssy/article/details/38373833

Vector的扩容机制

public synchronized void ensureCapacity(int minCapacity) {  
    modCount++;//父类中的属性，记录集合变化次数  
    ensureCapacityHelper(minCapacity);  
    }  
 private void ensureCapacityHelper(int minCapacity) {  
    int oldCapacity = elementData.length;  
    if (minCapacity > oldCapacity) {//扩容的条件，数组需要的长度要大于实际长度  
        Object[] oldData = elementData;  
        int newCapacity = (capacityIncrement > 0) ?  
        (oldCapacity + capacityIncrement) : (oldCapacity * 2);  
            if (newCapacity < minCapacity) {  
        newCapacity = minCapacity;  
        }  
        elementData = new Object[newCapacity];  
        System.arraycopy(oldData, 0, elementData, 0, elementCount);  
    }  
    }  

capacityIncrement：向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。

 if (newCapacity < minCapacity) {newCapacity = minCapacity;} 

hashset的一致性

class HashSet implements Set {
    private static final Object PRESENT = new Object();
    private transient HashMap<E,Object> map;

    public HashSet() {
        map = new HashMap<>();
    }

    public boolean add(E e) { //e=hello,world
        return map.put(e, PRESENT)==null;
    }
}

看以看出，hashset的底层实现是hashMap,add保持一致性，调用map.put()

class HashMap implements Map {
    public V put(K key, V value) { //key=e=hello,world

        //看哈希表是否为空，如果空，就开辟空间
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }

        //判断对象是否为null
        if (key == null)
            return putForNullKey(value);

        int hash = hash(key); //和对象的hashCode()方法相关

        //在哈希表中查找hash值
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            //这次的e其实是第一次的world
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
                //走这里其实是没有添加元素
            }
        }

        modCount++;
        addEntry(hash, key, value, i); //把元素添加
        return null;
    }

第一次添加，返回null;
之后在哈希表中查找hash值，调用hash方法，判断hash值是否相等，如果相等，在用equal()判断相等。则覆盖value；如果不等，则把元素添加；

TreeSet的add()

class TreeMap implements NavigableMap {
     public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }
}

class TreeSet implements Set {
    private transient NavigableMap<E,Object> m;

    public TreeSet() {
         this(new TreeMap<E,Object>());
    }

    public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }
}

真正的比较是依赖于元素的conpareTo方法，而这个方法是定义在Comparable里面。所以，想要重写该方法，就必须重写Comparable

Map集合的三种视图

（1）Set keyset()：返回map中包含的所有key的一个Set视图。集合是受map支持的，map的变化会在集合中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作以外），GG。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

（2）Collection values()：返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个collection时，若map被修改了（除迭代器自身的移除操作以外），GG，集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

（3）Set<Map.Entry<K,V>> entrySet()：返回一个map中包含的所有映射的一个集合视图。这个集合受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作，以及对迭代器返回的entry进行setValue外），GG。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

与Java集合框架相关的有哪些最好的实践？

（1）根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。

（2）一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。

（3）基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。

（4）总是使用类型安全的泛型，避免在运行时出现ClassCastException。

（5）使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。

（6）尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。