Thread: Immutable Integers

Hello,

I am attemping to figure out how to increment an integer value from another method (without returning the new value). Does anyone know a way to do this?

Here is an obviously wrong solution that simply shows the sort of behavior I am trying to get:

public void method1() {
	int value = 0;
	for(int i=0;i<10;i++) {
		method2(value);
		System.out.println(value);
	}
}
 
public void method2(int value) {
	value++;
}

All primitive types in Java are pass by value. All arrays and objects are pass reference by copy. Thus the best you can get to truly passing by reference is to pass some non-primitive type.

The most "correct" method is to somehow encapsulate value into a meaningful object which can be passed to method2.

However, there is a semi-hack way to pass a single element array as a pointer-like value.

What are you trying to accomplish? Why can't you return a value and re-assign to the original variable?

I managed to solve the issue by placing the int in an array and passing the array of a single int. This is basically how I would change my basic example to work properly:

public void method1() {
	int[] value = new int[]{0};
	for(int i=0;i<10;i++) {
		method2(value);
		System.out.println(value[0]);
	}
}
 
public void method2(int[] value) {
	value[0]++;
}

A class variable was not an option, as the methods were static and the class is actually server-side, which would mean there could be an unknown number of sessions accessing the class at the same time. A static class variable would not be safe by any means in this situation (I didn't think all this detail would be very important for this question, so I didn't include it in the original question).

I couldn't return a value because the methods in the real program are already returning a different object. Basically, I had an array of Object As, each of which contained X number of Object Bs. I was looping through the Object As in one method, and then looping through the Object Bs in each Object A in another method and sending the Object Bs to a third method, where Object Cs were being created from each Object B. The Object Cs were being returned from that method and an array was being created out of them. The reason I needed a mutable integer was because each Object C had a reference number associated with it that needed to be incremented.
Since the reference counter was being incremented three methods deeper than where it was declared, I was having trouble figuring out how to keep track of its value.

This sounds like a crazy-ass system, and it is, but there is a rhyme and reason behind the way things are.

Remember that Java is ALWAYS pass-by-value. The value of the primitive is passed as the parameter. For objects the reference to that object is passed by value and not the object. The fact that Java uses references when dealing with objects confuses the matter as some people incorrectly think that means objects are passed-by-reference. This absolutely incorrect.