System.arraycopy()方法详解-jdk1.8

最新推荐文章于 2025-04-03 21:05:54 发布
最新推荐文章于 2025-04-03 21:05:54 发布
阅读量5.9k 收藏 32
点赞数 17
分类专栏： java源码分析 文章标签： system.arraycopy arrays.copy 数组扩容
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/balsamspear/article/details/85069207
版权
定义
public static native void arraycopy(Object src,  int srcPos, Object dest, int destPos, int length);

可以看到，它是一个静态本地方法，由虚拟机实现，效率自然比用java一个个复制高

方法含义

从源数组src取元素，范围为下标srcPos到srcPos+length-1，取出共length个元素，存放到目标数组中，存放位置为下标destPos到destPos+length-1

简单说，就是数组间的复制

应用

常用作数组的扩容，如ArrayList底层数组的扩容

参数
  1. Object src：the source array. 源数组
  2. int srcPos：starting position in the source array. 在源数组中，开始复制的位置
  3. Object dest：the destination array. 目标数组
  4. int destPos：starting position in the destination data. 在目标数组中，开始赋值的位置
  5. int length：the number of array elements to be copied. 被复制的数组元素的数量
过程详解

以下面这个例子进行分析

public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        int[] dest = new int[5];
        System.arraycopy(src, 0, dest, 1, 4);

        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
0 1 2 3 4
*/

src = |1|2|3|4|
dest = |0|0|0|0|0|
执行System.arraycopy(src, 0, dest, 1, 4);时
第一步：从源数组（src）中，从下标0开始取，取4个，也就是src[0]-src[3]，即1 2 3 4四个数
第二步：把取出的数，按顺序，存放到目标数组（dest）中，从下标1开始存，存4个，也就是dest[1]-dest[4]
所以数组dest为：|0|1|2|3|4|

再来一个例子

public class SystemArrayCopy {

    public static void main(String[] args) {
        String[] src = {"aa", "bb", "cc", "cc"};
        String[] dest = new String[]{"a", "b", "c", "d", "e"};
        System.arraycopy(src, 1, dest, 2, 2);

        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
a b bb cc e
*/

String[] src = |"aa"|"bb"|"cc"|"cc"|
String[] dest = |"a"|"b"|"c"|"d"|"e"|
执行 System.arraycopy(src, 1, dest, 2, 2);时
第一步：从源数组（src）中，从下标1开始取，取2个，也就是src[1]-src[2]，即"bb" "cc"两个字符串
第二步：把取出的数，按顺序，存放到目标数组（dest）中，从下标2开始存，存2个，也就是dest[2]-dest[3]
所以数组dest为：|"a"|"b"|"bb"|"cc"|"e"|

注意，目标数组下标范围外的元素不会改变！

深复制与浅复制
  1. 当数组为一维数组，且元素为基本类型或String类型时，属于深复制，即原数组与新数组的元素不会相互影响
  2. 当数组为多维数组，或一维数组中的元素为引用类型时，属于浅复制，原数组与新数组的元素引用指向同一个对象
  1. 这里说的影响，是两个数组复制后对应的元素，并不一定是下标对应
  2. String的特殊是因为它的不可变性
1. 一维数组，元素为基本类型
public class SystemArrayCopy {

    public static void main(String[] args) {
        String str1 = "aa";
        String str2 = "bb";
        String str3 = "cc";
        String str4 = "dd";

        String[] src = {str1, str2, str3, str4};
        String[] dest = new String[4];

        System.arraycopy(src, 0, dest, 0, 4);

        System.out.println("改变前");
        print("src = ", src);
        print("dest = ", dest);

        src[0] = "abcd";

        System.out.println("改变后");
        print("src = ", src);
        print("dest = ", dest);
    }

    private static void print(String string, String[] arr) {
        System.out.print(string);
        for (String str : arr) {
            System.out.print(str + " ");
        }
        System.out.println();
    }

}
/*
改变前
src = aa bb cc dd 
dest = aa bb cc dd 
改变后
src = abcd bb cc dd 
dest = aa bb cc dd 
*/

可以看到，源数组第0个元素改变，并不会影响到目标数组

2. 多维数组
public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] arr1 = {1, 2};
        int[] arr2 = {3, 4};
        int[] arr3 = {5, 6};
        int[] arr4 = {7, 8};

