循环外数组更改（JAVA） 公共静态无效反向（int[]arr） { int[]a=arr； int索引=a.length-1； 对于（int i=0；i=0）{ arr[index]=a[i]； 索引--； } } }

因此，我试图反转给定数组中元素的顺序。我声明另一个与给定数组相同的临时数组“a”。然而，当通过循环来反转顺序或元素时，数组“a”不知何故也在改变。我不明白这怎么可能。在本例中，int[]arr为[14,2,19,3,15,22,18,7]，最终结果为[14,2,19,3,3,19,2,14]和[a]。非常感谢您的帮助，谢谢

另外，我是这个论坛的新手，所以如果我没有遵循正确的格式，我很抱歉

非常感谢大家的贡献！惊人和快速的反应

使用：

public static void reverse(int[] arr)
    {
        int[] a= arr;
        int index=a.length-1;
        for (int i=0; i<a.length; i++){
            System.out.println(ArrayUtil.toString(a));
            if (index>=0){
                arr[index]=a[i];
                index--;
            }
        }
    }

复制数组中的实际元素，而不是数组的引用。（复制引用意味着

a

和

arr

都将引用同一个对象，因此对

a

的任何更改也是对

arr

的更改。这适用于所有对象，而不仅仅是按值复制的原语）

使用：

public static void reverse(int[] arr)
    {
        int[] a= arr;
        int index=a.length-1;
        for (int i=0; i<a.length; i++){
            System.out.println(ArrayUtil.toString(a));
            if (index>=0){
                arr[index]=a[i];
                index--;
            }
        }
    }

复制数组中的实际元素，而不是数组的引用。（复制引用意味着

a

和

arr

都将引用同一个对象，因此对

a

的任何更改也是对

arr

的更改。这适用于所有对象，而不仅仅是按值复制的原语）

使用：

public static void reverse(int[] arr)
    {
        int[] a= arr;
        int index=a.length-1;
        for (int i=0; i<a.length; i++){
            System.out.println(ArrayUtil.toString(a));
            if (index>=0){
                arr[index]=a[i];
                index--;
            }
        }
    }

复制数组中的实际元素，而不是数组的引用。（复制引用意味着

a

和

arr

都将引用同一个对象，因此对

a

的任何更改也是对

arr

的更改。这适用于所有对象，而不仅仅是按值复制的原语）

使用：

public static void reverse(int[] arr)
    {
        int[] a= arr;
        int index=a.length-1;
        for (int i=0; i<a.length; i++){
            System.out.println(ArrayUtil.toString(a));
            if (index>=0){
                arr[index]=a[i];
                index--;
            }
        }
    }

---

复制数组中的实际元素，而不是数组的引用。（复制引用意味着

a

和

arr

都将引用同一个对象，因此对

a

的任何更改也是对

arr

的更改。这会发生在所有对象上，而不仅仅是按值复制的原语）

更改算法。即使您将修复代码以使其正常工作，也将使用额外的内存。更好地使用：

int[] a = new int[arr.length]
System.arraycopy( arr, 0, a, 0, arr.length);

for（int i=0；i

更改此的算法。即使您将修复代码以使其正常工作，也将使用额外的内存。更好地使用：

int[] a = new int[arr.length]
System.arraycopy( arr, 0, a, 0, arr.length);

for（int i=0；i

更改此的算法。即使您将修复代码以使其正常工作，也将使用额外的内存。更好地使用：

int[] a = new int[arr.length]
System.arraycopy( arr, 0, a, 0, arr.length);

for（int i=0；i

更改此的算法。即使您将修复代码以使其正常工作，也将使用额外的内存。更好地使用：

int[] a = new int[arr.length]
System.arraycopy( arr, 0, a, 0, arr.length);

for（int i=0；i
对
arr
的任何修改都将更改
a
，反之亦然，因为它们是对同一数组的引用。如果需要两个独立的阵列，则需要完全复制阵列：

for (int i = 0; i < a.length / 2; i++){
            int tmp = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = tmp;
        }

对
arr
的任何修改都将更改
a
，反之亦然，因为它们是对同一数组的引用。如果需要两个独立的阵列，则需要完全复制阵列：

for (int i = 0; i < a.length / 2; i++){
            int tmp = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = tmp;
        }

对
arr
的任何修改都将更改
a
，反之亦然，因为它们是对同一数组的引用。如果需要两个独立的阵列，则需要完全复制阵列：

for (int i = 0; i < a.length / 2; i++){
            int tmp = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = tmp;
        }

对
arr
的任何修改都将更改
a
，反之亦然，因为它们是对同一数组的引用。如果需要两个独立的阵列，则需要完全复制阵列：

for (int i = 0; i < a.length / 2; i++){
            int tmp = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = tmp;
        }

实际上

int[] a = new int[arr.length];
System.arraycopy(arr, 0, a, 0, a.length);

相同数组的引用被赋予数组a。
当您将值反向分配给arr时，这些值实际上是从
按相反的顺序。所以在最后，你得到了对称的数组

int[] a = new int[arr.length];
System.arraycopy(arr, 0, a, 0, a.length);

相同数组的引用被赋予数组a。
当您将值反向分配给arr时，这些值实际上是从
按相反的顺序。所以在最后，你得到了对称的数组

int[] a = new int[arr.length];
System.arraycopy(arr, 0, a, 0, a.length);

相同数组的引用被赋予数组a。
当您将值反向分配给arr时，这些值实际上是从
按相反的顺序。所以在最后，你得到了对称的数组

int[] a = new int[arr.length];
System.arraycopy(arr, 0, a, 0, a.length);

相同数组的引用被赋予数组a。
当您将值反向分配给arr时，这些值实际上是从
按相反的顺序。因此，在最后你得到了对称的数组，不知何故数组“a”也被改变了是吗？它是同一个数组。您在声明
a
时将其设置为。如果您想要相同长度的新数组，请执行
new int[arr.length]
。这称为指针别名，（），因为
a
和
arr
都指向相同的内存位置。当一个改变时，另一个也会改变。“不知何故，数组“a”也在改变。”你怎么看
int[]a=arr是吗？它是同一个数组。您在声明
a
时将其设置为。如果你想