Suppose I have this in C++:
void test(int &i, int &j)
{
++i;
++j;
}
The values are altered inside the function and then used outside. How could I write a code that does the same in Java? I imagine I could return a class that encapsulates both values, but that seems really cumbersome.
One way you can have this behavior somehow simulated is create a generic wrapper.
public class _<E> {
E ref;
public _( E e ){
ref = e;
}
public E g() { return ref; }
public void s( E e ){ this.ref = e; }
public String toString() {
return ref.toString();
}
}
I'm not too convinced about the value of this code, by I couldn't help it, I had to code it :)
So here it is.
The sample usage:
public class Test {
public static void main ( String [] args ) {
_<Integer> iByRef = new _<Integer>( 1 );
addOne( iByRef );
System.out.println( iByRef ); // prints 2
_<String> sByRef = new _<String>( "Hola" );
reverse( sByRef );
System.out.println( sByRef ); // prints aloH
}
// Change the value of ref by adding 1
public static void addOne( _<Integer> ref ) {
int i = ref.g();
ref.s( ++i );
// or
//int i = ref.g();
//ref.s( i + 1 );
}
// Reverse the vale of a string.
public static void reverse( _<String> otherRef ) {
String v = otherRef.g();
String reversed = new StringBuilder( v ).reverse().toString();
otherRef.s( reversed );
}
}
The amusing thing here, is the generic wrapper class name is "_" which is a valid class identifier. So a declaration reads:
For an integer:
_<Integer> iByRef = new _<Integer>( 1 );
For a String:
_<String> sByRef = new _<String>( "Hola" );
For any other class
_<Employee> employee = new _<Employee>( Employee.byId(123) );
The methods "s" and "g" stands for set and get :P
Java has no equivalent of C++ references. The only way to get this to work is to encapsulate the values in another class and swap the values within the class.
Here is a lengthy discussion on the issue: https://jonskeet.uk/java/passing.html
Well, there are a couple of workarounds. You mentioned one yourself. Another one would be:
public void test(int[] values) {
++values[0];
++values[1];
}
I would go with the custom object, though. It’s a much cleaner way. Also, try to re-arrange your problem so that a single method doesn’t need to return two values.
Java does not have pass-by-reference. You must encapsulate to achieve the desired functionality. Jon Skeet has a brief explanation why pass-by-reference was excluded from Java.
A better question: why are you creating methods with such side-effects?
Generally, this is a strong indication that you should extract the data into a separate class, with public accessors that describe why the operation is taking place.
Java passes parameters by value, and has no mechanism to allow pass-by-reference.
The easiest solution is to use org.apache.commons.lang.mutable.MutableInt class you don't need to write by yourself.
You have to box it (your way) somehow.
Integer is immutable. so useless. int is mutable but since java is pass by value then its unusable again in that case. See these pages for more explanations: Java is Pass-by-Value, Dammit! and int vs Integer
Apache commons lang has a MutableInt class. Or you could write it yourself.
In any case, it should not be that bad because it should not happen often. If it does, then you should definitively change the way you code in Java.
Are the two integers related? Like a pair of x/y coordinates? If so, I would put the integers in a new class and pass that class into the method.
class A{
public void test(Coord c)
{
c.x++;
c.y++;
}
private class Coord{
public int x, y;
}
}
If the two integers are not related, you might want to think about why you are passing them into the same method in the first place.
Though its a bad design pattern IMHO, Another possible solution is
static void test(AtomicInteger i, AtomicInteger j)
{
i.incrementAndGet();
j.incrementAndGet();
}
You could construct boxed objects, ie,
Integer iObj = new Integer(i);
Integer jObj = new Integer(j);
and write your routine as
public void test(Integer i, Integer j){
i = i.add(1);
j = j.add(1);
}
For any number of reasons, the designers of Java felt call-by-value was better; they purposefully didn't include a method for call by reference. (Strictly, they pass copies of references to the objects, with the special case for the primitive types that they are purely call by value. But the effect is the same.)
