自定义实现Java动态数组

本文探讨了Java中动态数组的实现原理和设计,包括动态扩容的两种方式:固定倍数扩容和固定值扩容。文章详细介绍了动态数组的属性如size、elements,以及需要实现的初始化、查找、插入、删除等基本操作。在实际操作中,由于数组物理地址连续,扩容时需新申请内存并复制数据,然后释放旧内存。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

写在前面

通常,我们会用高级程序语言中的数组来描述线性表的顺序存储结构,而这种顺序表的特点时逻辑顺序物理顺序相同,即数组中元素的内存地址是连续的。

那么很显然,这样的数组(静态数组)在空间被占满后再往里添加数据,就会发生溢出,进而导致程序崩溃。

那么我们可能就需要它可以动态分配内存然后随时可以扩容。

原理

数组动态扩容的原理其实很简单,我们知道它无法承载更多数据的原因是因为内存空间不足,那么只需要将其需要的内存空间扩大就可以了。

但是很显然,我们不可能是在数组内存空间不足的时候,从计算机中再分配一块内存然后与之合并。因为我们知道数组,也就是顺序表它不仅仅是逻辑结构上的顺序,再实际物理结构上,它也保持着内存地址的连续性,简单来说就是:

假设现在有一个顺序表L
它的存储的起始位置为LOC(A)
sizeof(ElemType) 是每个数据元素所占用存储空间的大小
那么,第i个元素的内存地址为LOC(A)+(i-1)×sizeof(ElemType)
最后一位元素的内存地址为LOC(A)+(MaxSize-1)×sizeof(ElemType)

所以在实际操作时,我们没办法保证分配给数组的那块内存空间后面是空余的,因此这种分配方式显然无法满足要求。

那么数组动态扩容是如何实现的呢?
其实很简单,我们只需要再申请一块更大的内存,然后将原有数据复制过去就行,当然,还要将原本的内存空间释放掉。

而数组的扩容有两种方式:

  • 固定倍数扩容:设定好扩容的倍数,例如2,那么每一次扩容都只需要将数组的大小扩大为原来的2倍即可。
  • 固定值扩容:设定好扩容的大小。例如10,每一次扩容都将数组的长度扩大10

动态数组的设计

动态数组的属性

  • size:表示动态数组的大小,它可以表示动态数组的大小,也可以表示当前动态数组的元素个数。
  • elements:存储数据的数组(本质上还是一个静态数组),此处就以整型数组为例。
  • DEFAULT_CAPACITY:指定默认的动态数组的默认数组大小。
  • ELEMENT_NOT_FOUND:遍历循环查找元素时,如果找不到元素,就返回-1。
	//动态数组的属性
    private int size;
    private int[] elements;
    private static final int DEFAULT_CAPACITY=10;
    private static final int ELEMENT_NOT_FOUND=-1; 

动态数组的接口

动态数组需要实现以下的操作:

  1. 初始化
  2. 求数组长度
  3. 按值查找操作
  4. 按位查找操作
  5. 插入操作
  6. 删除操作
  7. 输出操作
  8. 判空操作
  9. 销毁操作

动态数组的实现


/**
 * Java语言下实现一些关于数组的基本操作
 * @author yequan17
 * @version 2022.3.27
 */
public class Array {

