String Best Practices in Java

In this blog post, I will explain the best practices for String Handling in Java. This post is part of the Java Best Practices Series. It aims to guide you on how to use Strings effectively in day-to-day Java projects.

Strings are one of the most used data types in Java, but if not handled correctly, they can lead to performance issues and cumbersome code. This blog post outlines the best practices for working with strings in Java, ensuring efficient and maintainable code.

Check out the beginner to expert String Tutorial/Guide at Java String API Guide/Tutorial.

1. Use String Literals Where Possible

Using string literals allows Java to make use of the String Pool, leading to better performance.

String str = "JavaGuides"; // Uses String Pool

2. Use StringBuilder or StringBuffer for String Concatenations

Concatenating strings using the + operator in a loop can be highly inefficient. Use StringBuilder or StringBuffer instead.

• StringBuilder is faster as it is not synchronized.
• StringBuffer is synchronized and should be used in a multi-threading context.

Let's demonstrate the performance of String, StringBuilder, and StringBuffer:

public class PerformanceTest {
    public static void main(String[] args) {
        // String Concatenation
        String str = "";
        long startTime = System.nanoTime();
        for (int i = 0; i < 10; i++) {
            str += i;
        }
        long endTime = System.nanoTime();
        System.out.println(String.format("String operation with + operator took [%d] nano seconds", (endTime - startTime)));

        // StringBuilder Concatenation
        StringBuilder builder = new StringBuilder();
        startTime = System.nanoTime();
        for (int i = 0; i < 10; i++) {
            builder.append(i);
        }
        endTime = System.nanoTime();
        System.out.println(String.format("String operation with StringBuilder took [%d] nano seconds", (endTime - startTime)));

        // StringBuffer Concatenation
        StringBuffer buffer = new StringBuffer();
        startTime = System.nanoTime();
        for (int i = 0; i < 10; i++) {
            buffer.append(i);
        }
        endTime = System.nanoTime();
        System.out.println(String.format("String operation with StringBuffer took [%d] nano seconds", (endTime - startTime)));
    }
}

Output:

String operation with + operator took [86037] nano seconds
String operation with StringBuilder took [7928] nano seconds
String operation with StringBuffer took [14165] nano seconds

From the above results, StringBuilder and StringBuffer are faster than using the + operator.

3. Use equals() Method for String Comparison Instead of ==

To compare the content of strings, always use the equals() method instead of the == operator.

• Use == to compare primitives (e.g., boolean, int, char).
• == returns true if two references point to the same object.
• The result of the equals() method depends on its overridden implementation.

Here is a simple program to demonstrate comparing two strings using equals() method instead of == operator:

public class StringEqualsTest {
    public static void main(String[] args) {
        String s1 = "string";
        String s2 = "string";
        String s3 = new String("string");

        System.out.println("== operator result for s1 and s2 : " + (s1 == s2));
        System.out.println("== operator result for s1 and s3 : " + (s1 == s3));
        System.out.println("equals() method result for s1 and s2 : " + s1.equals(s2));
        System.out.println("equals() method result for s1 and s3 : " + s1.equals(s3));
    }
}

Output:

== operator result for s1 and s2 : true
== operator result for s1 and s3 : false
equals() method result for s1 and s2 : true
equals() method result for s1 and s3 : true

To compare the content of strings, always use the equals() method, not ==.

4. Call equals() Method on Known String Constants

If you know some constants are fixed, use the equals method on known constants rather than unknown variables to avoid null pointer exceptions.

public class ConstantEqualsTest {
    private static final String CONSTANT = "constant value";

    public static void main(String[] args) {
        processString("constant value");
    }

    private static void processString(String str) {
        if (CONSTANT.equals(str)) {
            System.out.println("CONSTANT.equals(string): " + CONSTANT.equals(str));
        }
    }
}

Output:

CONSTANT.equals(string): true

5. Prefer switch Statement Instead of Multiple if-else-if

Java 1.7 introduced the switch statement for Strings. If you need to compare multiple strings, use switch over multiple if-else-if statements.

public class Test {
    public static final String CONSTANT = "someConstant";

    public static void main(String[] args) {
        Test test = new Test();
        long startTime = System.nanoTime();
        test.convertStringToIntegerWithSwitch("FOUR");
        long endTime = System.nanoTime();
        System.out.println(String.format("String comparison with Switch took [%d] nano seconds.", (endTime - startTime)));

        startTime = System.nanoTime();
        test.convertStringToIntegerWithIf("FOUR");
        endTime = System.nanoTime();
        System.out.println(String.format("String comparison with If took [%d] nano seconds.", (endTime - startTime)));
    }

