精华内容
下载资源
问答
  • 在面试后台开发的过程中,集合是面试的热话题,不仅要知道各集合的区别用法,还要知道集合的扩容机制,今天我们就来谈下ArrayList 和 HashMap的默认大小以及扩容机制。在 Java 7 中,查看源码可以知道:ArrayList 的...

    在面试后台开发的过程中,集合是面试的热话题,不仅要知道各集合的区别用法,还要知道集合的扩容机制,今天我们就来谈下ArrayList 和 HashMap的默认大小以及扩容机制。

    在 Java 7 中,查看源码可以知道:ArrayList 的默认大小是 10 个元素,HashMap 的默认大小是16个元素(必须是2的幂,为什么呢???下文有解释)。这就是 Java 7 中 ArrayList 和 HashMap  类 的代码片段:

    // from ArrayList.java JDK 1.7

    private static final int DEFAULT_CAPACITY = 10;

    //from HashMap.java JDK 7

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

    这里要讨论这些常用的默认初始容量和扩容的原因是:

    当底层实现涉及到扩容时,容器或重新分配一段更大的连续内存(如果是离散分配则不需要重新分配,离散分配都是插入新元素时动态分配内存),要将容器原来的数据全部复制到新的内存上,

    这无疑使效率大大降低。加载因子的系数小于等于1,意指即当元素个数超过容量长度*加载因子的系数时,进行扩容。另外,扩容也是有默认的倍数的,不同的容器扩容情况不同。

    List 元素是有序的、可重复

    ArrayList、Vector默认初始容量为10

    Vector:线程安全,但速度慢

    底层数据结构是数组结构

    加载因子为1:即当 元素个数 超过 容量长度 时,进行扩容

    扩容增量:原容量的 1倍

    如 Vector的容量为10,一次扩容后是容量为20

    ArrayList:线程不安全,查询速度快

    底层数据结构是数组结构

    扩容增量:原容量的 0.5倍+1

    如 ArrayList的容量为10,一次扩容后是容量为16

    Set(集) 元素无序的、不可重复。

    HashSet:线程不安全,存取速度快

    底层实现是一个HashMap(保存数据),实现Set接口

    默认初始容量为16(为何是16,见下方对HashMap的描述)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍

    如 HashSet的容量为16,一次扩容后是容量为32

    Map是一个双列集合

    HashMap:默认初始容量为16

    (为何是16:16是2^4,可以提高查询效率,另外,32=16<<1)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍

    如 HashSet的容量为16,一次扩容后是容量为32

    接下来我们来谈谈hashMap的数组长度为什么保持2的次幂?

    hashMap的数组长度一定保持2的次幂,比如16的二进制表示为 10000,那么length-1就是15,二进制为01111,同理扩容后的数组长度为32,二进制表示为100000,length-1为31,二进制表示为011111。

    这样会保证低位全为1,而扩容后只有一位差异,也就是多出了最左位的1,这样在通过 h&(length-1)的时候,只要h对应的最左边的那一个差异位为0,就能保证得到的新的数组索引和老数组索引一致(大大减少了

    之前已经散列良好的老数组的数据位置重新调换),还有,数组长度保持2的次幂,length-1的低位都为1,会使得获得的数组索引index更加均匀。

    1. static int indexFor(int h, int length) {

    2. return h & (length-1);

    3. }

    首先算得key得hashcode值,然后跟数组的长度-1做一次“与”运算(&)。看上去很简单,其实比较有玄机。比如数组的长度是2的4次方,那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问,

    为什么hashmap的数组初始化大小都是2的次方大小时,hashmap的效率最高,我以2的4次方举例,来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。

    看下图,左边两组是数组长度为16(2的4次方),右边两组是数组长度为15。两组的hashcode均为8和9,但是很明显,当它们和1110“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同

    一个位置上去,这就产生了碰撞,8和9会被放到同一个链表上,那么查询的时候就需要遍历这个链表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hashcode的

    值会与14(1110)进行“与”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组

    长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!

    20200720103300831742.png

    所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

    说到这里,我们再回头看一下hashmap中默认的数组大小是多少,查看源代码可以得知是16,为什么是16,而不是15,也不是20呢,看到上面的解释之后我们就清楚了吧,显然是因为16是2的整数次幂的原因,

    在小数据量的情况下16比15和20更能减少key之间的碰撞,而加快查询的效率。

    展开全文
  • 总结一:以下就是List下的三个实现类集合ArrayList 和Vector,LinkedList扩容总结:ArrayList 和Vector扩容机制总结:ArrayList 和Vector,底层都是Object数组,默认加载因子都是1(元素满了才扩展容量).默认容量都是...

    总结一:以下就是List下的三个实现类集合ArrayList 和Vector,LinkedList扩容总结:

    ArrayList 和Vector扩容机制总结:

    ArrayList 和Vector,底层都是Object数组,默认加载因子都是1(元素满了才扩展容量).默认容量都是10;但是ArrayList 在jdk1.8时默认为空,当添加元素时,才初始化为10个容量。ArrayList:新容量为原容量的1.5倍,Vector:新容量为原容量的2倍.

    ArrayList 默认初始容量为10,(jdk8的时候底层Object[] elementData数组初始化为{},并没有创建长度为10的数组。在add元素时才创建了10个容量。)

    线程不安全,查询速度快

    底层数据结构是数组结构

    扩容增量:原容量的 0.5倍,新容量为原容量的1.5倍。

    如 ArrayList的容量为10,一次扩容后是容量为15

    同样可以通过分析源码知道:

    Vector:

    默认初始容量为10,(jdk7和jdk8一样都初始容量为10)。

    线程安全,但速度慢

    底层数据结构是数组结构

    加载因子为1:即当 元素个数 超过 容量长度 时,进行扩容

    扩容增量:原容量的 1倍,新容量为原容量的2倍。

    如 Vector的容量为10,一次扩容后是容量为20

    LinkedList没有扩容机制:

    LinkedList:没有扩容机制,因为其底层是双向链表结果。不存在数组的扩容一说,没有初始化大小,也没有扩容的机制,就是一直在前面或者后面新增就好。。

    总结二:Set下的三个实现类集合HashSet和LinkedHashSet,TreeSet,扩容总结:LinkedHashSet,TreeSet没有数组的扩容机制。

    HashSet和HashMap扩容机制总结:

    HashSet和HashMap都是默认初始容量是16,加载因子是0.75,扩容为原来的2倍。而带LinkedHashSet和LinkedHashMap是链表不存在扩容的,HashSet:底层是数组+链表的结构。

    Set(集) 元素无序的、不可重复。

    HashSet:线程不安全,存取速度快

    底层实现是一个HashMap(保存数据),HashSet:底层是数组+链表的结构,实现Set接口

    默认初始容量为16(为何是16,见下方对HashMap的描述)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍,新容量为原容量的2倍。

    如 HashSet的容量为16,一次扩容后是容量为32。

    因为构造一个HashSet,其实相当于新建一个HashMap,然后取HashMap的Key。

    扩容机制和HashMap一样。

    Map是一个双列集合

    HashMap:默认初始容量为16

    (为何是16:16是2^4,可以提高查询效率,另外,32=16<<1 –>至于详细的原因可另行分析,或分析源代码)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍,新容量为原容量的2倍。

    如 HashSet的容量为16,一次扩容后是容量为32

    Hashtable扩容机制:

    public Hashtable() {

    this(11, 0.75f);

    }

    Hashtable默认初始容量11。

    二、扩容加载因子(0.75),当超出默认长度(int)(11*0.75)=8时,扩容为oldx2+1。新容量为原容量的2倍+1.

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

    小结:HashTable和HashMap区别

    第一,继承不同。

    public class Hashtable extends Dictionary implements Map

    public class HashMap extends AbstractMap implements Map

    第二:

    Hashtable 中的方法是同步的,而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下,可以直接使用

    Hashtable,但是要使用HashMap的话就要自己增加同步处理了。

    第三,Hashtable中,key和value都不允许出现null值。

    在HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,

    即可以表示 HashMap中没有该键,也可以表示该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中

    是否存在某个键, 而应该用containsKey()方法来判断。

    第四,两个遍历方式的内部实现上不同。

    Hashtable、HashMap都使用了 Iterator。而由于历史原因,Hashtable还使用了Enumeration的方式 。

    第五,哈希值的使用不同,HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

    第六,Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11,增加的方式是 old2+1。HashMap中hash数组的默认大小是16, 增加的方式是 old2。

    小结:StringBuffer和StringBuilder:

    StringBuilder和StringBuffer的初始容量都是16,程序猿尽量手动设置初始值。以避免多次扩容所带来的性能问题,默认数组容量扩充为原数组容量的2倍+2。

    1.StringBuilder是jdk1.5引进的,而StringBuffer在1.0就有了;

    2.StringBuilder和StringBuffer都是可变的字符串。能够通过append或者insert等方法改动串的内容;

    3.StringBuffer是线程安全的而StringBuilder不是,因而在多线程的环境下优先使用StringBuffer,而其它情况下推荐使用

    StringBuilder,由于它更快。

    4.StringBuilder和StringBuffer都继承自AbstractStringBuilder类,AbStractStringBuilder主要实现了扩容、append、

    insert方法。StrngBuilder和StringBuffer的相关方法都直接调用的父类。

    5.StringBuilder和StringBuffer的初始容量都是16,程序猿尽量手动设置初始值。以避免多次扩容所带来的性能问题;

    6.StringBuilder和StringBuffer的扩容机制是这种:首先试着将当前数组容量扩充为原数组容量的2倍加上2,假设这个新容

    量仍然小于预定的最小值(minimumCapacity),那么就将新容量定为(minimumCapacity),最后推断是否溢出,若溢出,

    则将容量定为整型的最大值0x7fffffff。

    转载自CSDN-专业IT技术社区

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    展开全文
  • 当底层实现涉及到扩容时,容器或重新分配一段更大的连续内存(如果是离散分配则不需要重新分配,离散分配都是插入新元素时动态分配内存),要将容器原来的数据全部复制到新的内存上,这无疑使效率大大降低。...

    当底层实现涉及到扩容时,容器或重新分配一段更大的连续内存(如果是离散分配则不需要重新分配,离散分配都是插入新元素时动态分配内存),要将容器原来的数据全部复制到新的内存上,

    这无疑使效率大大降低。加载因子的系数小于等于1,意指即当元素个数超过容量长度*加载因子的系数时,进行扩容。另外,扩容也是有默认的倍数的,不同的容器扩容情况不同。

    List 元素是有序的、可重复

    ArrayList、Vector默认初始容量为10

    Vector:线程安全,但速度慢

    底层数据结构是数组结构

    加载因子为1:即当 元素个数 超过 容量长度 时,进行扩容

    扩容增量:原容量的 1倍

    如 Vector的容量为10,一次扩容后是容量为20

    ArrayList:线程不安全,查询速度快

    底层数据结构是数组结构

    扩容增量:原容量的 0.5倍+1

    如 ArrayList的容量为10,一次扩容后是容量为16

    Set(集) 元素无序的、不可重复。

    HashSet:线程不安全,存取速度快

    底层实现是一个HashMap(保存数据),实现Set接口

    默认初始容量为16(为何是16,见下方对HashMap的描述)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍

    如 HashSet的容量为16,一次扩容后是容量为32

    Map是一个双列集合

    HashMap:默认初始容量为16

    (为何是16:16是2^4,可以提高查询效率,另外,32=16<<1)

    加载因子为0.75:即当 元素个数 超过 容量长度的0.75倍 时,进行扩容

    扩容增量:原容量的 1 倍

    如 HashSet的容量为16,一次扩容后是容量为32

    接下来我们来谈谈hashMap的数组长度为什么保持2的次幂?

    hashMap的数组长度一定保持2的次幂,比如16的二进制表示为 10000,那么length-1就是15,二进制为01111,同理扩容后的数组长度为32,二进制表示为100000,length-1为31,二进制表示为011111。

    这样会保证低位全为1,而扩容后只有一位差异,也就是多出了最左位的1,这样在通过 h&(length-1)的时候,只要h对应的最左边的那一个差异位为0,就能保证得到的新的数组索引和老数组索引一致(大大减少了

    之前已经散列良好的老数组的数据位置重新调换),还有,数组长度保持2的次幂,length-1的低位都为1,会使得获得的数组索引index更加均匀。

    1. static int indexFor(int h, int length) {

    2. return h & (length-1);

    3. }

    首先算得key得hashcode值,然后跟数组的长度-1做一次“与”运算(&)。看上去很简单,其实比较有玄机。比如数组的长度是2的4次方,那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问,

    为什么hashmap的数组初始化大小都是2的次方大小时,hashmap的效率最高,我以2的4次方举例,来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。

    看下图,左边两组是数组长度为16(2的4次方),右边两组是数组长度为15。两组的hashcode均为8和9,但是很明显,当它们和1110“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同

    一个位置上去,这就产生了碰撞,8和9会被放到同一个链表上,那么查询的时候就需要遍历这个链表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hashcode的

    值会与14(1110)进行“与”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组

    长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!

    af8361ead6f5ee76219b002c718e74a0.png

    所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

    说到这里,我们再回头看一下hashmap中默认的数组大小是多少,查看源代码可以得知是16,为什么是16,而不是15,也不是20呢,看到上面的解释之后我们就清楚了吧,显然是因为16是2的整数次幂的原因,

    在小数据量的情况下16比15和20更能减少key之间的碰撞,而加快查询的效率。

    展开全文
  • ArrayList和Vector扩容机制

    千次阅读 2016-11-28 17:31:54
    ArrayList中ensureCapacity扩容,trimToSize容量调整到适中,Vector的扩容,是可以指定扩容因子,同时Vector扩容策略是:原来容量的2倍与原来容量+扩容因子,两者中取容量大的,进行扩容 ArrayList和Vector都是...


    ArrayList中ensureCapacity扩容,trimToSize容量调整到适中,Vector的扩容,是可以指定扩容因子,同时Vector扩容策略是:原来容量的2倍与原来容量+扩容因子,两者中取容量大的,进行扩容


    ArrayList和Vector都是继承了相同的父类和实现了相同的接口。如下 

    Java代码  收藏代码
    1. public class Vector<E>  
    2.     extends AbstractList<E>  
    3.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable  
    4. {}  
    5.   
    6. public class ArrayList<E> extends AbstractList<E>  
    7.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable  
    8. {}  

    两者之间我认为主要有两个却别。 
    1、Vector中的public方法都添加了synchronized关键字,以确保方法同步。 
    2、内部属性不同,这也是导致扩容方式不同的原因所在。 

    我现在来说第二条, 
    ArrayList有两个属性,存储数据的数组elementData,和存储记录数目的size。 
    Vector有三个属性,存储数据的数组elementData,存储记录数目的elementCount,还有扩展数组大小的扩展因子capacityIncrement。 


    先来看ArrayList的扩展方法 
    Java代码  收藏代码
    1. public void ensureCapacity(int minCapacity) {  
    2. modCount++;//父类中的属性,记录集合变化次数  
    3. int oldCapacity = elementData.length;  
    4. if (minCapacity > oldCapacity) {  
    5.     Object oldData[] = elementData;  
    6.     int newCapacity = (oldCapacity * 3)/2 + 1;  
    7.         if (newCapacity < minCapacity)  
    8.     newCapacity = minCapacity;  
    9.     elementData = (E[])new Object[newCapacity];  
    10.     System.arraycopy(oldData, 0, elementData, 0, size);  
    11. }  
    12.    }  

    重构下看起来更方便 
    Java代码  收藏代码
    1. public void ensureCapacity(int minCapacity) {  
    2. modCount++;//父类中的属性,记录集合变化次数  
    3. int oldCapacity = elementData.length;  
    4. if (minCapacity > oldCapacity) {//扩容的条件,数组需要的长度要大于实际长度  
    5.     Object oldData[] = elementData;  
    6.     int newCapacity = ((oldCapacity * 3)/2 + 1)<minCapacity?minCapacity: ((oldCapacity * 3)/2 + 1);  
    7.        elementData = (E[])new Object[newCapacity];  
    8.     System.arraycopy(oldData, 0, elementData, 0, size);  
    9. }  
    10.    }  

    可以看到,再满足扩容条件时,扩展后数组大小为((原数组长度*3)/2+1)与传递参数中较大者 

    再看看Vector的扩容方法 
    Java代码  收藏代码
    1. public synchronized void ensureCapacity(int minCapacity) {  
    2.     modCount++;//父类中的属性,记录集合变化次数  
    3.     ensureCapacityHelper(minCapacity);  
    4.     }  
    5.  private void ensureCapacityHelper(int minCapacity) {  
    6.     int oldCapacity = elementData.length;  
    7.     if (minCapacity > oldCapacity) {//扩容的条件,数组需要的长度要大于实际长度  
    8.         Object[] oldData = elementData;  
    9.         int newCapacity = (capacityIncrement > 0) ?  
    10.         (oldCapacity + capacityIncrement) : (oldCapacity * 2);  
    11.             if (newCapacity < minCapacity) {  
    12.         newCapacity = minCapacity;  
    13.         }  
    14.         elementData = new Object[newCapacity];  
    15.         System.arraycopy(oldData, 0, elementData, 0, elementCount);  
    16.     }  
    17.     }  

    可以看到,相对于ArrayList的扩容方法,这个方法被一分为2,老实说我更喜欢这样,方法的职责更加明确。 


    int newCapacity = (capacityIncrement > 0) ?(oldCapacity + capacityIncrement) : (oldCapacity * 2); 

    当扩容因子大于0时,新数组长度为原数组长度+扩容因子,否子新数组长度为原数组长度的2倍。 


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

    将上面生成的新数组长度与传递的参数要求长度作比较,较大者为最终的新长度。


    转载地址:http://man-yutao.iteye.com/blog/1317446

    展开全文
  • 总结ArrayList 和Vector默认加载因子都是1(元素满了才扩展容量).默认容量都是10;但是ArrayList 在jdk1.8时默认为空,当添加元素时,才初始化为10个容量。ArrayList 默认初始容量为10,(jdk8的时候底层Object[] ...
  • Java 7 中,查看源码可以知道:ArrayList 的默认大小是 10 个元素,HashMap 的默认大小是16个元素(必须是2的幂,为什么呢???下文有解释)。这就是 Java 7 中 ArrayList 和 HashMap 类 的代码片段:// from ...
  • 原文作者:这个名字先用着原文标题:java集合的扩容机制发布时间:2021-02-28 12:44:36总结一:以下就是List下的三个实现类集合ArrayList 和Vector,LinkedList扩容总结:ArrayList 和Vector扩容机制总结:ArrayList...
  • Java集合的扩容机制

    2020-04-13 17:37:38
    List相关的默认容量以及扩容机制 ArrayList ArrayList默认容量是10 ArrayList最大容量Integer.MAX_VALUE - 8 ArrayList扩容机制,按原数组长度的1.5倍扩容。如果扩容后的大小小于实际需要的大小,将数组扩大到实际...
  • java集合的扩容机制

    2020-04-13 17:21:07
    JAVA中的部分需要扩容的内容总结如下: 第一部分:HashMap 、HashSet、Hashtable 第二部分:ArrayList、Vector、CopyOnWriteArrayList ...2、扩容机制。3、同类型之间对比。 1.1 HashMap: 一、初始容量定义:默认为...
  • ArrayList是最常见以及每个Java开发者最熟悉的集合类了,顾名思义,ArrayList就是一个以数组形式实现的集合,以一张表格来看一下ArrayList里面有哪些基本的元素:源代码:/** * The array buffer into which the ...
  • JAVA中的部分需要扩容的内容总结如下: 第一部分:HashMap 、HashSet、Hashtable 第二部分:ArrayList、Vector、CopyOnWriteArrayList ...2、扩容机制。3、同类型之间对比。 1.1 HashMap: 一、初始容量定义:默认为...
  • List相关的默认容量以及扩容机制 ArrayList ArrayList默认容量是10 ArrayList最大容量Integer.MAX_VALUE - 8 ArrayList扩容机制,按原数组长度的1.5倍扩容。如果扩容后的大小小于实际需要的大小,将数组扩大到...
  • List相关的默认容量以及扩容机制 ArrayList ArrayList默认容量是10 ArrayList最大容量Integer.MAX_VALUE - 8 ArrayList扩容机制,按原数组长度的1.5倍扩容。如果扩容后的大小小于实际需要的大小,将数组扩大到...
  • Java集合扩容机制1、ArrayList2、Vector3、Stack4、HashMap 为什么需要扩容?即当前集合能容纳的数据量达到一个饱和状态(饱和状态和加载因子有关)之后,集合需要申请新的存储空间,即扩容。 常见的需要扩容的集合...
  • JAVA集合默认大小及扩容机制

    千次阅读 2019-06-28 14:52:42
    List 元素是有序的、可重复 ...如 Vector的容量为10,一次扩容后是容量为20 ArrayList:线程不安全,查询速度快 默认初始容量为10 底层数据结构是数组结构 扩容增量:原容量的 0.5倍+1 如 Arr...
  • 集合的扩容机制 List 元素是有序的、可重复 ArrayList、Vector默认初始容量为10 Vector:线程安全,但速度慢  底层数据结构是数组结构  加载因子为1:即当 元素个数 超过 容量长度 时,进行扩容  扩容增量:原...
  • (Java) ArrayList capacity属性获取+扩容机制验证 capacity私有属性用来描述ArrayList的空间。这里开辟的空间类似于cpp中的malloc,仅仅是开辟,未使用(即未初始化)。 利用反射机制读取私有属性capacity 在java中...
  • java中各种集合的扩容机制记录总结

    万次阅读 2019-03-01 15:00:00
    JAVA中的部分需要扩容的内容总结如下: 第一部分:HashMap 、HashSet、Hashtable 第二部分:ArrayList、Vector、CopyOnWriteArrayList 第三部分:StringBuffer、StringBuilder 先从以下几个源...
  • 默认容量为10,没有初始化大小,也没有扩容机制 Vector实现类: 默认容量为10,超出后按照源容量2倍来扩容(未指定增长步长) grow源码: Set接口: HashSet实现类: 默认容量16,加载因子0.75,超出后按照1倍...
  • list元素时有序的、可重复 Arraylist、vector默认初始化...如vector的容量为10,一次扩容后是容量为20 ArrayList:线程不安全,查询速度快 底层数据结构是数组结构 扩容增量:原容量的0.5倍+1 如ArrayList的...

空空如也

空空如也

1 2 3 4 5 6
收藏数 116
精华内容 46
关键字:

vector扩容机制java

java 订阅