Thread: primitive vs reference data-type

Hello everyone!

This is probably a really simple question but i got a little it confused.
I wanted to write a little example which explains the difference between a non reference and a reference data type.
So i choose 2 ints and 2 strings:

         int eins,zwei;
         string a,b; 
...
         eins = 3;
    	 zwei = eins;
    	 a = "before";
    	 b = a;
//i generated an outout then i set
 
         eins = 5;
         a = "after";
//again i generated an output

what i expected was: eins =5 zwei= 3 a= "after" b= "after"

BUT b is still "before"

i thought with b= a; i set the reference to a so that b would change when i change a; where am i thinking wrong?

Strings are immutable, so:
a = "before";
b = a; (now they both point to the same string)

a = "after" (now a points to a different string and b still points to the same old string because b was not changed)

See the accepted answer here

I c...ok...ill try explain my understanding of this:

i create strings a,b;
i set a = "before"; b = a; now b is pointing to the actually same place somewhere in my memory if i got jps right? following the tuts kevin linked i copied the reference of a and gave it to b (where a and b are just some fixed adress while runtime and in this adresses is the adress of the data a and b are supposed to represent, thos stored adresses are the said remote controls in the tutorial).
now when i set a = "after"; new memory is asigned and a new string is created for a with a new adress in my memory and the adress in a is now leading to the place in memory where the new ccreated string "after" stands. i DIDNT change the "before". therefore (cause i didn't change the reference/remote control in b) b is still pointing to the memory where "before" is stored.

this principle applies to all classes.

did i get that right?

if yes: is there a possibility to simulate a structure like i thought it was? namely:
a=c;
b=c;
change in c directly affects a and b.
when i got it right changing c wouldn't do anything to a and b in this.

thank you two for your time!

Some code to play with

public class EditableObject {
 
	private String message;
 
	public EditableObject(String message) {
		this.setMessage(message);
	}
 
	public String getMessage() {
		return message;
	}
 
	public void setMessage(String message) {
		this.message = message;
	}
 
}

public class EditableObjectTest {
 
	public static void main(String[] args) {
 
		EditableObject eo = new EditableObject("before");
		EditableObject copy = eo;
		System.out.println(eo.getMessage());
		copy.setMessage("after");
		System.out.println(eo.getMessage());
	}
 
}

Hello.
It is okay to use "reference" in java termilonogy.
Suppose I have a ArrayList object arrayList that holds 'n' strings.
I invoke shrink(arrayList). In the shrink() method I remove the last two elements. After control returns from shrink() method to the calling method the object referred to by arrayList has been changed. It has 'n-2' strings.
Coming to String, String objects are immutable. It means once an String object is created it will never ever be modified. The operations invoked on it return another String which is again immutable.
But if I say,
String s1="abc", s2="abc" both s1 and s2 refer to same object.
So using "reference" term is perfectly fine in java.

Bottom line is it is the implementation that will decide if an object can be modified or not. But "reference" is always there.

Syed.

Originally Posted by syedbhai

String s1="abc", s2="abc" both s1 and s2 refer to same object.

s1 and s2 would refer to two different objects which happen to hold the same value, but s1==s2 is false, they are two different objects

<code>
public static void main(String str[]) {
String s1="abc", s2="abc";

System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s1 == s2);
}
</code>
This is the output:
96354
96354
true

ok..i runned your code jps.
am i right when i say that this works, because the object you created is mutable via the method you implemented which allows to change the value of the object while the object remains at its place in memory?
no references are changed but the data in the referenced object?
is changing an objects values using a method of this object the only way i can achieve this?

(concerning the s1 s2 example: == compares the reference (of non primitive types) so syeds code would create 2 different places in memory for 2 strings of same value but the comparing would give me a false. but lets say we have 2 strings with same value and i don't know in which way they were set. it could possibly be that they refer to the same object even if they probably don't?)

Syed, code tags are enclosed by square braces, '[tagHere]'.

Originally Posted by syedbhai

public static void main(String str[])  {
      String s1="abc", s2="abc";
 
      System.out.println(s1.hashCode());
      System.out.println(s2.hashCode());
      System.out.println(s1 == s2);
    }

This is the output:
96354
96354
true

that confuses me...i really thought that would give a false...

Originally Posted by syedbhai

<code>
public static void main(String str[]) {
String s1="abc", s2="abc";

System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s1 == s2);
}
</code>
This is the output:
96354
96354
true

The compiler has optimized because s1 and s2 were declared with static strings of equal value, and since strings are immutable there was no reason to make two different String objects with the same value.

public static void main(String str[]) {
	String s1, s2;
	Scanner scanner = new Scanner(System.in);
	System.out.println("Enter s1");
	s1 = scanner.nextLine();
	System.out.println("Enter s2");
	s2 = scanner.nextLine();
	System.out.println(s1 == s2);
	scanner.close();
	}

Input: a a
Output: false

--- Update ---

Originally Posted by Wolfone

ok..i runned your code jps.
am i right when i say that this works, because the object you created is mutable via the method you implemented which allows to change the value of the object while the object remains at its place in memory?
no references are changed but the data in the referenced object?
is changing an objects values using a method of this object the only way i can achieve this?

(concerning the s1 s2 example: == compares the reference (of non primitive types) so syeds code would create 2 different places in memory for 2 strings of same value but the comparing would give me a false. but lets say we have 2 strings with same value and i don't know in which way they were set. it could possibly be that they refer to the same object even if they probably don't?)

Yes you are understanding correctly. The important thing to note is that both variables are linked to the same object. Note that the printlns were both done on the variable named eo and the string was updated through the variable named copy, (actually a very poor variable name for this example, my bad)
Using a method is not the only way, any field can be changed, or any method can be called, provided it is visible and accessable (public/protected/etc).

so strings which hold the same value at compile-time get the same address but strings subsequently added at runtime would get different addresses even if they hold the same value?


EDIT: reply to #12 update: i thought so and already tested it in your example by removing the private modification and so on.
well copy holds a copy of the address it refers to...so its not that bad...^^

thanks for enlightening me (again )!

Originally Posted by Wolfone

so strings which hold the same value at compile-time get the same address but strings subsequently added at runtime would get different addresses even if they hold the same value?

This is an optimization any decent compiler should make, yes, but there is no guarantee it will happen that I know of.

Wolfone,
This link may be of help to you.
String constant/literal pool » the Open Tutorials

Syed.

very interesting link! thanks!

you three helped a lot!

i think that solves this thread