Passing a String by Reference in Java?

java

pass-by-reference

string-immutable

string-builder

byNikita Barsukov·Oct 26, 2024

class StringRef {
    StringBuilder content;
    StringRef(String str) { content = new StringBuilder(str); }
    void append(String str) { content.append(str); }
}

public class Main {
    public static void main(String[] args) {
        StringRef ref = new StringRef("Hello");
        mutateString(ref); // Let's add some flavor to our greeting
        System.out.println(ref.content); // Expect "Hello World" and not intergalactic static!
    }

    static void mutateString(StringRef ref) {
        ref.append(" World"); // Not quite "Hello, universe!" but it'll do.
    }
}

In Java, one efficient way to simulate passing a string by reference is by wrapping it using a StringBuilder within a helper class like StringRef. This allows us to use the mutable properties of StringBuilder to alter the content. The change will persist, hence behaving as if we passed the reference itself.

Immutable but why?

Java strings are immutable—they cannot be changed post-creation. Any string operation results in a separate, new String instance. Knowing this solidifies why Java lacks the 'pass-by-reference' concept seen in some other languages like C.

Arrays and container objects to the rescue

An excellent workaround to achieve 'pass-by-reference' behaviour is using arrays or container objects. When you pass an array or a mutable object with your string in it, you can modify this string, making the changes visible in the calling scope.

StringBuilder and StringBuffer: What's the deal?

Both StringBuilder and StringBuffer can be used for mutable string operations. While StringBuilder is preferential due to performance benefits in a single-threaded environment, you might want to use StringBuffer for thread-safe operations.

Value-passing semantics in Java

Java strictly follows pass-by-value semantics. When passing an object, you're actually passing the object reference's value and not the object itself. Understanding this helps debunk misconceptions about pass-by-reference in Java.

Channeling string changes externally

A nifty way to handle external string mutations is by wrapping a string in its own container class. Employing this OOP method neatly ties together behavior with state in typical Java fashion.

Enhancing code readability

Stamping method parameters with final when they shouldn't be altered offers boosted readability and maintainability in your code—it'll help you and your colleagues down the road.

Concatenation and references in Java

When concatenating, Java always creates a new reference. The original strings remain untouched. Awareness and proper handling can help you prevent unintended behavior.

Deeper insights

Opting for a container class

When dealing with legacy code or external libraries, a mutable string wrapper can provide a handy and flexible solution avoiding an otherwise extensive refactor.

When StringBuilder makes sense

If you're continually concatenating strings, especially within loops, switching over to StringBuilder instead of the + operator can result in noticeable performance improvements.

Using final parameters smartly

By marking parameters as final, you can prevent unintentional modifications within the method—acting as a preventive measure against subtly introduced bugs.

Multithreading with Strings

StringBuffer offers thread-safe operations, essential when working with string manipulation across multiple threads, saving you the effort of manual synchronization.

explain-codes / Java / Passing a String by Reference in Java?

Linked

Stringbuilder vs String Concatenation in toString() in Java



Create `ArrayList` from array



How do I print my Java object without getting "SomeType@2f92e0f4"?



Converting String array to java.util.List



Difference between null and empty ("") Java String

