避免在Java中传递引用的方法

Question

This question is probably as old as the hills. Nevertheless, after reading lots of articles and forums I still don't see a good solution to my problem.

I have to transfer some Monte Carlo simulation programs from C++ to Java. The problem is that it heavily relies on passing variables by reference in functions, like:

void make_step(int &a, int &b, double &c) {
   a++;
   b += a;
   c *= 1.1;
}

There is no passing by reference in Java, as well as possible analogs, like multiple return values or nested functions. Solutions, which I have read on this site, usually involve encapsulation of primitive types into objects. Alternatively - break functions to single-return ones. However, in my case it results in too long and complicated code (few lines of C++ code grow to almost pages in Java). Also, since these algorithms are hard to debug, I want to avoid dramatical changes in code while porting.

What I do now is substituting of all primitive type variables with arrays of length 1 (which are objects and can be modified inside functions). But it doesn't look like very elegant solutions. Does anyone have better ideas?

Answer 1

If you want the parameters to be "in-out" variables, they have to be object references.

With Mutable Wrappers

You can use mutable wrappers but this will require you to slightly modify your existing code (the algorithm):

class Int {
    int v;
}

class MDouble {
    double v;
}

void make_step(Int a, Int b, MDouble c) {
    a.v++;
    b.v += a.v;
    c.v *= 1.1;
}

With Local Variable Copies

If you want to keep your original code, you can create local variable copies of the wrapped parameters, and you can use those without having to modify your code.

At the end of your method (before return ) copy back the local variables into the wrappers and you're done. A tip for this is to use a try-finally block so your local variables will get copied back into the wrappers no matter how or where your method returns:

void make_step(int[] aa, int[] bb, double[] cc) {
    int a = aa[0];
    int b = bb[0];
    double c = cc[0];

    try {
        // all your original code comes here
        a++;
        b += a;
        c *= 1.1;
    } finally {
        aa[0] = a;
        bb[0] = b;
        cc[0] = c;
    }
}

Answer 2

There are mutable Integer and Decimal classes out there you can use those to pass by reference. Check out Apache Commons libraries here

Answer 3

There are few options:

• Wrap all parameters in an object. The simple version indeed makes the program longer, but if you can wrap the entire algorithm in an object then those parameters become the object members.
• Use mutable integers (objects) - either Java's AtomicInteger which has get()/set() methods, or the commnos-lang version

Answer 4

从c ++到java编写相同的逻辑时更多关于.equals和比较器==> <用于比较使用成员变量和局部变量将更新的对象返回到被调用的方法以获取更改。

Answer 5

You can use "atomic references" to wrap your object in a reference.

There are atomicXXX classes for most basic types as well. These will work similarly to normal references aside from the overhead of creating them in the first place.

Arrays of length 1 are just as a solution, but if you dislike the syntax or appearance of them, this is the only other solution that I know of that can mimic the same behavior without a general refactor.