Java数组的拷贝方式，浅拷贝深拷贝

最新推荐文章于 2024-05-13 14:18:42 发布

Mars1997

最新推荐文章于 2024-05-13 14:18:42 发布

阅读量2.7k

点赞数

分类专栏： Java学习

本文链接：https://blog.csdn.net/Mars1997/article/details/79922386

版权

Java学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一，关于交换两个数字

1.简单交换

public static void swap(int a,int b) {
		int tmp=a;
		a = b;
		b = tmp;
	}

运行结果如下：
这里写图片描述
可知，此方法并不可行，因为形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
2.引用交换

	public static void swap2(TestSwap a,TestSwap b) {
		int tmp = a.date;
		a.data = b.data;
		b.data = tmp;
	}

运行结果如下：
这里写图片描述
可知，此方法可行，因为形参为引用值，引用的是存放数据的地址，而在交换方法里，真正交换的是值。

二，数组

数组是用一个标识符（变量名）和一组下标来代表一组具有相同数据类型的数据元素的集合。这些数据元素在计算机存储器中占用一片连续的存储空间，其中的每个数组元素在数组中的位置是固定的，可以通过下标的编号加以区分，并通过标识符和下标访问每一个数据元素。
数组提供了在计算机存储器中快速且简便的数据存取方式，数组的应用可以大大提高对数据操作的灵活性。
在Java中，数组被定义为一个对象，属于引用类型。
数组的三种定义方法：

 1.数组类型[] 数组名=new 数组类型[数组长度];   
 2.数组类型[] 数组名={数组0,数组1,数组2,数组3,....};   
 3.数组类型[] 数组名=new 数组类型[]{数组0,数组1,数组2,...};

例如：

int[] array = new int[10];//数组每个元素被初始化为0
int[] array2 = {1,2,3,4,5,6,7,8,9};
int[] array3 = new int[]{1,2,3,4,5};

数组的遍历

	public static void show(int[] array){
		for(int i=0;i<array.length;i++)
		{
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}

这里写图片描述
foreach循环的语句
格式：

for(数据类型 变量名:对象)
{
//循环体为引用了变量的Java语句
}

例如：数组的遍历

for(int j:array)
		{
		System.out.println(j);	
		}

注：
1.其中变量名可以是任意的但是数据类型必须与遍历对象的数据类型相同。
2.对象为一个容器，例如数组或是集合等
3.无法再循环中改变对象中的值，即任何在循环体中改变对象中的值都是无效的，对象中的值不会被改变。这也是foreach循环较for循环的重要区别，foreach实现对象的遍历代码更加简洁，for循环可以改变对象中的值。

        int []c={1,2,3,4,5};  
        for(int i:c)  
        {  
            if(i==3||i==5)  
                i=i*5;  
        }  
        for(int j:c)  
        {  
            System.out.println(j);  
        }

这里写图片描述
foreach循环无法改变对象中的值。
数组的4种拷贝方式
1.for循环拷贝
（1）对于基本类型来说，如果改变了array2的值，array的值并不改变，此拷贝为深拷贝。

	int [] array = {1,2,3,4,5};
    int [] array2 = new int[array.length];
    for (int i = 0; i < array2.length; i++) {
    array2[i] = array[i];
    }

（2）对于引用类型来说，如果改变t2的值，t1的值也会发生改变，他只拷贝了地址，此拷贝为浅拷贝。

class TestArray{
	private int val = 10;
	public int getVal(){           //得到val值
		return val;
	}
	public void setVal(int val){   //设置val值
		this.val = val;
	}

}

public class Test{
	public static void show(int[] array) {
		for(int i=0;i<array.length;i++)
		{
			System.out.println(array[i]+" ");
		}
		System.out.println();
	}
	
	public static void show2(TestArray[] array) {
		for(int i=0;i<array.length;i++)
		{
			System.out.println(array[i].getVal());
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		TestArray[] t1 = new TestArray[3];      //对于引用类型数组用for循环拷贝为浅拷贝
		t1[0] = new TestArray();
		t1[1] = new TestArray();
		t1[2] = new TestArray();
		
		TestArray[] t2 = new TestArray[3];
		for(int i=0;i<t1.length;i++)
		{	
			t2[i] = t1[i];
		}
		show2(t1);
		System.out.println("------");
		show2(t2);
		System.out.println("---改变后---");
		t2[0].setVal(1000);
		show2(t1);
		System.out.println("--------");
		show2(t2);
	}
	
	public static void main1(String[] args) {
		int[] array = {1,2,3,4,5};
		int[] array2 = new int[array.length];
		
		for(int i = 0;i<array.length;i++)
		{
			array2[i] = array[i];
		}
		
		show(array);
		System.out.println("---------");
		show(array2);
		array2[0]=100;
		System.out.println("----改变后-----");
		show(array);
		System.out.println("---------");
		show(array2);
	}

}

这里写图片描述

2.clone拷贝
（1）对于基本类型来说，如果改变了array2的值，array的值并不改变，此拷贝为深拷贝。

	public static void show(int[] array){
		for(int i = 0;i < array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5};
		int[] array2 = new int[array.length];
		System.out.println(array);
		System.out.println(array2);
		array2 = array.clone();
		show(array);
		System.out.println("========");
		show(array2);
		array2[0] = 1000;
		System.out.println("===改变后的值===");
		show(array);
		System.out.println("========");
		show(array2);
	}

这里写图片描述

（2）对于引用类型来说，如果改变t2的值，t1的值也会发生改变，他只拷贝了地址，此拷贝为浅拷贝。

public static void show2(TestArray2[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i].getVal());
        }
        System.out.println();
    }
    public static void main(String[] args) {
        TestArray2[] t1 = new TestArray2[3];   
        t1[0] = new TestArray2();
        t1[1] = new TestArray2();
        t1[2] = new TestArray2();

        TestArray2[] t2 = new TestArray2[3];
        t2 = t1.clone();
        show2(t1);
        System.out.println("========");
        show2(t2);

        t2[0].setVal(100);
        System.out.println("====改变后=====");
        show2(t1);
        System.out.println("=========");
        show2(t2);
    }

