精华内容
下载资源
问答
  • Vector扩容机制

    2021-09-27 17:45:36
    同样的Vector的初始化也有无参和有参 无参: public Vector() { this(10); } 直接给定初始容量为10;...定义初始化容量大小,扩容参数为0 两个参数: public Vector(int initialCapacity, int capacityIncrement) {

    同样的Vector的初始化也有无参和有参

    无参:

        public Vector() {
            this(10);
        }
    

    直接给定初始容量为10;

    一个参数:

        public Vector(int initialCapacity) {
            this(initialCapacity, 0);
        }
    

    定义初始化容量大小,扩容参数为0

    两个参数:

    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
    

    定义容量大小,和扩容参数大小

    添加元素,调用add()

        public synchronized boolean add(E e) {
            modCount++;     //修改次数+1
            ensureCapacityHelper(elementCount + 1);   //判断是否需要扩容
            elementData[elementCount++] = e;
            return true;
        }
    

    调用ensureCapacityHelper()判断是否扩容

        private void ensureCapacityHelper(int minCapacity) {
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)   //放入元素后的长度 > 数组长度 ,扩容
                grow(minCapacity);
        }
    

    需要扩容,调用grow()扩容

        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);
        }
    
    Vector总结:

    无参的Vector初始容量为10;

    如果实例化时初始化参数 capacityIncrement > 0,那么扩容时,新容量 = 旧容量 + 扩容参数,

    没有实例化时没有初始参数 capacityIncrement > 0,那么扩容时,新容量 = 2 * 旧容量,

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

    在 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这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组

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

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

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

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

    展开全文
  • Vector扩容机制

    2021-07-18 12:52:13
    Vector扩容机制 本文基于jdk16的源码,其他版本思路相同,代码有所不同而已,若存在问题,请大佬指点。 1、简单介绍 ①Vector类的定义说明 public class Vector<E> extends AbstractList<E> ...

    Vector扩容机制

    本文基于jdk16的源码,其他版本思路相同,代码有所不同而已,若存在问题,请大佬指点。

    1、简单介绍

    ①Vector类的定义说明

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

    ②Vector类的底层存储数据使用的是一个Object类型的数组

    protected Object[] elementData;
    

    ③Vector类是线程安全的,因为在其操作函数中带有synchronized

    public synchronized boolean add(E e) {
        modCount++;
        add(e, elementData, elementCount);
        return true;
    }
    

    ④开发中,需要线程同步安全,建议使用Vector

    2、扩容机制

    1、当使用的是无参构造函数创建Vector对象时,默认会初始化容量为10,每次扩容,容量 = 原容量 × 2

    Vector vector = new Vector();
    

    2、当使用的是一个参数的有参构造函数创建Vector对象时,初始化容量则为指定的长度,每次扩容,容量 = 原容量 × 2

    Vector vector = new Vector(8);
    

    3、当使用的是两个参数的有参构造函数创建Vector对象时,初始化容量则为指定的长度,每次扩容,容量 = 原容量 + 指定的扩容长度

    Vector vector = new Vector(8,2);
    

    (1)无参构造创建Vector对象

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t3k9wqjN-1626583916162)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718102500286.png)]

    从上面断点中进入Vector的无参构造中

    //用于保存数据的Object数组
    protected Object[] elementData;
    //容量扩容值,即当需要扩容时,进行多大的扩容
    protected int capacityIncrement;
    
    //Vector的无参构造
    public Vector() {
        //调用有参构造,并设置初始化容量为10
        this(10);
    }
    
    //从上面Vector的无参构造跳转到Vector的单个参数的有参构造
    public Vector(int initialCapacity) {
        	//此处调用Vector的两个参数的有参构造
        	//initialCapacity为容量,0为下次需要扩容时,扩展的长度
            this(initialCapacity, 0);
    }
    
    //从上面的单个参数的有参构造跳转到这里
    public Vector(int initialCapacity, int capacityIncrement) {
            super();
        	//如果初始化的容量小于0,抛出异常
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
        	//创建容量为initialCapacity的Object数组
            this.elementData = new Object[initialCapacity];
        	//容量增长值
            this.capacityIncrement = capacityIncrement;
    }
    

    无参构造初始化后,elementData数组大小为10

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uT4sjjXr-1626583916166)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718103401459.png)]

    添加元素

    在这里插入图片描述

    从上面断点进入上面的方法中

    //modCount用于记录数组被修改的次数
    protected transient int modCount = 0;
    
    public synchronized boolean add(E e) {
        //修改次数加1
        modCount++;
        //进行添加操作  e:需要添加的元素  elementData:保存数据的数组  elementCount:添加的下标位置
        add(e, elementData, elementCount);
        return true;
    }
    

    在这里插入图片描述

    调用上面的add(e, elementData, elementCount)方法进入以下代码

    //进行添加操作  e:需要添加的元素  elementData:保存数据的数组  s:添加元素的下标位置
    private void add(E e, Object[] elementData, int s) {
        //添加的下标值是否等于elementData的长度 即是否容量已满
        if (s == elementData.length)
            //进行扩容操作
            elementData = grow();
        //将元素进行保存
        elementData[s] = e;
        //下一次添加元素的下标位置加1
        elementCount = s + 1;
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UuGdm1Fv-1626583916175)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718104252077.png)]

    当Vector的容量已满时,再次添加元素,需要进行扩容

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4oUrCvnM-1626583916178)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718104429194.png)]

    进行扩容操作

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ELnNd4ig-1626583916180)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718104637064.png)]

    //首先进入到这里
    private Object[] grow() {
        //进行扩容操作
        return grow(elementCount + 1);
    }
    
    
    //扩容操作
    private Object[] grow(int minCapacity) {
       		//之前的容量为elementData的长度
            int oldCapacity = elementData.length;
        	//新的容量主要看capacityIncrement > 0 ? capacityIncrement : oldCapacity
        	//如果指定的扩容长度大于0,则在原来的基础上加上指定的扩容长度 即newCapacity = oldCapacity + capacityIncrement
        	//否则在原来的基础上乘以2 即newCapacity = oldCapacity + oldCapacity
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    capacityIncrement > 0 ? capacityIncrement : oldCapacity
                                               /* preferred growth */);
        	//copyOf会保留原有的数据,在进行扩容
            return elementData = Arrays.copyOf(elementData, newCapacity);
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZoyfB792-1626583916182)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718105318031.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CodAEHU6-1626583916185)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718105434678.png)]

    (2)有参构造创建Vector对象(1个参数)

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mNv3IhZf-1626583916187)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718105552205.png)]

    //用于保存数据的Object数组
    protected Object[] elementData;
    //容量扩容值,即当需要扩容时,进行多大的扩容
    protected int capacityIncrement;
    
    //调用有参构造
    public Vector(int initialCapacity) {
        //调用两个参数的有参构造
        this(initialCapacity, 0);
    }
    
    //两个参数的有参构造 此时initialCapacity为8,capacityIncrement为0
    public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            //创建容量为initialCapacity的Object数组   this.elementData = new Object[8];
            this.elementData = new Object[initialCapacity];
        	//容量增长值   this.capacityIncrement = 0 
            this.capacityIncrement = capacityIncrement;
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S03gYlC1-1626583916189)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718110010402.png)]

    当容量已满时,进行扩容的操作与无参构造相同

    (3)有参构造创建Vector对象(2个参数)

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JUPMtCZB-1626583916190)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718110421399.png)]

    直接进入到两个参数的构造函数中

    //initialCapacity :初始容量  capacityIncrement:扩容长度
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //创建Object数组
        this.elementData = new Object[initialCapacity];
        //扩容长度赋值
        this.capacityIncrement = capacityIncrement;
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gtUouh8b-1626583916191)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718110714512.png)]

    当Vector的8个容量已满时,需要进行扩容

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9937X3Zm-1626583916193)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718110853684.png)]

    中间步骤都相同,这里只看下具体的扩容操作

    这里因为我们创建Vector对象是调用的是两个参数的构造函数,即给了它扩容的长度为2,所以此处扩容是在原来的基础上加了2

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iHi0k2YJ-1626583916195)(C:\Users\14538\AppData\Roaming\Typora\typora-user-images\image-20210718111045105.png)]

    3、Vector与ArrayList的简单比较

    底层结构版本线程安全(同步)效率扩容倍数
    ArrayList可变数组Object[]jdk1.2不安全,效率高如果为有参构造,初始化容量为指定容量,扩容为原容量的1.5倍; 如果为无参构造,初始化容量为10,之后每次扩充为原容量的1.5倍
    Vector可变数组Object[]jdk1.0安全, 效率不高如果为无参构造,初始化容量为10,扩容为原容量的2倍; 如果为单参数构造,初始化容量为指定容量,扩容为原容量的2倍; 如果为两个参数的构造,初始化容量为指定容量,扩容为原容量加上扩容长度
    展开全文
  • 简单了解javaVector扩容

    千次阅读 2019-08-27 14:19:34
    package com.example.demo.test; import java.util.Vector; /** * <p> * <code>VectorTest<... * 测试Vector扩容方式,通过测试可以看出其每次以2的倍数形式扩充Object数组 ...
    package com.example.demo.test;
    
    import java.util.Vector;
    
    /**
     * <p>
     * <code>VectorTest</code>
     * </p>
     * Description: JDK 1.8
     * 测试Vector的扩容方式,通过测试可以看出其每次以2的倍数形式扩充Object数组
     *
     * @author Jalen
     * @date 2019/8/27 13:31
     */
    public class VectorTest {
    
        public static void main(String[] args) {
            createEmptyVector();
        }
    
        /**
         * 创建Vector
         * 调用链1(初始化):
         *      {@link java.util.Vector#Vector(int)}
         *          传入capacity为2,如果为空,默认capacity是10
         *      {@link java.util.Vector#Vector(int, int)}
         *          第一个参数为初始容量initialCapacity,为2,第二个参数是capacityIncrement,默认在初始化时传0
         *          该操作创建一个2个长度的Object数组,且capacityIncrement赋值为0
         *          代码:
         *              super();
         *              if (initialCapacity < 0)
         *                  throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
         *              this.elementData = new Object[initialCapacity];
         *              this.capacityIncrement = capacityIncrement;
         * 调用链2:
         *      {@link java.util.Vector#add(Object)}
         *          synchronized修饰,modCount自增,计算容量(如果不够会执行扩容),根据下标为elementData赋值
         *          代码:
         *              modCount++;
         *              ensureCapacityHelper(elementCount + 1);  //elementCount=0,只需确保有一个空间可用
         *              elementData[elementCount++] = e;
         *              return true;
         *      {@link java.util.Vector#ensureCapacity(int)}
         *          这里传入的参数minCapacity为1,即我们需要的最小容量是1,elementData length是我们初始化时的容量2,此时不会扩容
         *              if (minCapacity - elementData.length > 0)
         *                  grow(minCapacity);
         *      elementData[elementCount++] = e; //因为无需扩容,直接根据数组下标赋值就好啦
         * 调用链3:
         *      此时和调用链2是一样的,不存在扩容
         * 调用链4:
         *      {@link java.util.Vector#add(Object)}
         *          synchronized修饰,modCount自增,计算容量(如果不够会执行扩容),根据下标为elementData赋值
         *          代码:
         *              modCount++;
         *              ensureCapacityHelper(elementCount + 1);  //elementCount=0,只需确保有一个空间可用
         *              elementData[elementCount++] = e;
         *              return true;
         *      {@link java.util.Vector#ensureCapacity(int)}
         *          这里传入的参数minCapacity为3,即我们需要的最小容量是3,elementData length是我们初始化时的容量2,此时会扩容
         *              if (minCapacity - elementData.length > 0)
         *                  grow(minCapacity);
         *      {@link java.util.Vector#grow(int)}
         *          计算新的容量,因为capacityIncrement初始化时是0,所以newCapacity = oldCapacity + oldCapacity,
         *          即新容量等于旧容量的2倍,elementData扩容为原来的2倍数,即4
         *          代码:
         *              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); //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
         *              elementData = Arrays.copyOf(elementData, newCapacity);
         *      最后根据下标赋值就好啦
         *          代码:
         *              elementData[elementCount++] = e;
         * 调用链5:
         *      因为上一步扩容到4,此时不会扩容
         * 调用链6:
         *      此时因为容量4已用完,会触发扩容,容量扩大到8
         */
        private static void createEmptyVector(){
            Vector<String> vector = new Vector<>(2); //1
            vector.add("aaa"); //2
            vector.add("bbb"); //3
            vector.add("ccc"); //4
            vector.add("ddd"); //5
            vector.add("eee"); //6
            System.out.println(vector.toString());
        }
    
        /**
         * 这里初始化时指定每次扩容的大小,交给用户设置
         */
        private static void createEmptyVectorWithIncrement(){
            Vector<String> vector = new Vector<>(2, 3);//初始容量为2,每次扩容空间为3
            vector.add("aaa"); //不扩容,容量为2
            vector.add("bbb"); //不扩容,容量为2
            vector.add("ccc"); //扩容,扩容为5
            vector.add("ddd"); //不扩容,容量为5
            vector.add("eee"); //不扩容,容量为5
            System.out.println(vector.toString());
        }
    }
    

     

    扩容方法:

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

    注意不同于ArrayList的扩容方式
    ArrayList扩容公式为:newCapacity  =  oldCapacity + oldCapacity >> 1

    展开全文
  • JDK1.7的ArrayList的 扩容机制源码。JDK1.7的源码是 ,在实例化这个 ArrayList 集合对象的时候。不管 调用者初始化完ArrayList对象后 继不继续 使不使用,在初始化对象的时候,都会创建一个长度为 10 的 Object 的...
  • 在面试后台开发的过程中,集合是面试的热话题,不仅要知道各集合的区别用法,还要知道集合的扩容机制,今天我们就来谈下ArrayList 和 HashMap的默认大小以及扩容机制。在 Java 7 中,查看源码可以知道:ArrayList 的...
  • Java集合的扩容机制

    2020-04-12 15:18:58
    在面试后台开发的过程中,集合是面试的热话题,不仅要知道各集合的的区别用法,还要知道集合的扩容机制,今天我们就来谈下ArrayList 和 HashMap的默认大小以及扩容机制。 在Java8中,查看源码可以知道:ArrayList 的...
  • 今天刚好遇到一个关于集合扩容的问题,正好借机整理一下: 当底层实现涉及到扩容时,容器或重新分配一段更大的连续内存(如果是离散分配则不需要重新分配,离散分配都是插入新元素时动态分配内存),要将容器原来...
  • java中各种集合的扩容机制记录总结

    千次阅读 2018-03-13 17:32:51
    参考:https://www.cnblogs.com/lq147760524/p/6713677.html JAVA中的部分需要扩容的内容总结如下:第一部分:HashMap 、HashSet、Hashtable第二部分:ArrayList、Vector、CopyOnWriteArrayList第三部分:...
  • 一、ArrayList简介 1.1、ArrayList概述 1)ArrayList是可以动态增长和缩减的索引...3)ArrayList的用法和Vector向类似,但是Vector是一个较老的集合,具有很多缺点,不建议使用。 4)ArrayList和Collection的关系
  • 由于它们的底层构成不同,以及数据的构造为单列、多列、可重复、不可重复,导致其扩容机制也不尽相同。 一、List 获取ArrayList 容量大小的方法: public static int getArrayListCapacity(ArrayList<?> ...
  • ArrayList和Vector扩容机制

    千次阅读 2015-07-16 13:55:32
    ArrayList和Vector都是继承了相同的父类和实现了相同的接口。如下  Java代码  public class Vector   extends AbstractList   implements List, RandomAccess, Cloneable, java.io....
  • JAVA中的部分需要扩容的内容总结如下: 第一部分:HashMap 、HashSet、Hashtable 第二部分:ArrayList、Vector、CopyOnWriteArrayList ...2、扩容机制。3、同类型之间对比。 1.1 HashMap: 一、初始容量定义:默认为...
  • vector扩容时以2倍或1.5倍扩容的原因

    千次阅读 2021-02-01 08:33:37
    vector扩容原理 Vector通过一个连续的数组存放元素,如果集合已满,在新增数据的时候,就要分配一块更大的内存,将原来的数据复制过来,释放之前的内存,在插入新增的元素; 对vector的任何操作,一旦引起空间重新...
  • JAVA中常见集合的扩容

    2020-12-24 19:02:05
    在面试后台开发的过程中,集合是面试的热话题,不仅要知道各集合的区别用法,还要知道集合的扩容机制,今天我们就来谈下ArrayList 和 HashMap的默认大小以及扩容机制。// from ArrayList.java JDK 1.7private static...
  • 本文使用Java 8+ 目录前言第一章 集合与数组概念第二章 集合框架1、集合...ArrayList源码剖析1、核心属性源码:2、构造方法(验证核心属性)3、ArrayList的扩容机制4、ArrayList扩容的核心方法。5、add方法(重点)当添.
  • 浅谈ArrayList及扩容机制 ArrayList ArrayList就是动态数组,其实就是Array的复杂版本,它提供了动态的添加元素和删除元素的方法,同时实现了Collection 和 List接口,能够灵活的设置数组的大小。 通过源码的分析,...
  • 线程安全,但速度慢底层数据结构为数组结构加载因子为1:即当元素个数超过容量长度时,进行扩容扩容增量:原容量的1倍如vector的容量为10,一次扩容后是容量为20ArrayList:线程不安全,查询速度快底层数据结构是...
  • 扩容机制 由于他和 ArrayList的机制类似,其他的代码,这里不再展示,只关心关键方法 newCapacity(int minCapacity): private int newCapacity(int minCapacity) { // overflow-conscious code int oldCapacity = ...
  • JAVA中的部分需要扩容的内容总结如下:第一部分:HashMap hmap=new HashMap<>();HashSet hset=new HashSet<>();Hashtable htable=new Hashtable<>();第二部分:CopyOnWriteArrayList coarray=new ...
  • 集合的扩容机制 List 元素是有序的、可重复 ArrayList、Vector默认初始容量为10 Vector:线程安全,但速度慢  底层数据结构是数组结构  加载因子为1:即当 元素个数 超过 容量长度 时,进行扩容  扩容增量:原...
  • vector的容量为10,一次扩容后是容量为20 ArrayList:线程不安全,查询速度快 底层数据结构是数组结构 扩容增量:原容量的0.5倍+1 如ArrayList的容量为10,一次扩容后是容量为16 Set元素无序、不可重复 hashset...
  • VectorVector的底层实现和扩容机制 public class Vector extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable { /** * The array buffer into which the components of the ...
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OW1GESNm-1603707176501)(C:\Users\hp\AppData\Roaming\Typora\typora-user-images\image-20201026141056486.png)] 初始操作 /** Default...
  • 默认长度是什么,说一下它的扩容机制 进入ArrayList类源码进行分析 分析思路: 1.查看arraylist类的介绍 2.理解arraylist类的属性含义 3.理解arraylist的构造方法 4..理解arraylist中比较重要的方法机制(如add、...
  • 扩容增量 扩容倍数 加载因子 ArrayList集合 数组 有序、不可重复、非线程安全 10 视情况而定 原容量的0.5倍 1.5倍 1 LinkedList集合 双向链表 有序、不可重复、非线程安全 ...
  • Java 中的数组相比,它的容量能动态增长。在添加大量元素前,应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。 ArrayList继承于 AbstractList,实现了 List, ...
  • 微信公众号: Java随笔录 关注可了解更多Java相关的技术分享。... ArrayList 扩容机制分析3.1. 先从 ArrayList 的构造函数说起3.2. 一步一步分析 ArrayList 扩容机制3.2.1. 先来看 `add` 方法3.2.2. 再来看看 `ensure.
  • - ArrayList是java集合框架很常用数据结构; - 实现list接口,继承 AbstractList ,基于数组实现容量大小动态变化 - 支持指针快速访问、浅拷贝 - 允许 null 元素的存在 - 实现RandomAccess、Cloneable、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,757
精华内容 3,502
关键字:

javavector自动扩容机制

java 订阅