why do some people make a new reference in method to a field variable?
public class Foo {
int mFoo[] = {1, 2, 3};
void method() {
int foo[] = mFoo; // WHY not just use mFoo?
print(foo[0]); // WHY not just use mFoo?
}
}
-
1Maybe they think its marginally faster (which it could be). Or maybe to avoid threading issues.Thilo– Thilo2012-06-27 15:07:56 +00:00Commented Jun 27, 2012 at 15:07
-
1@scrappedcola if I change 'foo[0]=5' the same will also reflect to mFoo.tomi– tomi2012-06-27 15:11:06 +00:00Commented Jun 27, 2012 at 15:11
-
@Thilo Threading issues? Can you elaborate how that helps?Eric B.– Eric B.2012-06-27 16:22:10 +00:00Commented Jun 27, 2012 at 16:22
-
@EricB. see the accepted answerThilo– Thilo2012-06-27 22:53:36 +00:00Commented Jun 27, 2012 at 22:53
Add a comment
|
6 Answers
It can be a good idea if for example, at another place of your code, you change the value of mFoo. Especially in a multithreaded context, you would want to ensure you're still working on the right data.
2 Comments
tomi
if I would change 'foo[0]=5' it will also reflect on mFoo. So could you elaborate why this would be different in multithreaded context?
Alexis Dufrenoy
Imagine you are in a multithreaded app. In one of your thread, you begin to iterate on your table. In another thread, you execute
mFoo=anotherTable; What happens next in your iterating thread?It used to be the case (and still is with Java ME AFAIK) that loading a field into a local variable and using it multiple times was faster than access a field multiple times.
However, today using a local variable this way can confuse the JIT compiler and using a local variable this way can be slower.
2 Comments
Louis Wasserman
Really? I can't imagine this slowing things down. (I have seen recent benchmarks demonstrating speedups with this technique even on Java 7 -server, but only tiny ones in extremely performance-critical code.)
Peter Lawrey
This was a claim by one of the JVM developers less than a month ago. I imagine it depends on the situation. I haven't seen it myself. ;)
It depends on your goal. If you want to modify whatever Object was passed in as a parameter you would not make a new instance of the type of the referenced Object.
Otherwise you would make a new instance which would you could modify freely without worrying about modifications to the passed in Object. This is commonly used in multi-threaded applications.
1 Comment
Thilo
Making new instances is not mentioned in the question, though.
There's an accepted answer already, but the use makes more sense in this context:
private Class<?> clazz = ...;
public void foo() {
Class<?> current = clazz;
while (current != Object.class) {
// do some stuff.
current = current.superclass();
}
}
In this example you are constantly re-assigning "current" to a new value. Imagine the side effect without the variable, and if you kept doing:
clazz = clazz.superclass();
You'd be changing the field in the object itself, not locally to your method, so repeated calls to "foo" would not exhibit the behavior you are expecting.
1 Comment
tomi
the accepted answer was the first one that clarified me the issue.
It just doesn't make sense if you use just like this:
int[] local = somethingElse;
... // changes to local will reflect on somethingElse
It would make sense if a real copy would be done like:
int[] local = Arrays.copyOf(somethingElse,somethingElse.lenght())
... // changes to local will not reflect on somethingElse
The copy can prevent changing the elements that you will need on your method invoking other methods or by other Threads interference. In case that you have for example a method that changes this elements invoked at the same time you are using them. So, you can make a copy and work with them without being concern about the modification applied to it.
A test can be done with the following code:
int[] test = new int[] {1,2,3};
int[] test2 = Arrays.copyOf(test,test.length);
test2[0] = 9;
System.out.println(Arrays.toString(test));
Comments
In case of primitive types like int you're coping the values, not pointer, so your original array is still untouched after invoking method "print". It doesnt hold though for arrays
1 Comment
tomi
if we have int arrays then we are also just pointing and not copying. this would be copying: int i=5; int j=i;
