精华内容
下载资源
问答
  • ArrayList自动扩容原理

    2019-06-28 16:56:45
    ArrayList自动扩容原理 一、ArrayList三种初始化 1、默认的构造器,将会以默认的大小来初始化内部的数组 public ArrayList(); 2、用一个ICollection对象来构造,并将该集合的元素添加到ArrayList public ...

    ArrayList自动扩容原理

    一、ArrayList三种初始化

    1、默认的构造器,将会以默认的大小来初始化内部的数组

    public ArrayList();

    2、用一个ICollection对象来构造,并将该集合的元素添加到ArrayList

    public ArrayList(Collection<? extends E> c)

    3、用指定的大小来初始化内部的数组

    public ArrayList(int initialCapacity)

    二、扩容概括

         扩容概括为两步:

         1、扩容---把原来的数组复制到另一个内存空间更大的数组中

         2、添加元素---把新元素添加到扩容以后的数组中

    下面详细介绍扩容代码的实现原理和方法之间的调用关系

    三、自动扩容从ArrayList初始化开始

    1、无参构造方法:创建一个空数组

    transient Object[] elementData;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    
    
    /**
     *无参构造方法实现创建一个空数组,并且为这个数组赋一个空值
     *
    */
    public ArrayList() {
            super();
            //为数组赋空值
            this.elementData = EMPTY_ELEMENTDATA;    
        }

    2、扩容从add( )开始

     /**
         *1、 ArrayList 扩容从add()开始
         *2、add方法有两条语句如下:
         *   ensureCapacityInternal(size + 1); 判断是否需要调用扩容方法
         *   elementData[size++] = e;  调用add方法添加的值赋值给数组。
         * 
         */
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }

    3、ensureCapacityInternal:判断是否需要扩容

        //1、add方法调用ensureCapacityInternal方法
    private void ensureCapacityInternal(int minCapacity) {
        //2、判断当前数组是否为空
            if (elementData == EMPTY_ELEMENTDATA) {
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
        //3、调用扩容判断的方法,将当前最小扩容值传进去。
            ensureExplicitCapacity(minCapacity);
        }
    
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
        
         /**
         * 4、minCapacity:最小扩容值
         *elementData.length:数组空间长度
         * 判断是否扩容原理:
         * (最小扩容值 - 数组空间长度 > 0)则调用扩容方法grow(minCapacity);
         * 举例:第一次调用add方法,最小扩容值为11,数组长度为10 那么(11- 10 > 0)调用扩容,扩容后是当 
         *前值的1.5倍=15。            
         * 第二次调用add方法,最小扩容值+1是12,数组长度为15那么(12- 15 > 0)不大于0,不调用扩容方法
         */
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }

    4、grow(minCapacity) :计算扩容空间大小,并调用复制数组方法。

        private void grow(int minCapacity) {
            // overflow-conscious code
        //1、获取现在数组的长度
            int oldCapacity = elementData.length;
        //2、扩容后的数组长度
        //  oldCapacity >> 1    右移运算符   原来长度的一半 再加上原长度也就是每次扩容是原来的1.5倍
            int newCapacity = oldCapacity + (oldCapacity >> 1);
        //3、判断扩容后的长度是否小于需要的最小扩容
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
        //4、判断扩容后的长度是否超过规定的最大值
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
        //5、调用复制数组方法,将老的数组复制到新的数组中,并将需要添加的元素加到数组最后一位
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

     

    展开全文
  • Java ArrayList自动扩容机制

    万次阅读 2018-09-12 17:54:49
     ArrayList底层是基于数组实现的,是一个动态数组,自动扩容。  ArrayList不是线程安全的,只能用在单线程环境下。  实现了Serializable接口,因此它支持序列化,能够通过序列化传输;  实现了RandomAccess接口...

    ArrayList介绍

          ArrayList底层是基于数组实现的,是一个动态数组,自动扩容。
          ArrayList不是线程安全的,只能用在单线程环境下。
          实现了Serializable接口,因此它支持序列化,能够通过序列化传输;
          实现了RandomAccess接口,支持快速随机访问,实际上就是通过下标序号进行快速访问;
          实现了Cloneable接口,能被克隆。

    动态扩容

    一 初始化

          JDK1.7通过无参构造方法(初始长度默认10,以默认的大小来初始化内部的数组)、有参构造方法对数组进行初始化。

    二  确保内部容量

         通过判断,如果够则不进行操作;容量不够就扩充来确保内部容量。

             ① ensureCapacityInternal方法名的英文大致是“确保内部容量”,size表示的是执行添加之前的元素个数,并非ArrayList的容量,容量应该是数组elementData的长度。ensureCapacityInternal该方法通过将现有的元素个数数组的容量比较。看如果需要扩容,则扩容。 
             ②是将要添加的元素放置到相应的数组中。 

             *根据传入的最小需要容量minCapacity来和数组的容量长度对比,如果minCapacity大于或等于数组容量,则需要进行扩容。

    三 扩容

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // jdk1.7采用位运算比以前的计算方式更快
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //jdk1.7这里增加了对元素个数的最大个数判断,MAX_ARRAY_SIZE 为int最大值减去8。
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // 最重要的复制元素方法   Arrays.copyOf() 
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    综述:ArrayList在第一次插入元素add()时分配10(默认)个对象空间。假如有20个数据需要添加,那么会在第11个数据的时候(原始数组容量存满时),按照1.5倍增长;之后扩容会按照1.5倍增长(10、15、22、、、)。

         每次扩容都是通过Arrays.copyOf(elementData, newCapacity) 这样的方式实现的。ArrayList的自动扩容机制底层借助于System实现System.arraycopy(0,oldsrc,0,newsrc,length);

    扩展System源码中的arraycopy()标识为native意味JDK的本地库,不可避免的会进行IO操作,如果频繁的对ArrayList进行扩容,毫不疑问会降低ArrayList的使用性能,因此当我们确定添加元素的个数的时候,我们可以事先知道并指定ArrayList的可存储元素的个数,这样当我们向ArrayList中加入元素的时候,就可以避免ArrayList的自动扩容,从而提高ArrayList的性能。

    注意:实现环境:JDK1.7。(注:不同版本的JDK扩容机制略有区别)

    JDK1.8扩容机制:https://blog.csdn.net/yang1464657625/article/details/59109133

    重写list.add(),get(),equal(),remove(),size():https://blog.csdn.net/qq_36258792/article/details/74234797

    展开全文
  • ArrayList自动扩容机制

    2019-12-18 14:30:33
    ArrayList 操作的底层其实是Object[] 数组,对该数组进行了包装。 ArrayList 在创建时若不指定元素个数,会使用默认值:private static final int DEFAULT_CAPACITY = 10; 内部相当于创建了一个: Object[] object...

    ArrayList 操作的底层其实是Object[] 数组,对该数组进行了包装。

    ArrayList 在创建时若不指定元素个数,会使用默认值:private static final int DEFAULT_CAPACITY = 10;

    内部相当于创建了一个: Object[] object = new Object[10];

    应为数组的容量在创建时指定,且固定不可变,ArrayList添加元素个数超过了10个时,该数组就已经满了,

    然后会调用private void grow(int minCapacity){。。。。}方法来扩容,实际就是创建一个新数组,长度为

    int newCapacity = oldCapacity + (oldCapacity >> 1);//原来的1.5倍

    然后把旧数组复制过来,使用新数组进行操作:

    elementData = Arrays.copyOf(elementData, newCapacity);//扩展空间并复制

     

    展开全文
  • ArrayList自动扩容解析

    2017-10-27 15:05:12
    探索ArrayList自动改变size真相 ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变 大小的,实际上它只是改变了该...
    探索ArrayList自动改变size真相
    ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变
    大小的,实际上它只是改变了该引用型数组的指向而已。下面,让我们来看看java是怎样实现ArrayList类的。
    一、ArrayList类的实质
         ArrayList底层采用Object类型的数组实现,当使用不带参数的构造方法生成ArrayList对象时,
    实际上会在底层生成一个长度为10的Object类型数组。
        首先,ArrayList定义了一个私有的未被序列化的数组elementData,用来存储ArrayList的对象列表(注意只定义未初始):
      private transient Object[] elementData;
        
        其次,以指定初始容量(Capacity)或把指定的Collection转换为引用型数组后实例化elementData数组;如果没有指定,则预置初始容量为10进行
    实例化。把私有数组预先实例化,然后通过copyOf方法覆盖原数组,是实现自动改变ArrayList的大小(size)的关键。有人说ArrayList是复杂的数组,我
    认为不如说ArrayList是关于数组的系统的方法组合。
      ArrayList的构造方法源码如下:
        // 用指定的初始容量构造一个空列表。
        public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
            this.elementData = new Object[initialCapacity];//属性指向新建长度为初始容量的临时数组
        }
        // 使用初始容量10构造一个空列表
        public ArrayList() {
            this(10);
        }
        / *构造包含利用collection的迭代器按顺序返回的指定collection元素的列表
         @param c 集合,它的元素被用来放入列表t
         @throws NullPointerException 如果指定集合为 null
         */
        public ArrayList(Collection<? extends E> c) {
            elementData = c.toArray();//用Collection初始化数组elementData
            size = elementData.length;
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
    二、ArrayList实现自动改变size机制
       为了实现这一机制,java引进了Capacity和size概念,以区别数组的length。为了保证用户增加新的列表对象,java设置了最小容量(minCapacity)
    ,通常情况上,它大于列表对象的数目,所以Capactiy虽然就是底层数组的长度(length),但是对于最终用户来讲,它是无意义的。而size存储着列表
    对象的数量,才是最终用户所需要的。为了防止用户错误修改,这一属性被设置为privae的,不过可以通过size()获取。
       下面,对ArrayList的初始以及其列表对象的增加和删除等三种情况下的size自动改变机制进行分析。
       1、初始Capacity和size值。
       从上面给出的ArrayList构造方法源码中,我们不难看出Capacity初始值(initialCapacity)可以由用户直接指定或由用户指定的Collection集合存
    储的对象数目确定,如果没有指定,系统默认为10。而size的被声明为int型变量,默认为0,当用户指定Collection创建ArrayList时,size值等于
    initialCapacity。
     
       2、add()方法
        该方法的源码如下:
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);
            elementData[size++] = e;//添加对象时,自增size
            return true;
        }
        方法中调用的ensureCapacityInternal主要用来调整容量,修改elementData数组的指向。其中涉及到3个方法的调用,其核心在于grow方法:
        
        private void ensureCapacityInternal(int minCapacity) {
            modCount++;//定义于ArrayList的父类AbstractList,用于存储结构修改次数
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }  
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量扩大到原容量的1.5倍,右移一位相关于原数值除以2。
            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);
        }
        private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0// overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;//MAX_ARRAY_SIZE和Integer.MAX_VALUE为常量,详细请参阅下面的注解
        }
       
       通过以上代码,我们可知java自动增加ArrayList大小的思路是:向ArrayList添加对象时,原对象数目加1如果大于原底层数组长度,则以适当长度新
    建一个原数组的拷贝,并修改原数组,指向这个新建数组。原数组自动抛弃(java垃圾回收机制会自动回收)。size则在向数组添加对象,自增1
     
       注解:
        //定义于该类的常量,用来分配数组的size最大值。一些 VMs在数组里保留字头,试图分配更大数组时可能导致OutOfMemoryError:被请求数组的
    size超出VM界限。
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
       //在java.lang.Integer类中常量MIN_VALUE、MAX_VALUE如下:
       public static final int   MIN_VALUE = 0x80000000;//整型取值区间下界:-2147483648
       public static final int   MAX_VALUE = 0x7fffffff;//整型取值区间上界:2147483647
      //在java.util.AbstractList中modCount定义如下:
      protected transient int modCount = 0;
        3、remove()方法
        该重构方法其一源码如下(其它的就不累述了):
        public E remove(int index) {
            rangeCheck(index);
            modCount++;
            E oldValue = elementData(index);
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);//将后面的列表对象前移
            elementData[--size] = null// 数组前移一位,size自减,空出来的位置置null,具体的对象的销毁由Junk收集器负责
            return oldValue;
        }
        private void rangeCheck(int index) {//边界检查
            if (index < 0 || index >= this.size)
               throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
        E elementData(int index) {//获取指定index所在位置的对象
            return (E) elementData[index];
        }
     
        通过remove()源码的学习,我们不难看出,其改变ArrayList大小的核心与add()方法相似,都是同数组拷贝。
        另外,如果确有必要,用户也可以指定ArrayList实例的容量,可以有效的降低时间成本。它是通过调用ensureCapacityInternal来实现的,源代码
    如下:
        public void ensureCapacity(int minCapacity) {
            if (minCapacity > 0)
                ensureCapacityInternal(minCapacity);
        }
        因为size为private的,java给出方法来访问它:
        public int size() {
             checkForComodification();
             return this.size;
        }
     
        综上所述,在用户向ArrayList追加对象时,Java总是要先计算容量(Capacity)是否适当,若容量不足则把原数组拷贝到以指定容量为长度创建的
    新数组内,并对原数组变量重新赋值,指向新数组。在这同时,size进行自增1。在删除对象时,先使用拷贝方法把指定index后面的对象前移1位(如果

    有的话),然后把空出来的位置置null,交给Junk收集器销毁,size自减1,即完成了




    都知道ArrayList是基于数组的,那它是怎么实现可变的呢?


    创建ArrayList对象时,ArrayList有个带参数的构造函数,那个参数的意思就代表着ArrayList长度,默认情况是10。当数据多了,ArrayList容不下时,这时ArrayList会增加长度,newLength = oldLength + oldLength/2;如果初始值是10,那么依次是15,22,33,49,73......,长度是增加了,那是怎样实现的呢?当数据容不下时,ArrayList会再创建一个更大的数组,数组长度为之前所说的那样,然后将之前的数据拷贝到新数组中。这就是ArrayList基于数组实现的可变长度原理。


    下面详细解释下:


    1、代码如下






    ArrayList初始化时没有设置容量大小,随后给他添加10个字符串,size变为10;当10个字符串添加完之后,继续添加,这时ArrayList容量增加到15,size变为11。如果当ArrayList容量又满了时,这时ArrayList容量增加到22,以此类推(10,15,22,33,49......),newCapacity = oldCapacity+(oldCapacity/2),截图如下:





    2、如果ArrayList初始化时不给其设置容量大小,当调用add方法时,会给其默认分配10容量值。



    3、ArrayList中add方法

    [java] view plain copy
    1. /** 
    2.     * Appends the specified element to the end of this list. 
    3.     * 
    4.     * @param e element to be appended to this list 
    5.     * @return <tt>true</tt> (as specified by {@link Collection#add}) 
    6.     */  
    7.    public boolean add(E e) {  
    8.        ensureCapacityInternal(size + 1);  // Increments modCount!!  
    9.        elementData[size++] = e;  
    10.        return true;  
    11.    }  
    添加操作,首先会调用ensureCapacityInternal(size + 1),其作用为保证数组的容量始终够用,其中size是elementData数组中元组的个数,初始为0。


    ArrayList中ensureCapacityInternal方法

    [java] view plain copy
    1. private void ensureCapacityInternal(int minCapacity) {  
    2.        if (elementData == EMPTY_ELEMENTDATA) {  
    3.            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  
    4.        }  
    5.   
    6.        ensureExplicitCapacity(minCapacity);  
    7.    }  
    8.   
    9.    private void ensureExplicitCapacity(int minCapacity) {  
    10.        modCount++;  
    11.   
    12.        // overflow-conscious code  
    13.        if (minCapacity - elementData.length > 0)  
    14.            grow(minCapacity);  
    15.    }  
    ensureCapacityInternal()函数中,用if判断,如果数组没有元素,给数组一个默认大小,会选择实例化时的值与默认大小中较大值,然后调用ensureExplicitCapacity()。



    ArrayList中grow方法

    [java] view plain copy
    1. /** 
    2.    * Increases the capacity to ensure that it can hold at least the 
    3.    * number of elements specified by the minimum capacity argument. 
    4.    * 
    5.    * @param minCapacity the desired minimum capacity 
    6.    */  
    7.   private void grow(int minCapacity) {  
    8.       // overflow-conscious code  
    9.       int oldCapacity = elementData.length;  
    10.       int newCapacity = oldCapacity + (oldCapacity >> 1);  
    11.       if (newCapacity - minCapacity < 0)  
    12.           newCapacity = minCapacity;  
    13.       if (newCapacity - MAX_ARRAY_SIZE > 0)  
    14.           newCapacity = hugeCapacity(minCapacity);  
    15.       // minCapacity is usually close to size, so this is a win:  
    16.       elementData = Arrays.copyOf(elementData, newCapacity);  
    17.   }  

    函数体中,modCount是数组发生size更改的次数。然后if判断,如果数组长度小于默认的容量10,则调用扩大数组大小的方法grow()。

    [java] view plain copy
    1. >>表示带符号右移,如:int i=15; i>>2的结果是3,移出的部分将被抛弃。  
    2. 转为二进制的形式可能更好理解,0000 1111(15)右移2位的结果是0000 0011(3),0001 1010(18)右移3位的结果是0000 0011(3)。  
    10>>1 为5 


    15>>1 为7


    22>>1 为11 


    4、从内部实现机制来讲ArrayList是使用数组(Array)来控制集合中的对象。当你增加元素的时候,如果元素的数目超出了内部数组目前的长度,它需要扩展内部数组的长度,ArrayList是原来的50%,即newCapacity = oldCapacity+(oldCapacity/2)



    展开全文
  • Java ArrayList自动扩容

    2017-04-07 17:35:32
    探索ArrayList自动改变size真相 ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变 大小的,实际上它只是改变了该引用型...
  • 关于ArrayList自动扩容

    2017-04-07 17:28:51
    探索ArrayList自动改变size真相 ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变 大小的,实际上它只是改变了该引用型...
  • 不同的JDK版本的扩容机制可能有差异 实验环境:JDK1.8    扩容机制:    当向ArrayList中添加元素的时候,ArrayList如果要满足新元素的存储超过ArrayList存储新元素前的存储能力,ArrayList会增强自身的存储能力...
  • 当添加第2个元素时,此时的minCapacity=2,此时elementData.length(即是容量)在添加第一个元素后扩容成10了,所以minCapacity,不会进入grow(minCapacity)方法,数组容量仍为10不变 所以当添加第3、4···到第10个...
  • 探索ArrayList自动改变size真相 ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变 大小的,实际上它只是改变了该引用型...
  • ArrayList介绍 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionU...
  • ArrayList简介 ArrayList 是 java 集合框架中比较常用的数据结构。继承自 AbstractList,实现了 List 接口。基于数组实现容量大小动态变化。同时还实现了 RandomAccess、Cloneable、Serializable 接口,所以...
  • ArrayList自动扩容原理(底层实现)

    千次阅读 2018-11-10 00:38:29
         ArrayList的列表对象实质上是存储在一个引用型数组里的,有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说,该数组是无法改变 大小的,实际上它只是改变了该引用型数组的指向而已。下面,...
  • ArrayList类的成员变量 //默认的数组容量 private static final int DEFAULT_CAPACITY = 10; //一个空的Object数组 private static final Object[] EMPTY_ELEMENTDATA = {}; //一个空的Object数组,同上面的区别是...
  • 目录 扩充容量的方法ensureCapacity。 ...当容量不足以容纳当前的元素个数时,就设置新的容量为旧的容量的1.5倍加1,如果设置后的新容量还不够,则直接新容量设置为传入的参数(也就是所需的...
  • ArrayList 如何自动扩容

    2021-01-19 14:46:06
    数组最大的优势是根据下标获取数据的...其实是java.util.ArrayList自己实现了自动扩容。 现在我们就来分析一下,java.util.ArrayList 是如何自动扩容的。 我们一般初始化一个ArrayList的方法是用它的构造方法 ArrayLis
  • Arraylist动态扩容详解

    2019-09-24 07:37:53
    Arraylist动态扩容详解 ArrayList 概述 ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长。 ArrayList不是线程安全的,只能用在单线程环境下。 实现了Serializable接口,因此它支持序列...
  • ArrayList底层扩容代码

    2020-07-29 23:48:36
    谁都知道ArrayList底层是数组,并且会自动扩容。那面试官就问了,ArrayList是怎么扩容的?什么时候它会进行扩容?扩容多少? 既然是扩容问题,二话不说,先看源码 private Object[] grow(int minCapacity) { ret
  • 今天小编就为大家分享一篇对Java ArrayList自动扩容机制示例讲解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • ArrayList扩容机制

    千次阅读 2017-08-23 10:06:33
    ArrayList是基于数组实现的,是一个动态的数组,其容量可以自动的增长,我们具体来看一下Arraylist扩容机制的主要源码。 public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!!...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 624
精华内容 249
关键字:

arraylist自动扩容