Java之数组的拷贝

于 2018-04-13 03:38:00 发布
阅读量126 收藏
点赞数
分类专栏： Homework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39475906/article/details/79922539
版权

两个数的转化

class TestSwap{
    public int data;
}
public class TestDemo {

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

    public static void swap2(TestSwap a,TestSwap b) {
        int tmp = a.data;
        a.data = b.data;
        b.data = tmp;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println(a);
        System.out.println(b);
        System.out.println("===================");
        TestSwap t = new TestSwap();
        t.data = 10;
        TestSwap t2 = new TestSwap();
        t2.data = 20;
        swap2(t,t2);
        System.out.println(t.data);
        System.out.println(t2.data);
    }
}

这里写图片描述
由此可见：简单的swap方法是不能将两个数转换的
原因：
这里写图片描述

数组的遍历

        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] array2 = new int[]{1,2,3,4,5};
        int[] array3 = new int[10];

三个数组的存储方法：
这里写图片描述
数组输出的两种方法

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 main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {1,2,3,4,5,6,7,8,9};
        for(int j:array)
        {
            System.out.println(j);  
        }
    }

用数组输出Fibonacci前40项：

public class lll {
    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 Fibonacci(int[] array){
        array[0] = 1;
        array[1] = 1;
        for(int i=3;i<=array.length;i++)
        {
            array[i] = array[i-1]+array[i-2];
            System.out.println(array[i]);
        }
        System.out.println();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = new int[40];
        Fibonacci(array);
        show(array);
    }

}

数组的4种拷贝方式

（1）for循环拷贝

基本类型

public class TestDemo3 {
    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 main(String[] args) {
        // TODO Auto-generated method stub
        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);
    }

}

这里写图片描述
改变了array2的值，array的值并没有改变，我们称此拷贝为深拷贝；
这里写图片描述

引用类型

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

}
public class TestDemo3 {
    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];   
        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);
    }

这里写图片描述
这不仅改变了t2的值，t1的值也发生了改变；
这里写图片描述
若改变一个值，则t1以及t2的值都会改变，我们称此类拷贝为浅拷贝；

（2）clone

基本类型

public class TestDemo4 {

    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 main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {1,2,3,};
        int[] array2 = new int[array.length];
        System.out.println(array);
        System.out.println(array2);

        array2 = array.clone();
        show(array);
        System.out.println("===========");
        show(array2);

        array[0] = 100;
        System.out.println("=====改变后======");
        show(array);
        System.out.println("===========");
        show(array2);
    }

}

这里写图片描述
改变了array2的值，array的值并没有改变，我们称此拷贝为深拷贝；

引用类型：

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

public class TestDemo4 {

    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);
    }
}

这不仅改变了t2的值，t1的值也发生了改变；
这里写图片描述
若改变一个值，t1以及t2的值都会改变，我们称此类拷贝为浅拷贝；

（3）System.arraycopy

arraycopy(object src, int srcPos,
        object dest,int destPos,
        int length)

src:源数组
srcPos:源数组的开始位置 0 开始拷贝的位置
dest：拷贝到目标数组
destPos: 拷贝到目标数组的位置
length：源数组 拷贝多大

基本类型

public class TestDemo5 {

    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 main(String[] args) {
        // TODO Auto-generated method stub
        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);
        System.out.println("====改变后=====");
        array2[0] = 100;
        show(array);
        System.out.println("=========");
        show(array2);

    }

}

这里写图片描述
改变了array2的值，array的值并没有改变，我们称此拷贝为深拷贝；

引用类型

class TestArray3{
    private int val = 10;
    public int getVal(){           //得到val值
        return val;
    }
    public void setVal(int val){   //设置val值
        this.val = val;
    }
}
public class TestDemo5 {
    public static void show2(TestArray3[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i].getVal());
        }
        System.out.println();
    }
    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);
    }
}

这不仅改变了t2的值，t1的值也发生了改变；
这里写图片描述
若改变一个值，则t1以及t2的值都会改变，我们称此类拷贝为浅拷贝；

(4)Arrays.copyOf()

  • Arrays.copyOf();
  • Arrays：工具类 数组 包含许多方法
  • T[] original(原始数组 ),int newLength(新的数组长度)

基本类型

public class TestDemo6 {

    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 main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {1,2,3,4};
        int[] array2 = new int[array.length];
        array2 = Arrays.copyOf(array, array2.length);
        show(array);
        System.out.println("=========");
        show(array2);
        System.out.println("=====改变后哦====");

        array2[0] = 1000;
        show(array);
        show(array2);
    }
}

这里写图片描述
改变了array2的值，array的值并没有改变，我们称此拷贝为深拷贝；

引用类型

class TestArray4{
    private int val = 10;
    public int getVal(){           //得到val值
        return val;
    }
    public void setVal(int val){   //设置val值
        this.val = val;
    }
}
public class TestDemo6 {
    public static void show2(TestArray4[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i].getVal());
        }
        System.out.println();
    }

    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, t2.length);

        show2(t1);
        System.out.println("========");
        show2(t2);

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

这不仅改变了t2的值，t1的值也发生了改变；
这里写图片描述
若改变一个值，则t1以及t2的值都会改变，我们称此类拷贝为浅拷贝；

冒泡排序法

public class TestDemo7 {

    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 bubbleSort(int[] array){
        System.out.println(System.currentTimeMillis());
        int tmp = 0;
        for(int i=0;i<array.length-1;i++){
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
        System.out.println(System.currentTimeMillis());
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {12,43,2,1,54,76};
        bubbleSort(array);
        show(array);
    }

}
Java大佬
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值