        int[][] src = new int[][]{arr1, arr2, arr3, arr4};
        int[][] dest = new int[4][];

        System.arraycopy(src, 0, dest, 0, 4);

        System.out.println("改变前");
        print("src = ", src);
        print("dest = ", dest);

        src[0][0] = 11111;

        System.out.println("改变后");
        print("src = ", src);
        print("dest = ", dest);
    }

    // 简单输出二维int数组的方法
    private static void print(String string, int[][] arr) {
        System.out.print(string);
        for (int[] a : arr) {
            for (int i : a) {
                System.out.print(i + " ");
            }
            System.out.print(",");
        }
        System.out.println();
    }
}
/*
改变前
src = 1 2 ,3 4 ,5 6 ,7 8 ,
dest = 1 2 ,3 4 ,5 6 ,7 8 ,
改变后
src = 11111 2 ,3 4 ,5 6 ,7 8 ,
dest = 11111 2 ,3 4 ,5 6 ,7 8 ,
*/

源数组改变后，目标数组也跟改变了，这就是浅复制

3. 一维数组，元素为引用类型
public class SystemArrayCopy {

    public static void main(String[] args) {
        People p1 = new People(11, "A");
        People p2 = new People(12, "B");
        People p3 = new People(13, "C");
        People p4 = new People(14, "D");

        People[] src = new People[]{p1, p2, p3, p4};
        People[] dest = new People[4];

        System.arraycopy(src, 0, dest, 0, 4);

        System.out.println("改变前");
        print("src = ", src);
        print("dest = ", dest);

        src[0].setAge(111);
        src[0].setName("AAA");

        System.out.println("改变后");
        print("src = ", src);
        print("dest = ", dest);
    }

    private static void print(String string, People[] arr) {
        System.out.print(string);
        for (People p : arr) {
            System.out.print(p + ", ");
        }
        System.out.println();
    }
}
public class People {
    private int age;
    private String name;

    // get set constructor toString
}
/*
改变前
src = People{age=11, name='A'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'}, 
dest = People{age=11, name='A'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'}, 
改变后
src = People{age=111, name='AAA'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'}, 
dest = People{age=111, name='AAA'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'}, 
*/

源数组改变后，目标数组也跟改变了，这就是浅复制

总结：只有数组为一维数组，并且元素为基本类型或String类型时，才是深复制，其它都属于浅复制

异常

ArrayIndexOutOfBoundsException ArrayStoreException NullPointerException

1. ArrayIndexOutOfBoundsException

当数组越界时，抛出异常：ArrayIndexOutOfBoundsException

  1. srcPos < 0 || destPos < 0 || length < 0
  2. src.length < length + srcPos
  3. dest.length < length + destPos

代码演示

// 1. srcPos < 0 || destPos < 0 || length < 0
public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        int[] dest = new int[5];
        System.arraycopy(src, -1, dest, 0, 0);
        
        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/

// 2. src.length < length + srcPos
public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        int[] dest = new int[5];
        System.arraycopy(arr, 1, dest, 0, 4);
        
        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/

// 3. dest.length < length + destPos
public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        int[] dest = new int[3];
        System.arraycopy(src, 0, dest, 0, 4);
        
        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
2. ArrayStoreException

当两数据的元素类型不匹配时，抛出异常：ArrayStoreException

src元素为dest元素的子类时，是可以复制的，特殊地，int不是Object的子类（或者说，不存在继承的概念），所以，下例中，把int[] src = {1, 2, 3, 4};改为Integer[] src = {1, 2, 3, 4};，是不会报错的

public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        Object[] dest = new Object[3];
        System.arraycopy(src, 0, dest, 0, 4);
        
        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.ArrayStoreException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/

public class SystemArrayCopy {

