Is there some way to pass a String to a method as mutable?

Question

I know that by default, String varaibles are immutable in Java. But is there some way to set a String variable, or some special way (when passing said String variable) to make it mutable?

Or at least temporarily allow that Stirng to be changed?

I realize that I can change the value of a String by just assigning the modified immutable variable to the original variable, like show:

String A = "Test";
A.toUpperCase(); //will make A upper case, but not save the new upper case string to a variable
Sring A = A.toUpperCase; //will give me TEST and save it to A, replacing A

Is there some way to tell Java "Hey, for this one String specifically, treat it as mutable"?

Answer 1

No. Strings are immutable.

You should either create your own mutable structure that wraps a string or a char array if you need to, or using something like a StringBuilder if that will suit your needs.

Answer 2

Nope, the class String is immutable in java. In order to do this you can create class:

public class MutableString {

    private String str;

    public MutableString(String str) {
        this.str = str;
    }

    public void toUpperCase() {
        str = str.toUpperCase();
    }

    public String toString() {
        return str;
    }

}

The feasibility of this technique depends on the number of methods you need from String.

Answer 3

String variables are mutable in Java. String objects are not mutable.

However, method arguments are passed by value, not by reference. So you can't return a value for a String through a reference parameter.

For example, you can do this, because a is a mutable variable -- pointing first to one immutable String object, then another.

 String a = "Test";
 a = a.toUpperCase(); 

And you can do this:

  public void myfunction( String a ) {
     a = a.toUppercase
  }

But this caller will not observe a change to its own variable, because the actual and formal arguments are two different variables.

  public void mycaller() {
      String actual = "test";
      myfunction( actual );
      System.out.println( actual ); // Prints "test"
  }

What you could do is:

• Return the String from the method.
• Return from the method a results object that includes the String.
• Make your own class MyMutableString, which contains a mutable reference to a String.
• Pass a String[] array with one element.

If you have multiple values to return, consider the second option - return an object that encapsulates the method results. If you have a single value to return, just return it. The other options are less frequently useful.

Answer 4

No, there is no way to make a String in Java mutable. The class doesn't expose its inner character array, and offers no methods that can alter it. If you want mutable Strings, you've got a few options, though:

• StringBuilder and its synchronized variant StringBuffer are essentially mutable Strings, although slightly more cumbersome in code.
• char arrays are mutable - you can use toCharArray() to get a mutable copy of a String's internal char array, for example.
• Create your own class with an internal char array and methods that offer the manipulation features you want and toString() that allows you to use it as you intend.

Answer 5

The short answer is no, you cannot mutate java.lang.String objects.

To make Java more memory efficient, the JVM sets aside a special area of memory called the "String constant pool." When the compiler encounters a String literal, it checks the pool to see if an identical String already exists.

If a match is found, the reference to the new literal is directed to the existing String, and no new String literal object is created. (The existing String simply has an additional reference.) Now we can start to see why making String objects immutable is such a good idea. If several reference variables refer to the same String without even knowing it, it would be very bad if any of them could change the String's value.

You might say, "Well that's all well and good, but what if someone overrides the String class functionality; couldn't that cause problems in the pool?" That's one of the main reasons that the String class is marked final.

Nobody can override the behaviors of any of the String methods, so you can rest assured that the String objects you are counting on to be immutable will, in fact, be immutable.

Reference: SCJP Sun Certified Programmer for Java 6 - Study Guide Exam (310-065) - Kathy Sierra & Bert Bates

Answer 6

You can replace the reference (!) to a String as often as you like:

String A = "Test";
A = A.toUpperCase(); //will make A upper case
A = A.substring( 1 ); 

and so on. Excess usage of this may not be the best approach - it depends on the context.

Since some people seem to think that this can't be done with a String passed through a method:

String modify( String x ){
    x = x.toLowerCasae();
    x = x.substring( 1 );
    return x;
}

and the call must, of course replace the original String reference.

String tomod = "abc";
tomod = modify( tomod );

Three are, of course, classes better suited to this kind of String modification.