Java的拷贝 and Java值传递

Java的拷贝

提示：不是正文

java的拷贝分深拷贝和浅拷贝，深拷贝和浅拷贝的原理类似于java的值传递（java只有值传递）
java的深拷贝和浅拷贝属于基础，再并发场景下有着应用

---

提示：以下是本篇文章正文内容，案例仅供参考

一、拷贝

概念：拷贝其实就是复制。
在java中值类型的拷贝就是直接复制值。
引用类型的拷贝分深拷贝和浅拷贝。
我们用一个自定义的类来举例子：

public class student implements Cloneable{

    public String name = "zelei";

    student(String name)
    {
        this.name = name;
    }
    @Override
    protected student clone() throws CloneNotSupportedException {

        return new student("adfas");
    }
}

1.1：浅拷贝：

概念：Java中的浅拷贝就是拷贝引用类型的引用值，把引用值赋值给了拷贝变量，拷贝变量和原变量指向的内存空间一样。
示例代码：

 student zelei = new student("zelei");
     //浅拷贝
    student zeleiClone = zelei;
     if (zelei == zeleiClone)
    {
        System.out.println("两个student对象的引用值相等");
        System.out.println("zeleiClone.name = " + zeleiClone.name);
    }

1.2：深拷贝：

概念：深拷贝就是将需要拷贝的变量的内存空间复制一份，将复制的内存空间的引用给克隆变量
在java中对象需要实现Cloneable接口中的clone方法，自定义深拷贝。

 student zelei = new student("zelei");
 //深拷贝
 student zeleiClone1 = zelei.clone();
 if (zelei == zeleiClone1)
 {
        System.out.println("两个student对象的引用值相等");
        System.out.println("zeleiClone1.name = " + zeleiClone1.name);
 } else
 {
     System.out.println("两个student对象的引用值不相等");
     System.out.println("zeleiClone1.name = " + zeleiClone1.name);
 }

总结：

java引用类型默认浅拷贝
值类型默认是深拷贝
对象需要实现Cloneable接口中的clone方法，自定义深拷贝。

二、Java值传递

说明

以下内容摘自javaguide，本博客只进行了一点改动，原文链接：
javaguide

1.1:Java只有值传递

在Java中值类型的参数传递，传递的是值类型的值，引用类型的传递传递的是引用类型的值。

1.2：值类型传递

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;
    swap(num1, num2);
    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

结果：

a = 20
b = 10
num1 = 10
num2 = 20

解析：
值类型直接传递的就是自己的值，在方法中直接改变的就是这个值。

1.3:引用类型传递1

public class Person {
    private String name;
   // 省略构造函数、Getter&Setter方法
}

public static void main(String[] args) {
    Person xiaoZhang = new Person("小张");
    Person xiaoLi = new Person("小李");
    swap(xiaoZhang, xiaoLi);
    System.out.println("xiaoZhang:" + xiaoZhang.getName());
    System.out.println("xiaoLi:" + xiaoLi.getName());
}

public static void swap(Person person1, Person person2) {
    Person temp = person1;
    person1 = person2;
    person2 = temp;
    System.out.println("person1:" + person1.getName());
    System.out.println("person2:" + person2.getName());
}

结果：

person1:小李
person2:小张
xiaoZhang:小张
xiaoLi:小李

解析：
swap 方法的参数 person1 和 person2 只是拷贝的实参 xiaoZhang 和 xiaoLi 的地址（浅拷贝）。因此， person1 和 person2 的互换只是拷贝的两个地址的互换罢了，并不会影响到实参 xiaoZhang 和 xiaoLi 。

1.4:引用类型传递2

  public static void main(String[] args) {
      int[] arr = { 1, 2, 3, 4, 5 };
      System.out.println(arr[0]);
      change(arr);
      System.out.println(arr[0]);
  }

  public static void change(int[] array) {
      // 将数组的第一个元素变为0
      array[0] = 0;
  }

结果：

1
0

解析：
change 方法的参数拷贝的是 arr （实参）的地址，因此，它和 arr 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。

总结

java中值的传递，实际上就是拷贝。
值类型默认深拷贝所以可以影响实际参数。
引用类型默认浅拷贝，只是拷贝了一个引用值（指针），而不是实际的内存地址。

为什么 Java 不引入引用传递呢？

出于安全考虑，方法内部对值进行的操作，对于调用者都是未知的（把方法定义为接口，调用方不关心具体实现）。你也想象一下，如果拿着银行卡去取钱，取的是 100，扣的是 200，是不是很可怕。Java 之父 James Gosling 在设计之初就看到了 C、C++ 的许多弊端，所以才想着去设计一门新的语言 Java。在他设计 Java 的时候就遵循了简单易用的原则，摒弃了许多开发者一不留意就会造成问题的“特性”，语言本身的东西少了，开发者要学习的东西也少了。