    private int convertStringToIntegerWithSwitch(String stringNumber) {
        switch (stringNumber) {
            case "ZERO": return 0;
            case "ONE": return 1;
            case "TWO": return 2;
            case "THREE": return 3;
            default: return -1;
        }
    }

    private int convertStringToIntegerWithIf(String stringNumber) {
        if ("ZERO".equals(stringNumber)) {
            return 0;
        } else if ("ONE".equals(stringNumber)) {
            return 1;
        } else if ("TWO".equals(stringNumber)) {
            return 2;
        } else if ("THREE".equals(stringNumber)) {
            return 3;
        } else {
            return -1;
        }
    }
}

Using the switch statement improves performance as compared to multiple if-else statements.

6. Be Careful with Case Sensitivity

Use equalsIgnoreCase() if you want to compare strings without considering their case.

if (str1.equalsIgnoreCase(str2)) {
    // Strings are equal, ignoring case
}

7. Prefer isEmpty to Check for Empty Strings

Instead of comparing the length of a string to zero, use the isEmpty() method.

if (str.isEmpty()) {
    // String is empty
}

8. Use String.valueOf() Instead of toString()

If an object needs to be converted to a string, the result of obj.toString() and String.valueOf(obj) will be the same, but String.valueOf() is null-safe and will not throw a NullPointerException.

Test test = null;
// Below statement will not throw NPE
System.out.println(String.valueOf(test));
// Next statement will throw NPE
System.out.println(test.toString());

If you are sure the object will never be null, use toString(). Otherwise, prefer String.valueOf().

9. Use String Utility Classes

Prefer String Utility classes from popular libraries because they are well-tested and widely used.

Here are some useful String Utility methods:

• Java String Utility Class
• 27 Useful String Utility Methods

10. Avoid Duplicate Literals

Code containing duplicate String literals can usually be improved by declaring the String as a constant field.

// Bad
private void bar() {
    String howdy = "Howdy";
    buz(howdy);
    buz(howdy);
}

private void buz(String x) {}

// Better
private static final String HOWDY = "Howdy";
private void bar() {
    buz(HOWDY);
    buz(HOWDY);
}
private void buz(String x) {}

11. Other Basic String Best Practices

Unnecessary Case Change

Using equalsIgnoreCase() is faster than using toUpperCase() or toLowerCase().

Append Character with char

Avoid concatenating characters as strings in `

StringBuffer/StringBuilder.append` methods.

StringBuffer sb = new StringBuffer();
sb.append('a'); // Use this

Consecutive Appends Should Reuse

Consecutive calls to StringBuffer/StringBuilder.append should be chained, reusing the target object.

// Poor
StringBuffer buf = new StringBuffer();
buf.append("Hello");
buf.append(foo);
buf.append("World");

// Better
StringBuffer buf = new StringBuffer();
buf.append("Hello").append(foo).append("World");

Avoid StringBuffer Field

StringBuffers/StringBuilders can grow considerably, potentially causing memory leaks if held within objects with long lifetimes.

public class Foo {
    private StringBuffer buffer;
    // Potential memory leak as an instance variable;
}

Unnecessary Conversion Temporary

Avoid unnecessary temporaries when converting primitives to Strings.

public String convert(int x) {
    // This wastes an object
    String foo = new Integer(x).toString();
    // This is better
    return Integer.toString(x);
}

Conclusion

String handling in Java is powerful but requires attention to best practices to avoid common pitfalls and inefficiencies. By following the above guidelines, developers can write code that's more efficient, readable, and maintainable. Whether working on large-scale applications or small projects, these best practices are essential for anyone dealing with strings in Java.

Learn more about Java best practices in the Java Best Practices Series. Let me know if you know any other best practices for String Handling in Java.

Java String Best Practices - Cheat Sheet

Use this Java String Best Practices cheat sheet for your quick reference:

Related Posts

• JUnit Framework Best Practices
• Java Naming Conventions
• Single Responsibility Principle
• Liskov's Substitution Principle
• Interface Segregation Principle
• Dependency Inversion Principle
• Open Closed Principle
• Oops principles in Java
• Restful API Best Practices
• JSP Best Practices
• Guide to JDBC Best Practices
• Collection Best Practices
• String Best Practices in Java
• Exception Handling Best Practices
• Synchronization Best Practices
• Serialization Best Practices