CODEWITHSUNDEEP
javastring
Ratna Dinakar
Ratna Dinakar

Reputation: 1573

Strings - How do they work?

How do String objects work in Java? How does term "immutable" exactly apply to string objects? Why don't we see modified string after passing through some method, though we operate on original string object value?

Upvotes: 2

Views: 7435

Answers (5)

amit
amit

Reputation: 178421

a String has a private final char[] . when a new String object is created, the array is also created and filled. it cannot be later accessed [from outside] or modified [actually it can be done with reflection, but we'll leave this aside].

it is "immutable" because once a string is created, its value cannot be changed, a "cow" string will always have the value "cow".

We don't see modified string because it is immutable, the same object will never be changed, no matter what you do with it [besides modifying it with reflection]. so "cow" + " horse" will create a new String object, and NOT modify the last object.

if you define:

void foo(String arg) {
  arg= arg + " horse";
}

and you call:

String str = "cow";
foo(str);

the str where the call is is not modified [since it is the original reference to the same object!] when you changed arg, you simply changed it to reference another String object, and did NOT change the actual original object. so str, will be the same object, which was not changed, still containing "cow"

if you still want to change a String object, you can do it with reflection. However, it is unadvised and can have some serious side-affects:

    String str = "cow";
    try { 
    Field value = str.getClass().getDeclaredField("value");
    Field count = str.getClass().getDeclaredField("count");
    Field hash = str.getClass().getDeclaredField("hash");
    Field offset = str.getClass().getDeclaredField("offset");
    value.setAccessible(true);
    count.setAccessible(true);
    hash.setAccessible(true);
    offset.setAccessible(true);
    char[] newVal = { 'c','o','w',' ','h','o','r','s','e' };
    value.set(str,newVal);
    count.set(str,newVal.length);
    hash.set(str,0);
    offset.set(str,0);
    } catch (NoSuchFieldException e) {
    } catch (IllegalAccessException e) {}
    System.out.println(str);
}

Upvotes: 12

Alim Ul Gias
Alim Ul Gias

Reputation: 6791

I think this link will help you to understand how Java String really works

Now consider the following code -

String s = "ABC"; s.toLowerCase(); The method toLowerCase() will not change the data "ABC" that s contains. Instead, a new String object is instantiated and given the data "abc" during its construction. A reference to this String object is returned by the toLowerCase() method. To make the String s contain the data "abc", a different approach is needed.

Again consider the following - s = s.toLowerCase();

Now the String s references a new String object that contains "abc". There is nothing in the syntax of the declaration of the class String that enforces it as immutable; rather, none of the String class's methods ever affect the data that a String object contains, thus making it immutable.

I don't really understood your third question. May be providing a chunk of code and telling your problem is a better option. Hope this helps.

You can also look into this blogpost for more understanding

[code samples are taken from the wiki. you can also look in there for more information]

Upvotes: 0

Dhruv Gairola
Dhruv Gairola

Reputation: 9182

Strings in Java are immutable (state cannot be modified once created). This offers opportunities for optimization. One example is string interning, where string literals are maintained in a string pool and new String objects are only created if the particular string literal doesn't already exist in the pool. If the string literal already exists, a reference is returned. This can only be accomplished because strings are immutable, so you don't have to worry that some object holding a reference will change it.

Methods that appear to modify a string actually return a new instance. One example is string concatenation: 

String s = "";
for( int i = 0; i < 5; i++ ){
    s = s + "hi";
}

What actually happens internally (the compiler changes it):

String s = "";
for( int i = 0; i < 5; i++ ){
    StringBuffer sb = new StringBuffer();
    sb.append(s);
    sb.append("hi");
    s = sb.toString();
}

You can clearly see that new instances are created by the toString method (note that this can be made more efficient by directly using StringBuffers). StringBuffers are mutable, unlike Strings.

Upvotes: 2

hakon
hakon

Reputation: 354

Every object has state. The state of a String object is the array of characters that make up the String, for example, the String "foo" contains the array ['f', 'o', 'o']. Because a String is immutable, this array can never be changed in any way, shape, or form.

Every method in every class that wants to change a String must instead return a new String that represents the altered state of the old String. That is, if you try to reverse "foo" you will get a new String object with internal state ['o', 'o', 'f'].

Upvotes: 0

Kees de Kooter
Kees de Kooter

Reputation: 7195

From the tutorial:

The String class is immutable, so that once it is created a String object cannot be changed. The String class has a number of methods, some of which will be discussed below, that appear to modify strings. Since strings are immutable, what these methods really do is create and return a new string that contains the result of the operation.

Upvotes: 4

Related Questions