这里写图片描述
3.System.arraycopy
System.arraycopy 相对较快的拷贝方式 native 方法
System.arraycopy 的使用：
arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
src : 源数组
srcPos: 源数组开始拷贝的位置
dest：拷贝到的目标数组
destPos ：拷贝到目标数组的位置
length ：拷数组的长度

（1）对于基本类型来说，此拷贝为深拷贝。

	public static void show(int[] array){
		for(int i = 0;i < array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5};
		int[] array2 = new int[array.length];
		System.arraycopy(array, 0, array2, 0, array.length);
		show(array);
		System.out.println("========");
		show(array2);
		array2[0] = 1000;
		System.out.println("===改变后的值===");
		show(array);
		System.out.println("========");
		show(array2);
		
	}

这里写图片描述
（2）对于引用类型来说，此拷贝为浅拷贝。

class TestArray3{
	private int val = 10;
	
	public int getVal(){//得到val值等于多少
		return val;
	}
	public void setVal(int val){//设置当前的val值
		this.val = val;
	}
}
public class Test{
	public static void show2(TestArray3[] array){
		for(int i = 0;i < array.length;i++){
			
			System.out.println(array[i].getVal());
		}
	}
	
	public static void main(String[] args) {
		TestArray3[] t1 = new TestArray3[3];//引用类型
		t1[0] = new TestArray3();
		t1[1] = new TestArray3();
		t1[2] = new TestArray3();
		TestArray3[] t2 = new TestArray3[3];
		System.arraycopy(t1,0,t2,0,t1.length);
		show2(t1);
		System.out.println("========");
		show2(t2);
		t2[0].setVal(10000);
		System.out.println("====改变值=====");
		show2(t1);
		System.out.println("======");
		show2(t2);
	}
}

这里写图片描述
4.Arrays.copyOf()
Arrays.copyOf();//Arrays 工具类数组包含很多方法
T[] original, int newLength
原始数组新的数组长度
（1）对于基本类型来说，此拷贝为深拷贝。

import java.util.Arrays;
public class Test {
	public static void show(int[] array){
		for(int i = 0;i < array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5};
		int[] array2 = new int[array.length];
		array2 = Arrays.copyOf(array, array.length);
		show(array);
		System.out.println("========");
		show(array2);
		array2[0] = 1000;
		System.out.println("===改变后的值===");
		show(array);
		System.out.println("========");
		show(array2);
	}
}

这里写图片描述

（2）对于引用类型来说，此拷贝为浅拷贝。

import java.util.Arrays;
class TestArray4{
	private int val = 10;
	
	public int getVal(){//得到val值等于多少？
		return val;
	}
	public void setVal(int val){//设置当前的val值？？？
		this.val = val;
	}
}
public class Test {
public static void show2(TestArray4[] array){
		for(int i = 0;i < array.length;i++){
			
			System.out.println(array[i].getVal());
		}
	}
	public static void main(String[] args) {
		TestArray4[] t1 = new TestArray4[3];//引用类型
		t1[0] = new TestArray4();
		t1[1] = new TestArray4();
		t1[2] = new TestArray4();
		
		TestArray4[] t2 = new TestArray4[3];
		
		t2 = Arrays.copyOf(t1, t1.length);
		
		show2(t1);
		System.out.println("========");
		show2(t2);
		
		t2[0].setVal(10000);
		System.out.println("====改变值=====");
		show2(t1);
		System.out.println("======");
		show2(t2);
	}
}

这里写图片描述

Mars1997

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java数组的拷贝方式，浅拷贝深拷贝

一，关于交换两个数字1.简单交换public static void swap(int a,int b) { int tmp=a; a = b; b = tmp; }运行结果如下：可知，此方法并不可行，因为形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。形参只在函数内部有效。函数调用结束...
复制链接

扫一扫