    public static void main(String[] args) {
        Object[] src = {1, 2, 3, 4};
        int[] dest = new int[3];
        System.arraycopy(src, 0, dest, 0, 4);

        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.ArrayStoreException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
3. NullPointerException

当两个数组，有一个为null时，抛出异常：NullPointerException

public class SystemArrayCopy {

    public static void main(String[] args) {
        int[] src = {1, 2, 3, 4};
        int[] dest = null;
        System.arraycopy(src, 0, dest, 0, 4);

        for (Object o : dest) {
            System.out.println(o);
        }
    }
}
/*
Exception in thread "main" java.lang.NullPointerException
	at java.lang.System.arraycopy(Native Method)
	at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
【Java集合 6】arraycopy方法的作用
学Java，找哪吒
01-26 1万+
一、前言 对数组的复制，有四种方法： for clone System.arraycopy arrays.copyof 下面分析一下最常用的System.arraycopy() 二、源码拜读 三、深拷贝与浅拷贝 1、简单类型（深拷贝） package com.guor.test.javaSE.collection; import java.util.Arrays; public class ArrayTest { public static void main(String[
关于java的System.arraycopy()方法
weixin_33834910的博客
06-06 618
java.lang.System的静态方法arraycopy()可以实现数组的复制，讲课的老师说这个方法效率比较高，如果数组有成千上万个元素，那么用这个方法，比用for语句循环快不少。于是我试了试，发现以下问题。 如果是复制一个一位数组，那么改变复制后的数组并不影响原数组。但是如果复制一个二维数组，那么改变其中任何一个数组，那么另一个的值也发生了变化。开始不是很明白...
关于System. arraycopy（）【java基础】
zk1984的专栏
11-30 3277
    现在向大家介绍一下System. arraycopy（）这个方法，为了阐述清晰明了，现暂时采用中文书写，敬请原谅！下面这段是JavaTM 2 PlatformStandard Ed. 5.0 给出的官方文档解释。public static void arraycopy(Object src,                                    
System.arraycopy()
最新发布
liu174的博客
04-03 1038
方法是 Java 提供的一个高效的数组复制工具，它可以快速地将一个数组的指定区域复制到另一个数组的指定位置。通过本文的介绍，你应该已经掌握了方法的基本语法、使用方法、性能优势以及一些注意事项。在实际应用中，可以灵活运用方法来提高数组复制的效率。
System.arraycopy()方法使用
liuqinhou的博客
10-11 4690
java 数组复制
使用System.arraycopy()实现数组之间的复制
Merin007
05-27 406
System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。其函数原型是： public static void arraycopy(Object src,                              int srcPos,                              Object dest,                    
JDK1.8 ArrayList详解
粉丝头子的故事
03-31 473
文章目录1.ArrayList构造函数2.ArrayList扩容3.ArrayList缩容4.ArrayList随机访问5.ArrayList索引检查6.ArrayList插入行为7.ArrayList删除操作8.ArrayList集合操作9.ArrayList迭代器操作 1.ArrayList构造函数 1.根据确定容量的初始化 public ArrayList(int initialCapacity) { if (initialCapacity > 0) {
JDK8源码详解-util篇-ArrayDeque(双端队列)，请详细解析相关概念和描述，联网解析，中文解析，源码详细解析每一步）：删除指定元素 delete(int i) 参数：i —— 要删除的元素的索引值 注意： 1. 本方法会改变结构导致元素移动 2. 队列已满且未扩容的情况下不能删除指定元素 3. 对于调用本方法的removeFirstOccurrence(Object o)和removeLastOccurrence(Object o)，本方法中返回的值并未使用，上述两个方法没有进行返回值的判断处理 4. 本方法的返回值不能作为是否删除成功的标识，其只标识移动的是头索引(返回false)还是尾索引(返回true) 备注： 1. 本详解中的正常顺序包括整个数组就是正常顺序和数组为循环数组但是指定下标与头索引/尾索引之间的关系是正常顺序两种情况 2. 本详解中的循环顺序仅表示指定下标与头索引/尾索引之间的关系是非正常(循环)顺序 // 源码 private boolean delete(int i) { // 数组校验，数组不能已满，结构必须合理 checkInvariants(); final Object[] elements = this.elements; // 数组最后一位元素下标(此处与头索引和尾索引无关) final int mask = elements.length - 1; final int h = head; final int t = tail; // 需移除的索引到达头索引的距离 final int front = (i - h) & mask; // 需移除的索引到达尾索引的距离 final int back = (t - i) & mask; // 此处计算了尾索引到头索引的距离，与指定索引到头索引的距离进行比较，以下两种情况会抛异常 // 情况1：不变性检测后，增加元素后队列满了这种情况(距离为0) // 情况2：不变性检测后，移除元素导致指定索引到头索引的距离小于尾索引到头索引的距离(指定元素可能已被删除) if (front >= ((t - h) & mask)) throw new ConcurrentModificationException(); // 判断索引元素距头索引远还是距尾索引远，选择元素较少的方向移动元素和头尾索引 // 距头索引较近，变更头索引，移除成功返回false if (front < back) { // 头索引小于等于指定索引(正常的数组顺序，从前往后) if (h <= i) { // 复制指定索引前面的元素全部后移一位(复制到后面) System.arraycopy(elements, h, elements, h + 1, front); } else { // 头索引大于指定索引(非正常的数组顺序，循环型数组循环部分) // 将索引[0~指定索引元素前]的元素后移一位(复制到后面) System.arraycopy(elements, 0, elements, 1, i); // 将数组最大索引值复制至索引0 elements[0] = elements[mask]; // 将头索引后的元素全部后移一位(正常顺序) System.arraycopy(elements, h, elements, h + 1, mask - h); } // 原头索引设置为null，此索引已不再是头索引了 elements[h] = null; // 重新计算头索引并赋值(原头索引后一位) head = (h + 1) & mask; return false; } else { // 距尾索引较近，变更尾索引，移除成功返回true // 指定索引小于尾索引(正常的数组顺序，从前到后) if (i < t) { // 直接将指定索引后尾索引之前的元素前移一位(复制到前面) System.arraycopy(elements, i +
04-03
好的，我现在要处理用户关于JDK8中ArrayDeque的delete方法实现细节的问题，特别是删除指定元素的行为和注意事项。用户还提到了removeFirstOccurrence和removeLastOccurrence方法，需要详细解析源码并说明行为。 ...
Java类库中的数组拷贝方法详解-基础教程
"这篇资源是关于Java基础知识的课件，特别是讲解了如何使用Java类库中的`System.arraycopy()`方法进行数组拷贝操作。此外，它还涵盖了Java学习的概述、重要知识点、学习方法以及Java软件工程师应掌握的技术体系。" ...
【Java加密原理详解】：bcprov-jdk15on-1.68中文版教程指南
[【Java加密原理详解】：bcprov-jdk15on-1.68中文版教程指南](https://img-blog.csdnimg.cn/a0d3a746b89946989686ff9e85ce33b7.png) # 摘要 Java加密技术是保障数据安全的重要工具，本文系统地概述了Java加密技术的...
Java System类详解_动力节点Java学院整理
08-30
Java的System类是Java开发工具集（JDK）提供的重要工具类，主要用于处理与系统相关的操作。由于它被声明为final，所以无法被其他类继承。System类的主要功能包括： 1. **标准输入输出**： - `System.in`：表示标准...
System.arraycopy
w8827130的博客
12-06 758
今天在学习ArrayList源码的时候发现有个System.arraycopy方法是用来进行数组复制的，于是想更加深入的学习下。 System.arraycopy是Native原生态方法，底层是由其它语言实现的，是效率最高的数组浅复制方法。 /**      * @param      src      原数组      * @param      srcPos   原数组开始位...
System.arraycopy()方法
qq_51366518的博客
06-04 845
这段代码的意思是将数组 newArr 中从索引 0 开始的 n 个元素复制到数组 nums 中，从索引 0 开始的位置开始覆盖。换句话说，它将 newArr 中的前 n 个元素复制到 nums 数组的开头位置，覆盖原有的元素。它的作用是将一个数组的某一部分（或整个数组）复制到另一个数组中的指定位置。具体来说，System.arraycopy() 方法的参数包括源数组、源数组的起始位置、目标数组、目标数组的起始位置以及要复制的元素个数。
System.arraycopy方法的使用
Xu
05-03 2653
import java.util.Arrays; /** * 老紫竹JAVA提高教程 - System.arraycopy方法的使用。 * * 从指定源数组中复制一个数组，复制从指定的位置开始， * 到目标数组的指定位置结束 * * @author 老紫竹的家(java2000.net,laozizhu.com)
System.arraycopy函数
xclsky的博客
01-30 1454
1 System有一个静态的函数用于基础数组的复制功能。System.arraycopy(源数组,源数组的起始下标,目的数组,目的数据的起始下标,复制的长度) 如：public void test1(){ int[] aaa=new int[]{1,2,3,4,5,6,7,8,89}; int[] bbb=new int[aaa.length];//不能为null System.array
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值