由浅到深带你详谈Java实现数组扩容的三种方式
作者：程序yang 发布时间：2023-07-05 18:37:19
1.新建一个数组，把原来数组的内容搬到新数组中。
这种方法实现的思路是：先新建一个数组（前提条件是长度得比原来的长），然后把原来数组的内容搬到新数组中.
案例分析：
public static void main(String[] args) {
// 利用函数的方法进行数组的扩充
// 定义一个小型的数组
int[] a = { 1, 2, 3, 4, 5 };
// 调用扩容函数
a= expand1(a);
// 测试是否扩容完成，输出此时数组a中的值
for (int i = 0; i < a.length; i++) {
System.out.println("数组元素:" + a[i]);
}
}
// 扩容函数1，
public static int[] expand1(int a[]) {
// 定义一个新数组b，并为其赋值长度为数组a的二倍
int b[] = new int[a.length * 2];
// 将数组a的元素循环遍历到数组b中
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
System.out.println("数组扩容方法1:" + Arrays.toString(b));
return b;
}
输出结果：
数组扩容方法1:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
数组元素:1
数组元素:2
数组元素:3
数组元素:4
数组元素:5
数组元素:0
数组元素:0
数组元素:0
数组元素:0
数组元素:0
2.使用system.arraycopy()
常用作数组的扩容，如ArrayList底层数组的扩容
方法解析：
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
通过上面的源码可以看到，arraycopy它是一个静态本地方法，由虚拟机实现，效率自然比用java一个个复制高。
将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。 阵列组件的一个子序列被从通过引用的源阵列复制src被引用的目标阵列dest 。 复制的组件数等于length参数。 在位置的部件srcPos通过srcPos+length-1源阵列中的被复制到的位置destPos通过destPos+length-1分别，目的地阵列。
大白话总结：
从源数组src取元素，范围为下标srcPos到srcPos+length-1，取出共length个元素，存放到目标数组中，存放位置为下标destPos到destPos+length-1。简单说，就是数组间的复制。
参数解释：
src 源数组；
srcPos 源数组中的起始位置；
dest 目标数组；
destPos 目标数组中的起始位置；
length 要复制的数组元素的数量
注意事项：
1.若src和dest参数引用相同的数组对象，则执行复制，就好像位置 srcPos 到 srcPos + length - 1 的组件首次复制到具有 length 组件的临时数组，然后临时数组的内容被复制到位置 destPos 通过目标数组的 destPos + length - 1 。
2.若 src 是 null ，则抛java.lang.NullPointerException异常，并且不修改目标阵列。案例演示如下：
public static void main(String[] args) {
int[] src = { 1, 2, 3, 4 };
int[] dest = null;
System.arraycopy(src, 0, dest, 0, 4);//抛异常：java.lang.NullPointerException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有4个元素，索引是0-3，
dest目标数组为null，
当执行System.arraycopy(src, 0, dest, 0, 4);时，
第一步：由于dest为null，arraycopy方法检查到null操作，所以就会抛空指针异常。（如果你想深入理解，可以去了解一下arraycopy的底层源码。）
3.srcPos 的设置主要看 destPos 和 length ，若 srcPos 该位置往后的元素少于要复制的数组元素的数量（即 srcPos + length 的长度已经超过源数组元素的数量/个数，不是长度/索引；或者 destPos + length 的长度已经超过目标数组元素的数量/个数，不是长度/索引；），则会抛java.lang.ArrayIndexOutOfBoundsException异常。案例演示如下：
//src.length < srcPos + length
public static void main(String[] args) {
String[] src = { "aa", "bb", "cc", "dd" };
String[] dest = new String[] { "a", "b", "c", "d", "e" };
System.arraycopy(src, 1, dest, 1, 4);//抛异常java.lang.ArrayIndexOutOfBoundsException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有4个元素，索引是0-3，
dest目标数组共有5个元素，索引是0-4，
当执行System.arraycopy(src, 1, dest, 1, 4);时，
第一步：srcPos为1，即从源数组（src）中，从下标1开始取，
第二步：length为4，即取4个元素，也就是src[1]-src[4]，即从“bb”之后要取4个元素，这时源数组（src）只有“bb”、“cc”、“dd” 3个元素，明显不够4个元素，所以就会抛数组索引越界异常。
//dest.length < destPos + length
public static void main(String[] args) {
String[] src = { "aa", "bb", "cc", "dd" };
String[] dest = new String[] { "a", "b", "c", "d", "e" };
System.arraycopy(src, 0, dest, 2, 4);//抛异常java.lang.ArrayIndexOutOfBoundsException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有4个元素，索引是0-3，
dest目标数组共有5个元素，索引是0-4，
当执行System.arraycopy(src, 0, dest, 2, 4);时，
第一步：srcPos为0，即从源数组（src）中，从下标0开始取，
第二步：length为4，即取4个元素，也就是src[0]-src[3]，即从“aa”之后要取4个元素；分别是“aa”、“bb”、“cc”、“dd” 4个元素
第三步：把从源数组（src）取出的数（“aa”、“bb”、“cc”、“dd” 4个元素），按顺序，存放到目标数组（dest）中，从下标2开始存，存4个，也就是dest[2]-dest[5]，由于dest目标数组最大索引为4，只能存放“aa”、“bb”、“cc”，存不下“dd”，即不够容量存放4个数，所以就会抛数组索引越界异常。
4.若 dest 是 null ，则抛java.lang.NullPointerException异常，同上/参考2。
5.destPos 的设置主要看 srcPos 和 length ，若 destPos 该位置容纳不下要复制的数组元素（即 destPos + length 的长度已经超过目标数组元素的数量/个数，不是长度/索引；或者 srcPos + length 的长度已经超过源数组元素的数量/个数，不是长度/索引；），则会抛java.lang.ArrayIndexOutOfBoundsException异常。同上/参考3。
6.length 的设置主要看 srcPos 和 destPos，若 length 超出源数组中的起始位置之后的元素数量（即 srcPos 往后的元素数量/个数，不是长度/索引 ）或者 length 超出目标数组中的起始位置的元素数量（即 destPos 往后的元素数量/个数，不是长度/索引），则会抛java.lang.ArrayIndexOutOfBoundsException异常。
// length > srcPos.length - srcPos[index]
public static void main(String[] args) {
String[] src = { "aa", "bb", "cc", "dd" };
String[] dest = new String[] { "a", "b", "c", "d", "e" };
System.arraycopy(src, 2, dest, 2, 3);// 抛异常java.lang.ArrayIndexOutOfBoundsException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有4个元素，索引是0-3，
dest目标数组共有5个元素，索引是0-4，
当执行System.arraycopy(src, 2, dest, 2, 3);时，
第一步：srcPos为2，即从源数组（src）中，从下标2开始取，
第二步：length为3，即取3个元素，也就是src[2]-src[4]，即从“cc”之后要取3个元素，这时源数组（src）只有“cc”、“dd” 2个元素，明显不够3个元素，所以就会抛数组索引越界异常。
// length > destPos.length - destPos[index]
public static void main(String[] args) {
String[] src = { "aa", "bb", "cc", "dd" };
String[] dest = new String[] { "a", "b", "c", "d", "e" };
System.arraycopy(src, 2, dest, 4, 2);// 抛异常java.lang.ArrayIndexOutOfBoundsException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有4个元素，索引是0-3，
dest目标数组共有5个元素，索引是0-4，
当执行System.arraycopy(src, 2, dest, 4, 2);时，
第一步：srcPos为2，即从源数组（src）中，从下标2开始取，
第二步：length为2，即取2个元素，也就是src[2]-src[3]，即从“cc”之后要取2个元素，分别是“cc”、“dd” 2个元素；
第三步：把从源数组（src）取出的数（“cc”、“dd” 2个元素），按顺序，存放到目标数组（dest）中，从下标4开始存，存2个，也就是dest[4]-dest[5]，由于dest目标数组最大索引为4，只能存放“cc”，存不下“dd”，即不够容量存放2个数，所以就会抛数组索引越界异常。
7.当srcPos 、destPos 和 length 任意一个参数小于0时，则会抛
java.lang.ArrayIndexOutOfBoundsException异常。
//srcPos < 0 || destPos < 0 || length < 0
public static void main(String[] args) {
String[] src = { "aa", "bb", "cc", "dd" };
String[] dest = new String[] { "a", "b", "c", "d", "e" };
System.arraycopy(src, -1, dest, 1, 1);//抛异常java.lang.ArrayIndexOutOfBoundsException
for (Object o : dest) {
System.out.println(o);
}
}
解析：
src源数组共有04个元素，索引是0-3，
dest目标数组共有5个元素，索引是0-4，
当执行System.arraycopy(src, -1, dest, 1, 1);时，
第一步：srcPos为-1，不在索引0-3范围内，所以就会抛数组索引越界异常。
📌补充点：
8.当源数组和目标数组两组数据的元素类型不匹配时，则会抛
java.lang.ArrayStoreException异常，并且不修改目标数组。
public static void main(String[] args) {
int[] src = { 1, 2, 3, 4 };
Object[] dest = new Object[3];
System.arraycopy(src, 0, dest, 0, 3);//抛异常java.lang.ArrayStoreException
for (Object o : dest) {
System.out.println(o);
}
}
或
public static void main(String[] args) {
Object[] src = { 1, 2, 3, 4 };
int[] dest = new int[3];
System.arraycopy(src, 0, dest, 0, 3);// 抛异常java.lang.ArrayStoreException
for (Object o : dest) {
System.out.println(o);
}
}
若源数组src的元素为目标数组dest的元素的子类时，是可以复制的，特殊地，如int不是Object的子类（或者说，不存在继承的概念），所以，上述代码中，如果把int[] src = {1, 2, 3, 4};改为Integer[] src = {1, 2, 3, 4};，是不会报错的。
public static void main(String[] args) {
Integer[] src = { 1, 2, 3, 4 };
Object[] dest = new Object[3];
System.arraycopy(src, 0, dest, 0, 3);
for (Object o : dest) {
System.out.println(o);
}
}
输出结果：
1
2
3
或
public static void main(String[] args) {
Object[] src = { 1, 2, 3, 4 };
Integer[] dest = new Integer[3];
System.arraycopy(src, 0, dest, 0, 3);
for (Object o : dest) {
System.out.println(o);
}
}
输出结果：
1
2
3
总结：
抛java.lang.ArrayStoreException异常（由于类型不匹配， src阵列中的元素无法存储到 dest阵列中），常见的就是：
src参数引用的对象不是数组。
dest参数引用的对象不是数组。
src参数和dest参数引用其组件类型为不同基元类型的数组。
src参数引用具有基本组件类型的数组，而dest参数引用具有引用组件类型的数组。
src参数引用具有引用组件类型的数组，而dest参数引用具有基本组件类型的数组。
抛java.lang.ArrayIndexOutOfBoundsException异常（如果复制会导致访问数组边界外的数据），常见的就是：
srcPos论点是否定的。
destPos参数为负数。
length参数为负数。
srcPos+length大于src.length ，源数组的长度。
destPos+length大于dest.length ，目标数组的长度。
抛java.lang.NullPointerException异常，常见的就是：
src或 dest 是 null 。
案例分析：
public static void main(String[] args) {
// 利用函数的方法进行数组的扩充
// 定义一个小型的数组
int[] a = { 1, 2, 3, 4, 5 };
// 调用扩容函数
a= expand2(a);
// 测试是否扩容完成，输出此时数组a中的值
for (int i = 0; i < a.length; i++) {
System.out.println("数组元素:" + a[i]);
}
}
// 数组扩容方法2，利用系统函数arraycopy进行扩容
public static int[] expand2(int a[]) {
int[] b = new int[a.length * 2];
// 系统函数进行扩容，将a[]的值赋值到b[]中，共a.length个长度。
System.arraycopy(a, 0, b, 0, a.length);
System.out.println("数组扩容方法2:" + Arrays.toString(b));
return b;
}
输出结果：
数组扩容方法2:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
数组元素:1
数组元素:2
数组元素:3
数组元素:4
数组元素:5
数组元素:0
数组元素:0
数组元素:0
数组元素:0
数组元素:0
3.使用java.util.Arrays.copyOf()
方法解析：
Arrays.copyof是用于数组进行复制时常使用的方法，本身在Arrays类里面，而之所以能这么使用而不用创建对象在于该方法本身由static修饰，被static修饰的方法可以在该类创建对象前载入jvm。
Arrays.copyof有众多的重载方法，以最典型的Arrays.copyOf(srcArray, length);为例进行分析，源码如下：
public static long[] copyOf(long[] original, int newLength) {
long[] copy = new long[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
通过上面的代码可以看出，其本质是调用了System.arraycopy方法。
1.先产生一个新的数组
2.调用arraycopy方法
3.返回产生的新数组
参数解释：
original 源数组
newLength 新扩容长度
注意事项：
当我们将原来的数组进行扩容的时候，调用该方法产生了一个新的数组，而将扩容后的数组赋值给原来的数组的时候，原数组指向新产生的数组，但其原数组的内容依然在内存中，等待jvm回收，在这段时间中其实是造成了内存的浪费，所以使用该方法尽管简便，实际上有一定的不足。
案例分析：
public static void main(String[] args) {
// 利用函数的方法进行数组的扩充
// 定义一个小型的数组
int[] a = { 1, 2, 3, 4, 5 };
// 调用扩容函数
a= expand3(a);
// 测试是否扩容完成，输出此时数组a中的值
for (int i = 0; i < a.length; i++) {
System.out.println("数组元素:" + a[i]);
}
}
// 数组扩容方法3，利用系统函数copyOf进行扩容
public static int[] expand3(int a[]) {
int[] b = java.util.Arrays.copyOf(a, a.length * 2);
System.out.println("数组扩容方法3:" + Arrays.toString(b));
return b;
}
输出结果：
数组扩容方法3:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
数组元素:1
数组元素:2
数组元素:3
数组元素:4
数组元素:5
数组元素:0
数组元素:0
数组元素:0
数组元素:0
数组元素:0
| Java数组扩容的原理： |
Java数组对象的大小是固定不变的，数组对象是不可扩容的。
利用数组复制方法可以变通的实现数组扩容。
System.arraycopy()可以复制数组。
Arrays.copyOf()可以简便的创建数组副本。
创建数组副本的同时将数组长度增加就变相的实现了数组的扩容。
总结：
只有数组为一维数组，并且元素为基本类型或String类型时，才是深拷贝，其它都属于浅拷贝。
拷贝的两层含义，对应了浅拷贝和深拷贝的概念，做了第一层，就是浅拷贝，做到第二层，就是深拷贝。
浅拷贝：将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用。
深拷贝：创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”。
很容易可以想到，浅拷贝比深拷贝要更快，但是，从拷贝的意义上来看，浅拷贝相较于深拷贝，要欠缺一点，即一个是效率问题，一个是内存占用问题。
来源：https://blog.csdn.net/weixin_44563573/article/details/127321446
0
投稿猜你喜欢
- Java原生API并不支持为应用程序设置全局热键。要实现全局热键，需要用JNI方式实现，这就涉及到编写C/C++代码，这对于大多数不熟悉C/
什么是抽象类什么是抽象类呢？抽象类顾名思义就是很抽象，就是当我们没有足够的信息去描述这个类的时候我们就可以先不用描述，这样的类就是抽象类。用- 本文实例讲述了Spring实战之属性覆盖占位符配置器用法。分享给大家供大家参考，具体如下：一 配置文件<?xml version=&q
- 前言每次update Maven Project 的时候，看着进度条寸步难行，心里憋得十分难受，明显阻碍我学习的热情。 maven仓库默认在
- 第一篇是纯利用现有JDK提供的绘图类(ImageIO)类制作,这个过程比较复杂且需要了解ImageIO类。这一篇文章是利用Hutool工具类
- 我们通过一个完整的实例来实现课程信息管理功能的操作，包括查询、修改、删除课程信息的操作。为了简化实例，添加课程信息的操作直接在 SQL Se
- session简介做过Web开发的程序员应该对Session都比较熟悉，Session是一块保存在服务器端的内存空间，一般用于保存用户的会话
- 本文实例为大家分享了java实现文件上传下载的具体代码，供大家参考，具体内容如下一.上传1.前端：<form method="
- 前景概要在这个之前service_edu子模块下的功能是没有任何问题，创建了service_oss子模块之前失败了很多次，影响到了之前原本正
- 接口的灵活性就在于“规定一个类必须做什么，而不管你如何做”。我们可以定义一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时
- 1、private实现封装处理如果像想要知道封装，首先必须清楚如果没有封装会怎么样？没有封装方法中的属性，在所有方法被调用后都可以进行无权限
- <％@ page language="java" contentType="text/html; cha
- java parseInt()
- 概述事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。Spring Framework对事务管理提供了一致的
- Springcloud Config什么是springcloud Config  简单来说，Spring
- 一、项目简述功能包括(管理员和学生角色)： 管理员和学生登录，图书管理，图书添加删除修改，图书 借阅，图书归还，图书查看，学生管理，借还管理
- 一、使用@Profile1.1、@Profile修饰类开发环境package com.example.demo.config;import
- C#抓图服务首先抽象出抓图接口，然后对接口做基于公共操作的抽象类封装，之后针对不同的抓图方式做差异化处理，最后根据接口实现抓图服务。注意：W
- 本文实例讲述了Java泛型定义与用法。分享给大家供大家参考，具体如下：1. 泛型的由来先看如下代码：import java.util.Lis
- maven打包方式使用maven打包插件maven-jar-plugin在pom.xml文件最后新增以下代码。maven-dependenc