    public static void main(String[] args){
        //动态数组的属性:默认长度
        final int DEFAULT_CAPACITY=10;
        //初始化数组elements,设置其长度为DEFAULT_CAPACITY,在初始情况下,各位默认值为0,如果是其他数据类型,则默认值为null
        int[] elements=new int[DEFAULT_CAPACITY];
        String[] elementsString=new String[DEFAULT_CAPACITY];
        int size=elements.length;

        //验证初始化下整型数组元素默认的值
        System.out.println("初始化下整型数组元素默认的值如下:");
        for(int i=0;i<size;i++){
            System.out.println("第"+(i+1)+"位的元素是:"+elements[i]);
        }

        //验证初始化下字符型数组元素默认的值
        System.out.println("初始化下整型数组元素默认的值如下:");
        for(int i=0;i<size;i++){
            System.out.println("第"+(i+1)+"位的元素是:"+elementsString[i]);
        }

        //输出数组的长度
        System.out.println("数组的长度为:"+size);

        //为整型数组各位元素赋值
        for(int i=0;i<size;i++){
            elements[i]=i;
            System.out.println("第"+(i+1)+"位的元素是:"+elements[i]);
        }

        //按值查找(以字符型数组举例)
        //存在两种情况,一种是要查找的元素为null,还有一种是要查找的元素不为null。
        //为了更好地展示,我们将字符数组的第6位保留为null,其余赋值
        for(int i=0;i<size;i++){
            if(i==5) continue;
            else elementsString[i]="abc"+i;
        }
        //输出查看一下数组
        for(int i=0;i<size;i++){
            System.out.println("第"+(i+1)+"位的元素是:"+elementsString[i]);
        }

        //下面进行按值查找
        for(int i=0;i<size;i++){
            if(elementsString[i]==null){
                System.out.println("第"+i+"位元素为null");
            }
            else if(elementsString[i].equals("abc6")){
                System.out.println("第"+i+"位元素为"+"abc6");
            }
            else{
                System.out.println("第"+i+"位元素不是你要找的");
            }
        }

        //按位查找:输出特定位置的元素的值
        System.out.println("第i位元素的值为:"+elementsString[3]);

        //插入操作
        //很显然,在这里,数组所分配的内存空间其实已经用完了,如果想要插入元素,就会发生数组越界,导致程序崩溃,所以我们需要先进行的是数组扩容
        //数组扩容的方式有两种,固定倍数扩容,和固定值扩容
        //我们首先用固定倍数2进行扩容
        //获取当前数组的长度,尽管这个元素可以用size表示,但是我们更倾向于用size记录结果,即获取的长度,而不是其本身的长度
        int oldCapcity=elements.length;
        //通过位运算将数组扩大一倍
        int newCapacity=oldCapcity<<1;
        int[] newElements=new int[newCapacity];
        //将旧数组复制到新数组中
        for(int i=0;i<size;i++){
            newElements[i]=elements[i];
        }

        int newSize=newElements.length;
        System.out.println("扩容完的数组长度为"+newSize);
        //将新数组打印出来
        for(int i=0;i<newSize;i++){
            System.out.println(newElements[i]);
        }

        //固定值扩容实现起来也一样,只是把上面newCapacity设置为oldCapacity+固定值就行,此处就省略不写

        //数组扩容完成后,还有一步非常重要,那就是将旧数组所占用的内存空间释放掉
        //在Java中,当对象没有指针指向时,就会被自动回收,所以我们只需要将数组指向元素的指针设置为null,整型数组就是设为0,就可以了
        for(int i=0;i<size;i++){
            elements[i]=0;
        }

        //扩容已经完成,下面我们来完成插入元素
        //插入元素分为两种,一种是在数组最后插入元素,一种是在数组中间(或最前面插入元素)
        //我们现在在elements的开头插入99,在第8位插入100,在最后插入101
        //当然,elements已经不存在了,我们所有的操作其实是在newElements上实现的,只是对于逻辑而言,我们还是基于elements进行了扩容以及数据插入
        //对于不是在最后添加元素的,都会涉及部分数据后移,为了避免被覆盖,我们的后移应该从后往前发生
        //开头插入99
        for(int i=newSize-1;i>0;i--){
            newElements[i]=newElements[i-1];
        }
        newElements[0]=99;
        size++;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("插入元素后数组的长度为:"+size);

        //在第8位插入100
        for(int i=newSize-1;i>8;i--){
            newElements[i]=newElements[i-1];
        }
        newElements[8]=100;
        size++;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("插入元素后数组的长度为:"+size);

        //在末尾插入101
        newElements[size]=101;
        size++;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("插入元素后数组的长度为:"+size);

        //我们再来看一下删除操作
        //删除元素分为两种,一种是删除非末尾元素,一种是删除中间(或开头)元素
        //删除首位的99,即数据前移
        for(int i=1;i<newSize;i++){
            newElements[i-1]=newElements[i];
        }
        size--;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("删除元素后数组的长度为:"+size);

        //删除第8位的100
        for(int i=8;i<newSize;i++){
            newElements[i-1]=newElements[i];
        }
        size--;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("删除元素后数组的长度为:"+size);

        //删除最后的101
        newElements[--size]=0;
        size--;
        for(int i=0;i<newSize;i++){
            System.out.println("第"+i+"位元素为"+newElements[i]);
        }
        System.out.println("删除元素后数组的长度为:"+size);
    }
}

注意:

  1. 扩容时,固定倍数扩容可以时间最优,固定大小扩容可以空间最优
  2. 数组的物理地址也是连续的,无法做到从计算机中再分配一块内存然后与之合并,只能是新申请一块内存进行操作。
  3. 扩容后记得删除旧数组。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值