精华内容
下载资源
问答
  • Java中实现数组动态扩容的两种方法java中初始化一个数组需要定义数组的容量,而在我们使用数组时往往会遇到数组容量不够的情况,此时我们就需要通过动态扩容的方式来来根据需求扩大数组的容量。我们可以通过两种方法...

    Java中实现数组动态扩容的两种方法

    java中初始化一个数组需要定义数组的容量,而在我们使用数组时往往会遇到数组容量不够的情况,此时我们就需要通过动态扩容的方式来来根据需求扩大数组的容量。

    我们可以通过两种方法来实现数组的动态扩容,一种是通过创建一个新的数组来覆盖旧数组,从而实现扩大数组容量的目的;另一种则是是通过java.util.Arrays类库来实现动态扩容。接下里我们分别对这两种方法进行分析。

    一、新数组覆盖旧数组

    当我们需要对数组进行扩容时,可以考虑不扩容数组本身,而是通过定义一个容量更大的数组,然后让原数组名称重新等于大数组即可。由于原数组数据在堆中,失去引用会被 GC 自动回收。示例如下:

    public static void main(String[] args) { int[] arr = {1,3,4}; //定义一个容量为3的数组arr int[] arr2 =new int[arr.length+1]; //定义一个新数组arr2,容量比arr大1 for(int i=0;i

    我们可以通过定义的新数组arr2的名称直接覆盖掉旧数组arr,原数组被自动回收,从而实现了数组的扩容,因此我们可以根据这个思路进行数组的动态扩容。目标如下:

    定义一个容量为1的数组,将系统输入的内容添加到数组中,并每添加一次对数组进行一次扩容。

    public static void main(String[] args) { Scanner input = new Scanner(System.in); int[] arr = new int[1]; //定义一个容量为1的数组arr int i =0; while(true) { //通过死循环来观察多次动态扩容的结果 int x = input.nextInt();//接收int类型的输入 arr[i] = x;//将输入传递给数组arr System.out.println(arr[i]); int[] arr2 = new int[arr.length + 1]; //定义一个新数组arr2,容量比arr大1 //通过循环对新数组赋值 for(int j=0;j

    输出的结果如下

    adb971b7679cc600fc66d615fb78bcf7.png

    二、调用Arrays类实现动态扩容

    除了新数组覆盖旧数组的暴力扩容法外,我们还可以通过调用系统自带的java.util.Arrays类中的方法对数组进行动态扩容。Arrays类中实现数组扩容的方法为copyof。(需要导入java.util.Arrays)

    copyof方法的扩容原理为使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度,调用格式为Arrays.copyof(原数组名,扩容后的数组大小)。示例如下:

    // An highlighted block public class ArrayTest { public static void main(String[] args) { int[] arr = {1, 3, 4}; //定义一个容量为3的数组arr arr = Arrays.copyOf(arr,7);//将数组arr扩容到7 arr[6] = 5; //给扩容后的数组下标6定义一个值 System.out.println(Arrays.toString(arr));//打印新数组 } }

    同样我们也使用Arrays类来实现数组的动态扩容,目标如下:

    定义一个大小为1的数组,每次输入三个数字,按从大到小的顺序定义到数组中,数组不够的位置通过Arrays类来实现数组的扩容。

    public static void main(String[] args) { Scanner input = new Scanner(System.in); int i = 3; int[] arr = {1, 3, 4}; //定义一个容量为3的数组arr while(true) { System.out.println("请输入三个数字"); //输入要添加的三个数字,分别定义为x1,x2,x3 int x1 = input.nextInt(); int x2 = input.nextInt(); int x3 = input.nextInt(); arr = Arrays.copyOf(arr, arr.length + 3);//将数组arr扩容3,并在扩容的位置分别赋值x1,x2,x3 arr[i] = x1; arr[i+1] = x2; arr[i+2] = x3; i = i + 3; System.out.println(Arrays.toString(arr));//打印新数组 } }

    输出如下

    0990cd108230e2a8285efd1e7ab2caeb.png

    本文地址:https://blog.csdn.net/LOVEGOOD1/article/details/108038123

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 有两种方法可以实现数组容量扩容: public class Demo1 { static int []array=new int [20]; public static void main(String[] args){ array=addLengthArray(array); for(int i ...

    java中,初始化数组要求指定数组容量,但在许多情况下需要扩充数组容量。

    有两种方法可以实现数组容量扩容:

    public class Demo1 {
    	
    	static int []array=new int [20];
    	public static void main(String[] args){
     
    		array=addLengthArray(array);
    		for(int i = 0;i<array.length;i++){
    			array[i]= i;
    			System.out.println(array[i]);
    		}
    	}
     
    	public static int[] addLengthArray(int[] array){
    		int[] newArray = new int [array.length*2];
                    //将array数组从0位置至array.length位置,复制到newArray数组0位置到array.length位置。
                    System.arraycopy(array,0,newArray,0,array.length);
    		return newArray;
    	}
     
    }

    1.上面的代码采用System.arraycopy方法实现,其声明为:

        System.arraycopy(Object src,int srcPos,Object dest,int destPos, int length) ;

    2.采用ArrayList类数组,它可以在需要时自动扩容;主要代码:Arrays.copyOf(arr,newLength)

    探索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,即完成了

     

    展开全文
  • 数组扩容拷贝

    2020-12-16 20:36:25
    一维数组扩容 怎么扩容的? 先新建一个大容量数组,然后将小容量数组中的数组一个一个拷贝到大数组中 一维数组扩容效率比较低。因为涉及到扩容的问题,在开发中尽可能的少进行数组的拷贝 最好在创建数组对象的...

    一维数组的扩容
    怎么扩容的?
    先新建一个大容量的数组,然后将小容量的数组中的数组一个一个拷贝到大数组中
    一维数组扩容效率比较低。因为涉及到扩容的问题,在开发中尽可能的少进行数组的拷贝
    最好在创建数组对象的时候预估一下多长合适。

    public class ArrayTest01 {
        public static void main(String[] args) {
            //数组拷贝。
            int[] src={1,2,3,4,5,5,6};
    
            //拷贝到这
            int [] dest =new int[20];//初始化一个20长度的数组,默认值0
    
            //调用System中的arraycopy来完成拷贝
            System.arraycopy(src,1,dest,1,2);
    
            //遍历
            for (int i = 0; i < dest.length; i++) {
                System.out.println(dest[i]);
    
            }
    
        }
    }
    
    
    展开全文
  • java中初始化一个数组需要定义数组的容量,而在我们使用数组时往往会遇到数组容量不够的情况,此时我们就需要通过动态扩容的方式来来根据需求扩大数组的容量。 我们可以通过两种方法来实现数组的动态扩容,一种是...

    Java中实现数组动态扩容的两种方法

    java中初始化一个数组需要定义数组的容量,而在我们使用数组时往往会遇到数组容量不够的情况,此时我们就需要通过动态扩容的方式来来根据需求扩大数组的容量。
    我们可以通过两种方法来实现数组的动态扩容,一种是通过创建一个新的数组来覆盖旧数组,从而实现扩大数组容量的目的;另一种则是是通过java.util.Arrays类库来实现动态扩容。接下里我们分别对这两种方法进行分析。

    一、新数组覆盖旧数组

    当我们需要对数组进行扩容时,可以考虑不扩容数组本身,而是通过定义一个容量更大的数组,然后让原数组名称重新等于大数组即可。由于原数组数据在堆中,失去引用会被 GC 自动回收。示例如下:

       public static void main(String[] args) {                                 
             int[] arr = {1,3,4};  //定义一个容量为3的数组arr                             
             int[] arr2 =new int[arr.length+1]; //定义一个新数组arr2,容量比arr大1          
               for(int i=0;i<arr.length;i++){//通过循环给新数组赋值                       
                   arr2[i]=arr[i];                                              
               }                                                                
             arr = arr2;//新数组覆盖旧数组                                              
             System.out.println(arr.length);//打印结果为4,数组扩容成功                     
       }                                                                        
    

    我们可以通过定义的新数组arr2的名称直接覆盖掉旧数组arr,原数组被自动回收,从而实现了数组的扩容,因此我们可以根据这个思路进行数组的动态扩容。目标如下:
    定义一个容量为1的数组,将系统输入的内容添加到数组中,并每添加一次对数组进行一次扩容。

       public static void main(String[] args) {                              
           Scanner input = new Scanner(System.in);                           
           int[] arr = new int[1];  //定义一个容量为1的数组arr                         
           int i =0;                                                         
           while(true) { //通过死循环来观察多次动态扩容的结果                                 
               int x = input.nextInt();//接收int类型的输入                          
               arr[i] = x;//将输入传递给数组arr                                      
               System.out.println(arr[i]);                                   
               int[] arr2 = new int[arr.length + 1]; //定义一个新数组arr2,容量比arr大1  
               //通过循环对新数组赋值                                                  
               for(int j=0;j<arr.length;j++){                                
                   arr2[j] = arr[j];                                         
               }                                                             
               arr = arr2;//新数组覆盖旧数组                                         
               i++;                                                          
               System.out.println(Arrays.toString(arr));//打印数组内的值            
           }                                                                 
       }                                                                     
    

    输出的结果如下
    在这里插入图片描述

    二、调用Arrays类实现动态扩容

    除了新数组覆盖旧数组的暴力扩容法外,我们还可以通过调用系统自带的java.util.Arrays类中的方法对数组进行动态扩容。Arrays类中实现数组扩容的方法为copyof。(需要导入java.util.Arrays)
    copyof方法的扩容原理为使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度,调用格式为Arrays.copyof(原数组名,扩容后的数组大小)。示例如下:

    // An highlighted block
    public class ArrayTest {                                     
        public static void main(String[] args) {                 
            int[] arr = {1, 3, 4};  //定义一个容量为3的数组arr             
            arr = Arrays.copyOf(arr,7);//将数组arr扩容到7              
            arr[6] = 5; //给扩容后的数组下标6定义一个值                        
            System.out.println(Arrays.toString(arr));//打印新数组     
        }                                                        
    }                                                            
    

    同样我们也使用Arrays类来实现数组的动态扩容,目标如下:
    定义一个大小为1的数组,每次输入三个数字,按从大到小的顺序定义到数组中,数组不够的位置通过Arrays类来实现数组的扩容。

       public static void main(String[] args) {                                                   
           Scanner input = new Scanner(System.in);                                                
           int i = 3;                                                                             
           int[] arr = {1, 3, 4};  //定义一个容量为3的数组arr                                               
           while(true) {                                                                          
               System.out.println("请输入三个数字"); //输入要添加的三个数字,分别定义为x1,x2,x3                          
               int x1 = input.nextInt();                                                          
               int x2 = input.nextInt();                                                          
               int x3 = input.nextInt();                                                          
               arr = Arrays.copyOf(arr, arr.length + 3);//将数组arr扩容3,并在扩容的位置分别赋值x1,x2,x3           
               arr[i] = x1;                                                                       
               arr[i+1] = x2;                                                                     
               arr[i+2] = x3;                                                                     
               i = i + 3;                                                                         
               System.out.println(Arrays.toString(arr));//打印新数组                                   
           }                                                                                      
       }                                                                                          
    

    输出如下
    在这里插入图片描述

    展开全文
  • 当元素太少时,就把数组容量缩小;扩容和缩容的实现是通过新建一个更大或更小的数组,把现有数组复制到新数组中,并用新数组代替现有数组。 扩容 扩容的策略是:添加元素时,如果容量已满,就将容量扩大一倍; //...
  • 数组扩容

    2020-08-20 18:06:44
    原来的数组所占据的空间将会... 数组扩容涉及数组的拷贝,数组拷贝会耗费大量的资源; 数组的优化: 创建数组的时候,预先估计数组中存储元素的个数,给定初始化容量,减少数组的拷贝,提高程序的执行效率。 ...
  • Java数组初始化需要指定数组容量,但是在许多情况下需要动态扩充容量。有两种方法可以实现:1.采用ArrayList类数组,它可以在需要时自动扩容;2.采用System.arraycopy方法实现,其声明为:araycopy(Object src,int ...
  • 关于数组扩容 java

    2020-07-17 19:57:45
    假如有一个int[] nums={1,2,3}的一维数组,我们要插入一个元素但我们知道数组的大小是固定的,我们要插入一个新的元素我们就只能扩容,扩大数组容量即大小。 扩容的步骤为: 1.创建一个临时数组,大小为原数组的...
  • 关于一维数组扩容: 在java开发中,数组长度一旦确定,不可改变。 那么数组满了怎么办?数组满了,需要扩容。 java中对数组扩容是: 先建立一个大容量数组,然后将小容量数组中的数据一个一个拷贝到大数组当中...
  • 答:数组需要扩容。 问:怎么扩容? 答:先建一个大容量数组,然后将小容量数组当中的数据一个一个拷贝到大数组当中去。 【注意】:数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中:尽可能少...
  • ArrayList底层创建Object[ ],长度为10,如添加元素导致容量不够,会扩容为原来的1.5倍,再把原有数组中数据复制到新数组 JDK8 做了改变,延迟了数组的创建,ArrayList底层数组是在第一次调用add()才创建,而在此...
  • 数组容量扩容问题: public class Test { public static void insert(int index, int element, int[] array, int size) { if (index < 0 || index > size) { System.err.println("下标错误"); ...
  • 从今天开始,每周周四写一点算法/数据结构相关的内容...动态数组允许使用者随时扩容数组,因此即使使用者不能确定数组将要容纳的元素个数,只需在动态数组容量不足时及时扩容,就可以正常使用数组。 3. 框架 下面给...
  • 数组扩容

    2020-10-04 16:30:40
    数组扩容 在java开发中,数组长度一旦确定不可变,那么数组满了怎么办? 数组满了,需要扩容。 java中对数组扩容是: 先新建一个大的容量数组,然后将小容量数组中的数据一个一个拷贝到大数组中去。 数组扩容...
  • 一、结论先行ArrayList在JDK1.8与JDK1.7底层区别JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组,当数组的长度不能容下所添加的内容时候,数组扩容至原大小的1.5倍JDK1.8:ArrayList像懒汉式,一开始...
  • 在文章开头先放一个传送门 【Java容器源码】ArrayList源码分析。是作者写的关于LInkedList源码的分析。这篇文章就仿写ArrayList,并实现容器... // 第一次扩容时的容量 private static final Object[] EMPTY_ELEMENT
  • java数组扩容

    2019-07-07 09:56:00
    有些时候使用数组代替栈,玩意数组容量不够需要扩容 则: 1.Array.toString();直接遍历打印数组 2.数组扩容采用Array.copyOf(),直接实现数组扩容功能,非常强大 (实际上,由于数组一旦实例化以后就不能改变...
  • Java 数组扩容

    2020-03-27 16:50:22
    数组扩容是指扩大数组容量添加元素。 在数组初始化后对数组进行扩容。 完整代码 public class Main { public static void main(String[] args) { String[] names = new String[] { "A", "B", "C" }; String[] ...
  • 需求:支持数组的尾部插入、按照index位置插入,当数组容量满后将数组扩容为原来的两倍,并迁移原来的数组数据到新的数组中。这里我将数组的增删查改操作和数组的扩容放到一个代码中。 package ...
  • 数组扩容--无序数组

    2020-01-05 14:07:52
    数组扩容–如何对一个数组进行有效的扩容 静态空间管理:开辟内部数组并适用一段地址连续的物理空间,capacity为总容量,size为当前的实际规模。若采用静态空间策略管理,容量capacity固定,则存在明显的不足。 上...
  • 数组扩容测试

    2019-10-09 01:10:00
    public class Test2 { public static void main(String[] args) { int [] its = {1,2,3}; int [] it2 = {4,5,6}; its = Arrays.copyOf(its, its.length+... //该操作只是将原来数组容量变大了,并没有进行复制 ...
  • 扩容机制其实就是新开辟一个新的空数组,新的数组容量要比原先数组要大,然后通过遍历将原先数组的元素赋给新的数组中,最后再将原先数组的引用指向新的数组,原先数组会因为没有引用就会被垃圾处理机制当成垃圾...
  • 接自定义数组(一),在前面的基础上加上了数组扩容的修改,这种情况是在存储的数据过大超过原先的数组容量时,为了避免数据溢出,来进行的操作。 public class SetArryList<E> { private Object[] ...
  • Swift数组扩容原理

    2018-01-03 02:47:14
    首先把结论写在文章开头,因为接下来的分析会有些啰嗦、复杂,如果不愿意深究的话只要记住Swift中数组扩容的原理是: Swift2中创建一个空数组,默认容量为2,当长度和容量相等,且还需要再添加元素时,创建一个 ...
  • JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组,当数组的长度不能容下所添加的内容时候,数组扩容至原大小的1.5倍 JDK1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,601
精华内容 1,040
关键字:

数组容量扩容