Java对象中数组引用陷阱与防御性拷贝实践

理解Java中的引用传递机制

在java中，所有非基本类型（包括数组和对象）的变量都存储的是对其在堆内存中实际对象的引用。当一个对象（或数组）作为参数传递给方法或赋值给另一个变量时，实际上是这个引用本身被“按值传递”了。这意味着，新的变量或参数会获得原始引用的一个副本，而这两个引用副本都指向内存中的同一个对象。

考虑以下代码片段：

public class testArrays {

    private int array1[] ;

    public testArrays(int[] arr) {
       this.array1 = arr; // 这里是问题的根源
    }

    // 辅助方法，用于打印数组内容
    public String toString(String name, int arr[]) {
           String outStr = "[";
           for (int i=0; i<= arr.length-1; i++) {
           if(i < arr.length-1)
              outStr = outStr + arr[i] + ", ";
           else
              outStr = outStr + arr[i] + "]";
           }
           return name + " = " + outStr;
    }

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

        testArrays ta = new testArrays(arr1);

        System.out.println(ta.toString("arr1 Before ",arr1));
        System.out.println(ta.toString("ta.array1 Before ", ta.array1));

        ta.array1[2] = 333; // 修改 ta.array1

        System.out.println(ta.toString("arr1 After ",arr1));
        System.out.println(ta.toString("ta.array1 After ", ta.array1));
    }
}

运行上述代码，我们会得到如下输出：

arr1 Before  = [1, 2, 3, 4, 5, 6, 7]
ta.array1 Before  = [1, 2, 3, 4, 5, 6, 7]
arr1 After  = [1, 2, 333, 4, 5, 6, 7]
ta.array1 After  = [1, 2, 333, 4, 5, 6, 7]

可以看到，在执行 ta.array1[2] = 333; 语句后，不仅 ta.array1 的第三个元素被修改了，连 main 方法中声明的 arr1 数组的第三个元素也发生了变化。这与预期只修改 ta.array1 的行为不符。

问题分析：共享引用导致意外修改

出现这种现象的原因在于，当执行 testArrays ta = new testArrays(arr1); 这行代码时，arr1 数组的引用被传递给了 testArrays 类的构造器。在构造器内部，this.array1 = arr; 这条语句并没有创建一个新的数组对象，而是将 testArrays 实例的私有成员变量 array1 指向了 main 方法中 arr1 所指向的同一个数组对象。

立即学习“Java免费学习笔记（深入）”；

简而言之，main 方法中的 arr1 变量和 testArrays 对象内部的 array1 变量，都持有指向堆内存中同一个 int[] 数组对象的引用。因此，通过其中任何一个引用对数组内容进行修改，都会反映在另一个引用上，因为它们操作的是同一个底层数据结构。

解决方案：防御性拷贝

为了避免这种意外的副作用，我们应该在对象接收外部数组作为参数时，创建一个该数组的独立副本。这种技术被称为“防御性拷贝”（Defensive Copying）。通过创建副本，我们可以确保对象内部的数据与外部传入的数据是完全独立的，从而防止外部对内部数据的修改，或者内部对外部数据的修改。

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

44

查看详情

实现防御性拷贝有几种方式：

1. 在构造器外部创建副本并传递： 在创建 testArrays 对象之前，先对原始数组进行拷贝，然后将拷贝后的数组传递给构造器。

   import java.util.Arrays; // 导入Arrays工具类
   
   public class TestArrays { // 遵循Java命名规范，类名首字母大写
   
       private int array1[] ;
   
       public TestArrays(int[] arr) {
          this.array1 = arr;
       }
   
       // ... (toString 方法不变)
   
       public static void main(String[] args) {
           int arr1[] = {1, 2, 3, 4, 5, 6, 7};
   
           // 在传递给构造器之前创建副本
           testArrays ta = new testArrays(Arrays.copyOf(arr1, arr1.length));
   
           System.out.println(ta.toString("arr1 Before ",arr1));
           System.out.println(ta.toString("ta.array1 Before ", ta.array1));
   
           ta.array1[2] = 333;
   
           System.out.println(ta.toString("arr1 After ",arr1));
           System.out.println(ta.toString("ta.array1 After ", ta.array1));
       }
   }

   登录后复制

