Java 扩容

分手后的思念是犯贱 2022-07-11 07:53 110阅读 0赞

# **1、**StringBuilder,StringBuffer #

public StringBuffer() {
            super(16);
        }

public StringBuffer(String str) {
            super(str.length() + 16);
            append(str);
        }

void expandCapacity(int minimumCapacity) {
            int newCapacity = value.length * 2 + 2;
            if (newCapacity - minimumCapacity < 0)
                newCapacity = minimumCapacity;
            if (newCapacity < 0) {
                if (minimumCapacity < 0) // overflow
                    throw new OutOfMemoryError();
                newCapacity = Integer.MAX_VALUE;
            }
            value = Arrays.copyOf(value, newCapacity);
        }

public final class StringBuilder extends AbstractStringBuilder implements Serializable, CharSequence

public final class StringBuffer extends AbstractStringBuilder implements Serializable, CharSequence

两者都有 append、insert、reverse操作。

与StringBuilder 相比，StringBuffer只是在每个方法前面加了synchronized锁。

# 2、ArrayList、Vector #

public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector

public Vector() {
            this(10);
        }

ArrayList

private static final int DEFAULT_CAPACITY = 10;

初始容量都是10

下面是扩容

Vector

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
        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);
        }
    
        private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
        }

ArrayList

private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            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);
        }

从上面看出两者除了线程安全性有区别外，扩容方式也不一样。Vector扩容是翻一倍，而ArrayList的扩容是增加到1.5倍。

# 3、HashSet #

public class HashSet<E>
        extends AbstractSet<E>
        implements Set<E>, Cloneable, java.io.Serializable

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

public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
            map = new LinkedHashMap<>(initialCapacity, loadFactor);
        }

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

HashSet是利用HashMap实现的。

# 4、HashMap，Hashtable #

public class HashMap<K,V>
        extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable

public class Hashtable<K,V>
        extends Dictionary<K,V>
        implements Map<K,V>, Cloneable, java.io.Serializable

public Hashtable() {
            this(11, 0.75f);
        }

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

static final int MAXIMUM_CAPACITY = 1 << 30;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

public HashMap() {
            this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
        }

private void inflateTable(int toSize) {
            // Find a power of 2 >= toSize
            int capacity = roundUpToPowerOf2(toSize);
    
            threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
            table = new Entry[capacity];
            initHashSeedAsNeeded(capacity);
        }

HashMap的初始化容量总是寻找一个适合的2的倍数的值。

扩容方式：

Hashtable （ 增加的方式是 old\*2+1）

int newCapacity = (oldCapacity << 1) + 1;

HashMap（扩容为两倍）

void addEntry(int hash, K key, V value, int bucketIndex) {
            if ((size >= threshold) && (null != table[bucketIndex])) {
                resize(2 * table.length);
                hash = (null != key) ? hash(key) : 0;
                bucketIndex = indexFor(hash, table.length);
            }
    
            createEntry(hash, key, value, bucketIndex);
        }

HashTable中构造hash数组时initialCapacity默认大小是11，增加的方式是 old\*2+1。HashMap中构造hash数组时initialCapacity默认大小是16，而且一定是2的指数。扩容为两倍。

# 总结： #

对于java中的各种集合类，根据底层的具体实现，小结了一下大致有3种扩容的方式：

1、对于以散列表为底层数据结构实现的，（譬如hashset，hashmap，hashtable等），扩容方式为当链表数组的非空元素除以数组大小超过加载因子时，

链表数组长度变大（乘以2) 然后进行重新散列。

2、对于以数组为底层数据结构实现的，譬如ArrayList，当数组满了之后，数组长度变大（乘以3/2+1），然后将原数组中的数据复制到新数组中。

3、对于以链表结构实现的，譬如TreeSet，TreeMap，则是动态增加元素~~即每次加１即可。总结：

总结：  
  
对于java中的各种集合类，根据底层的具体实现，小结了一下大致有3种扩容的方式：  
1、对于以散列表为底层数据结构实现的，（譬如hashset，hashmap，hashtable等），扩容方式为当链表数组的非空元素除以数组大小超过加载因子时，  
链表数组长度变大（乘以2) 然后进行重新散列。  
2、对于以数组为底层数据结构实现的，譬如ArrayList，当数组满了之后，数组长度变大（乘以3/2+1），然后将原数组中的数据复制到新数组中。  
3、对于以链表结构实现的，譬如TreeSet，TreeMap，则是动态增加元素~~即每次加１即可。  
4、Map用于存储键值对，根据键得到值，因此不允许键重复，值可以重复。  
（1）HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为null，不允许多条记录的值为null。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要同步，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。  
（2）Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，然而，这也导致了Hashtable在写入时会比较慢。  
（3）LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢。有HashMap的全部特性。  
（4）TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。TreeMap的键和值都不能为空。