为什么Java中的这个函数没有'；不影响结果吗？ 类测试{ 公共静态void main（字符串[]args）{ int[]list={1,2,3,4,5}； 反向（列表）； for（int i=0；i

当我运行这个程序时，答案是12345。在第4行调用此“反向”方法

class Test {
    public static void main(String[] args) {
        int[] list = {1, 2, 3, 4, 5};
        reverse(list);
        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
   }

   public static void reverse(int[] list) {
       int[] newList = new int[list.length];

       for (int i = 0; i < list.length; i++) {
           newList[i] = list[list.length - 1 - i];
       }

       list = newList;
   }
}

您刚刚更改了本地参数以引用新的数组实例

这不会影响调用方的变量，该变量仍然引用您传递的原始数组实例

您刚刚更改了本地参数以引用新的数组实例

---

这不会影响调用方的变量，该变量仍然引用您传递的原始数组实例。

这是因为您正在按值传递

list

。i、 e.

list=newList

行对调用者没有影响。在Java中，一切都是按值传递的

若要执行所需操作，请将函数更改为

list = newList;

在你的活动结束时

public static int[] reverse(int[] list)

而不是

return newList;

---

更正式地说，数组的引用是通过值传递的。当您重新指定list=newList时，您将引用点设置为不同的数组。但是调用方中的引用没有改变，因此指向原始数组。

这是因为您正在按值传递

列表。i、 e.
list=newList
行对调用者没有影响。在Java中，一切都是按值传递的

若要执行所需操作，请将函数更改为

list = newList;

在你的活动结束时

public static int[] reverse(int[] list)

而不是

return newList;

更正式地说，数组的引用是通过值传递的。当您重新指定list=newList时，您将引用点设置为不同的数组。但是调用方中的引用是不变的，因此指向原始数组。
您必须
返回新列表，而不是修改参数引用，因为它是唯一的方法范围

list = newList;

类测试{
公共静态void main（字符串[]args）{
int[]list={1,2,3,4,5}；
列表=反向（列表）；
for（int i=0；i
您必须
返回新列表，而不是修改参数引用，因为它是唯一的方法范围

list = newList;

类测试{
公共静态void main（字符串[]args）{
int[]list={1,2,3,4,5}；
列表=反向（列表）；
for（int i=0；i
问题在于Java参数传递是按值传递的。
reverse
的最后一句话是：

class Test {
    public static void main(String[] args) {
        int[] list = {1, 2, 3, 4, 5};
        list = reverse(list);
        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
   }

   public static int[] reverse(int[] list) {
       int[] newList = new int[list.length];

       for (int i = 0; i < list.length; i++) {
           newList[i] = list[list.length - 1 - i];
       }

       return newList;
   }
}

不幸的是，由于
list
是一个参数（并通过值传递），因此此赋值不会影响
main
方法中
list
的值

要使
reverse
方法正常工作，请执行以下操作之一：


将其更改为返回反向列表（并将结果分配到
main
中的
list
），或
将其更改为从
newList
的相应单元格分配
list
的单元格

（顺便说一句，如果要就地更新
列表
，则可以不使用单独的
newList
数组进行更新。）


针对这一评论：

我正在读的那本书说数组是通过引用传递的，方法中数组发生的任何事情都会影响主方法中的原始数组。也许我把它理解错了

不是这本书错了，就是你误解了。（我猜想可能是后者）Java中的所有类型（即所有类型）都是按值传递的，并按值返回

稍微令人困惑的是，在引用类型的情况下，传递或返回的值是对象的引用。这就给误解术语留下了空间（或者一本书有点草率），但是

“通过引用传递”

。。。而且

“传递参考”

。。。意思不一样

（事后看来，Goeldin等人称java对象指针为引用”是新java程序员的一个困惑源。OTHO，如果C++和C++中的程序员与旧术语“指针”相衔接，就会出现一种不同的困惑。
问题在于Java参数传递是按值传递的。
reverse
的最后一句话是：

class Test {
    public static void main(String[] args) {
        int[] list = {1, 2, 3, 4, 5};
        list = reverse(list);
        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
   }

   public static int[] reverse(int[] list) {
       int[] newList = new int[list.length];

       for (int i = 0; i < list.length; i++) {
           newList[i] = list[list.length - 1 - i];
       }

       return newList;
   }
}

不幸的是，由于
list
是一个参数（并通过值传递），因此此赋值不会影响
main
方法中
list
的值

要使
reverse
方法正常工作，请执行以下操作之一：


将其更改为返回反向列表（并将结果分配到
main
中的
list
），或
将其更改为从
newList
的相应单元格分配
list
的单元格

（顺便说一句，如果要就地更新
列表
，则可以不使用单独的
newList
数组进行更新。）


针对这一评论：

我正在读的那本书