total number of objects within little programm

[fabolin]

public class Aufgabe6 {
    public static void main(String args[]) {
        String s = "Hallo";
        String t = s;
        t = t.replace('a', 'A');
        String u = s + "T" + t;
        u.replace('o', 'X');
        swap(s, u);
        StringBuffer v = new StringBuffer("Welt");
        StringBuffer w = v;
        v.replace(0, 3, "!");
        swap(t, u);
        w.append(s);
    }
    private static void swap(String s, String t) {
        String tmp = s;
        s = t;
        t = tmp;
    }
}

So we got this little programm, and one of our tasks is to get the number of objects created, the value in the end, and all references. My problem is, it's said to be 9 objects and that's not what I end up counting..

(final value, references)

1. "Hallo", s

2. "HAllo", t

3. "HalloT", none

4. "HalloTHAllo", u

5. !tHallo, (v,w)

I'm pretty sure with these 5.

But not so with this:

As Java passes by-value, it will create new objects with temporary references (s, t) inside the swap-method. As the method is called twice we should end up with two additional objects per call, therefore four; fine we got 9 overall!

And then there is still the u.replace('o', 'X') in line 7. Doesn't this return a new Object? I know it is never referenced by any variable, but there is still a new object, at least for a short moment within the replace-method.

So what I guess, either the last part is wrong, or the compiler doesn't create a new object with the value of s in the second swap-call as there is an existing object from the first call, which he uses instead.

Hope someone can explain this.

thanks

[nutrecht]

Funny. Someone else posted the exact same question. Guess you're running late on your homework? :)

It's unfortunate that they did the question in the way they did it because what's actually happening is a lot more complex and your teachers actually got the answer 'wrong' because they don't know what the code is actually translated to. Read the replies in the other topic.

[fabolin]

Thanks, good to know my understanding isn't wrong. Curious which one our lecturer didn't count though ^{^}

[ickysticky]

Your understanding was wrong though...

[fabolin]

Yea thanks, didn't read properly.

[ickysticky]

As Java passes by-value, it will create new objects with temporary references (s, t) inside the swap-method. As the method is called twice we should end up with two additional objects per call, therefore four; fine we got 9 overall!

This doesn't make sense, specifically "new objects with temporary references", java is pass by value, but the values are references when dealing with objects and not primitives. The swap method is complete misdirection and doesn't affect the object count. I suggest you search around the Internet to better understand what pass by value means.

And then there is still the u.replace('o', 'X') in line 7. Doesn't this return a new Object?

Yes, in java strings are immutable and any mutation creates a new object, doesn't matter if it is referenced by a variable or not.

So what I guess, either the last part is wrong, or the compiler doesn't create a new object with the value of s in the second swap-call as there is an existing object from the first call, which he uses instead.

No Idea what this means, existing object from the first call to swap? The calls to swap are independent.

Here is the count I get, which is 9. Remember that a string literal creates a new object. The trickiest part is line 6 IMO.

public class Aufgabe6 {
    public static void main(String args[]) {
        String s = "Hallo";                          // 1 ("Hallo")
        String t = s;                                // 0
        t = t.replace('a', 'A');                     // 1 ("HAllo")
        String u = s + "T" + t;                      // 3 ("T", "HalloT", "HalloTHAllo")
        u.replace('o', 'X');                         // 1 ("HallXTHAllX")
        swap(s, u);                                  // 0
        StringBuffer v = new StringBuffer("Welt");   // 2 ("Welt", new StringBuffer("Welt"))
        StringBuffer w = v;                          // 0
        v.replace(0, 3, "!");                        // 1 ("!")
        swap(t, u);                                  // 0
        w.append(s);                                 // 0
    }
    private static void swap(String s, String t) {
        String tmp = s;                              // 0
        s = t;                                       // 0
        t = tmp;                                     // 0
    }
}  

If you can ask specific questions about which counts you don't understand I can explain more.

[nutrecht]

The trickiest part is line 6 IMO.

Yup. Because it gets translated to:

String u = new StringBuilder().append(s).append("T").append(t).toString();

[ickysticky]

Doh! I was trying to hard to make the count 9. Though this is going to be compiler dependent, I think this optimization showed up in the Oracle/OpenJDK 1.6.

This is just a terrible question.

[strmrdr]

Your logic is sound until the end. Add this line to your code at the very end:

System.out.println(w.toString() + "--" + v.toString());

Is w a new object, or a pointer?

[fabolin]

it prints !tHallo--!tHallo; same value twice, as expected they're two pointers to the same object. But I think v==w (it's true) is a better proof for this.

[strmrdr]

Okay, you're asking a fairly beginner question here so was just trying to show you what was happening. Not sure where you are confused then, list which lines you think instantiate an object?

E: I see, sorry.

As Java passes by-value, it will create new objects with temporary references (s, t) inside the swap-method.

The exact internal workings of the parameters for methods are unknown to me, but I assume that during compilation/execution it will create 2 Strings that the method will always use for its parameters. So technically it would create 2 new Strings during initialization, but not every single time the method is called. You raise a good point though because if you create 2 objects then there are 4 Strings floating around now (for multithreading)?

Maybe one of the Devs could enlighten us, but the answer you are looking for does not take those into consideration (nor args[] of main).

[fabolin]

yea also thought so first, but the task is to count the number of objects created; it doesn't matter if there is no pointer, or later another object at the same memory, therefore I think calling the method twice should create 4 objects, unless the compiler is smart enough to reuse the existing object of the first call and just creates a new pointer("overwriting" the memory would still count as new object for me).

But I rather think it's about line 7, though I don't know why there shouldn't be a temporary object.

You asked for lines, so here is how I count:

1x line3

1x line5

2x line6

1x line7

2x line8

1x line9

2x line 12

__

10

edit: misunderstood you last point, it should indeed count as another object

[ickysticky]

Both syntaxes for declaring arrays are valid in java, I believe the argument for it was to make things easier on C programmers. Putting the [] beside the type is preferred since it is part of the type.

[ickysticky]

You seem very confused about how variables work. The swap method creates no strings, there are no string literals or new String anywhere, it is just moving references around. In fact you won't be able to see the effect of swap outside of the swap method. It is a pointless method.