I have two classes using the same String
value, and both storing them as a final private field.
public class Foo{
private final String str;
private final Bar bar; //notice this
public Foo(String in){
this.str=in;
this.bar=new Bar(in); //option 1
this.bar=new Bar(this.str); //option 2
}
}
And here comes Bar
:
public class Bar{
private final String boo;
public Bar(String in){
this.boo=in;
}
}
*Intuition hints at the former but you can never be sure with Java.
Side question:
What I'm trying to do is this: Foo
does some processing on str
and uses Bar
as a utility class. Conceptually Foo
and str
are closely linked together, but apart from the constructor, Foo
doesn't touch str
directly again, but only through Bar
.
I thought about removing str
from Foo's fields in fear of Java allocating the same string twice, which prompted this question. But from a software engineering / code correctness standpoint, should I remove it?
Since you don't instantiate another String instance, your options are all the same reference (in this example).
Considering your initial call(s), we could force them to have different reference values (I don't know why you would do this, and there are consequences - namely growing the intern cache);
this.str=in;
this.bar=new Bar(in); // option 1
this.bar=new Bar(this.str); // option 2
This will change the references.
this.str = new String(in); // <-- create a new String from in.
this.bar = new Bar(in); // <-- keeps the original reference to in.
StringBuilder sb = new StringBuilder(in); // <-- create a StringBuilder.
this.bar = new Bar(sb.toString()); // <-- create another String.