2. 在构造器内部创建副本： 这通常是更推荐的做法，因为它将防御性拷贝的逻辑封装在类的内部，使得类的使用者无需关心拷贝细节。

   import java.util.Arrays;
   
   public class TestArrays {
   
       private int array1[] ;
   
       public TestArrays(int[] arr) {
          // 在构造器内部创建传入数组的副本
          this.array1 = Arrays.copyOf(arr, arr.length);
       }
   
       // ... (toString 方法不变)
   
       public static void main(String[] args) {
           int arr1[] = {1, 2, 3, 4, 5, 6, 7};
   
           TestArrays ta = new TestArrays(arr1); // 直接传入 arr1
   
           System.out.println(ta.toString("arr1 Before ",arr1));
           System.out.println(ta.toString("ta.array1 Before ", ta.array1));
   
           ta.array1[2] = 333;
   
           System.out.println(ta.toString("arr1 After ",arr1));
           System.out.println(ta.toString("ta.array1 After ", ta.array1));
       }
   }

   登录后复制

无论采用哪种方式，关键是利用 Arrays.copyOf(originalArray, newLength) 方法创建一个新的数组对象，并将原始数组的内容复制到新数组中。这样，arr1 和 ta.array1 将分别指向内存中的两个独立的数组对象。

使用防御性拷贝后的输出将符合预期：

arr1 Before  = [1, 2, 3, 4, 5, 6, 7]
ta.array1 Before  = [1, 2, 3, 4, 5, 6, 7]
arr1 After  = [1, 2, 3, 4, 5, 6, 7]       // arr1 未被修改
ta.array1 After  = [1, 2, 333, 4, 5, 6, 7] // ta.array1 被修改

注意事项与最佳实践

• 何时进行防御性拷贝：

  • 构造器中： 当对象接收外部数组或可变对象作为参数时，应在构造器内部进行拷贝，以防止外部修改影响对象内部状态。
  • Getter方法中： 如果类的某个Getter方法返回一个内部数组或可变对象的引用，也应该返回一个副本，以防止外部通过Getter返回的引用直接修改对象的内部状态。
  • Setter方法中： 类似于构造器，如果Setter方法接受一个数组或可变对象作为参数，也应进行拷贝。

• 浅拷贝与深拷贝：

  • Arrays.copyOf() 执行的是浅拷贝。对于基本类型数组（如 int[], double[]），浅拷贝足以创建完全独立的副本。
  • 但如果数组中存储的是对象引用（例如 Object[] 或 String[]），Arrays.copyOf() 只会复制这些引用本身，而不会复制引用指向的对象。这意味着新旧数组中的元素仍然指向内存中的同一个对象。如果需要复制这些引用指向的对象，则需要实现深拷贝，这通常涉及到遍历数组并对每个元素进行递归拷贝（例如，如果元素是 Cloneable 的，可以调用其 clone() 方法；或者手动创建新对象）。

• 性能考量： 创建数组副本会带来额外的内存开销和CPU时间。对于非常大或频繁操作的数组，这可能成为性能瓶颈。在这些情况下，需要权衡数据独立性和性能需求。如果确定不会发生意外修改，或者有其他机制来保证数据完整性，可以考虑不进行拷贝。

• Java命名规范： 遵循Java的命名约定是一个好习惯。类名应以大写字母开头（例如 TestArrays 而不是 testArrays）。这有助于提高代码的可读性和可维护性。

总结

理解Java中引用传递的机制是避免数组在对象中产生意外行为的关键。通过在构造器或Setter方法中实施防御性拷贝，我们可以有效地隔离对象内部状态与外部数据，从而确保程序的健壮性和可预测性。虽然防御性拷贝会带来一定的性能开销，但在大多数情况下，数据完整性和避免难以追踪的bug的价值远超这点开销。在设计类时，始终优先考虑如何保护其内部状态的独立性。

以上就是Java对象中数组引用陷阱与防御性拷贝实践的详细内容，更多请关注php中文网其它相关文章！