如何在 Java 中对原语执行相当于引用传递的操作

Question

此 Java 代码：

public class XYZ {   
    public static void main(){  
        int toyNumber = 5;   
        XYZ temp = new XYZ();  
        temp.play(toyNumber);  
        System.out.println("Toy number in main " + toyNumber);  
    }

    void play(int toyNumber){  
        System.out.println("Toy number in play " + toyNumber);   
        toyNumber++;  
        System.out.println("Toy number in play after increement " + toyNumber);   
    }   
}  

将输出以下内容：

 
Toy number in play 5  
Toy number in play after increement 6  
Toy number in main 5  

在 C++ 中，我可以将 toyNumber 变量作为引用传递来传递，以避免隐藏，即创建相同变量的副本，如下所示：

void main(){  
    int toyNumber = 5;  
    play(toyNumber);  
    cout << "Toy number in main " << toyNumber << endl;  
}

void play(int &toyNumber){  
    cout << "Toy number in play " << toyNumber << endl;   
    toyNumber++;  
    cout << "Toy number in play after increement " << toyNumber << endl;   
} 

并且 C++ 输出将是这样的：

Toy number in play 5  
Toy number in play after increement 6  
Toy number in main 6  

My问题是 - Java 中获得与 C++ 代码相同的输出的等效代码是什么，考虑到 Java是按值传递而不是通过引用传递？

Answer 1

你有几种选择。最有意义的实际上取决于您想要做什么。

选择 1：使 toyNumber 成为类中的公共成员变量

class MyToy {
  public int toyNumber;
}

，然后将对 MyToy 的引用传递给您的方法。

void play(MyToy toy){  
    System.out.println("Toy number in play " + toy.toyNumber);   
    toy.toyNumber++;  
    System.out.println("Toy number in play after increement " + toy.toyNumber);   
}

选择 2：返回值而不是通过引用传递

int play(int toyNumber){  
    System.out.println("Toy number in play " + toyNumber);   
    toyNumber++;  
    System.out.println("Toy number in play after increement " + toyNumber);   
    return toyNumber
}

此选择需要对 main 中的调用点进行一些小更改，以便其读取：toyNumber = temp.play(toyNumber);。

选择3：将其设为类或静态变量

如果这两个函数是同一类或类实例上的方法，则可以将 toyNumber 转换为类成员变量。

选择 4：创建 int 类型的单元素数组并传递该数组

这被认为是一种 hack，但有时用于从内联类调用返回值。

void play(int [] toyNumber){  
    System.out.println("Toy number in play " + toyNumber[0]);   
    toyNumber[0]++;  
    System.out.println("Toy number in play after increement " + toyNumber[0]);   
}

Answer 2

Java 不是按引用调用，而是仅按值调用，

但所有对象类型的变量实际上都是指针。

因此，如果您使用可变对象，您将看到您想要的行为

public class XYZ {

    public static void main(String[] arg) {
        StringBuilder toyNumber = new StringBuilder("5");
        play(toyNumber);
        System.out.println("Toy number in main " + toyNumber);
    }

    private static void play(StringBuilder toyNumber) {
        System.out.println("Toy number in play " + toyNumber);
        toyNumber.append(" + 1");
        System.out.println("Toy number in play after increement " + toyNumber);
    }
}

代码输出：

run:
Toy number in play 5
Toy number in play after increement 5 + 1
Toy number in main 5 + 1
BUILD SUCCESSFUL (total time: 0 seconds)

您也可以在标准库中看到此行为。
例如 Collections.sort(); Collections.shuffle();
这些方法不会返回新列表，而是修改其参数对象。

    List<Integer> mutableList = new ArrayList<Integer>();

    mutableList.add(1);
    mutableList.add(2);
    mutableList.add(3);
    mutableList.add(4);
    mutableList.add(5);

    System.out.println(mutableList);

    Collections.shuffle(mutableList);

    System.out.println(mutableList);

    Collections.sort(mutableList);

    System.out.println(mutableList);

该代码的输出：

run:
[1, 2, 3, 4, 5]
[3, 4, 1, 5, 2]
[1, 2, 3, 4, 5]
BUILD SUCCESSFUL (total time: 0 seconds)

Answer 3

创建 a

class PassMeByRef { public int theValue; }

然后传递对其实例的引用。请注意，最好避免使用通过其参数改变状态的方法，尤其是在并行代码中。

Answer 4

为了快速解决方案，您可以使用 AtomicInteger 或任何原子变量，这将允许您使用内置方法更改方法内的值。这是示例代码：

import java.util.concurrent.atomic.AtomicInteger;


public class PrimitivePassByReferenceSample {

    /**
     * @param args
     */
    public static void main(String[] args) {

        AtomicInteger myNumber = new AtomicInteger(0);
        System.out.println("MyNumber before method Call:" + myNumber.get());
        PrimitivePassByReferenceSample temp = new PrimitivePassByReferenceSample() ;
        temp.changeMyNumber(myNumber);
        System.out.println("MyNumber After method Call:" + myNumber.get());


    }

     void changeMyNumber(AtomicInteger myNumber) {
        myNumber.getAndSet(100);

    }

}

输出：

MyNumber before method Call:0

MyNumber After method Call:100

Answer 5

在 Java 中不能通过引用传递基元。当然，所有对象类型的变量实际上都是指针，但我们称它们为“引用”，并且它们也总是按值传递。

在确实需要通过引用传递基元的情况下，人们有时会做的是将参数声明为基元类型的数组，然后传递单元素数组作为参数。因此，您传递一个引用 int[1]，并且在该方法中，您可以更改数组的内容。

Answer 6

public static void main(String[] args) {
    int[] toyNumber = new int[] {5};
    NewClass temp = new NewClass();
    temp.play(toyNumber);
    System.out.println("Toy number in main " + toyNumber[0]);
}

void play(int[] toyNumber){
    System.out.println("Toy number in play " + toyNumber[0]);
    toyNumber[0]++;
    System.out.println("Toy number in play after increement " + toyNumber[0]);
}

Answer 7

“Pass-by...”在Java 和C 中保留。除此之外，如果您打算更改作为引用给出的原语的包装器实例，则可以通过反射来完成。 整数示例。

public class WrapperTest
{
    static void mute(Integer a)
    {
        try
        {
            Field fValue = a.getClass().getDeclaredField("value");
            fValue.setAccessible(true);
            fValue.set(a, 6);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void main(String[] args)
    {
        Integer z = 5;
        mute(z);
        System.out.println(z);
    }

}

输出为 6，如 C++ 示例中所示。反射是必需的，因为 Java 设计认为原始包装器是不可变的。否则，每个其他类都可以充当包装器，甚至是像 int[] 这样长度为 1 的数组。

Answer 8

我们在 checkPassByValue 中设置 a = 5，但它没有反映在 a 的值中。
类似地，当我们传递一个人时，我们可以使用 Person.setName 更新该人指向的数据，但是如果更改该人并使其引用一个新的 Person() 在这种情况下，更新将不会反映在主函数中

class Person {
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;

    public Person(String name) {
        this.name = name;
    }

}

public class PassByValueVsReference {
    public static void main(String[] args) {
        int a = 3;
        Person person = new Person("Foo");
        checkPassByValue(a, person);
        System.out.println(a);
        System.out.println(person.getName());
    }

    public static void checkPassByValue(int number, Person person) {
        number = 5;
        person.setName("Foo-updated");
        person = new Person("Foo_new reference");
    }
}

//C++ equivalent of checkPassByValue(int ,Person *);