Checking if a StringBuilder Is Null or Empty

1. Overview

StringBuilder allows us to build String values efficiently and conveniently. When working with StringBuilder in Java, there are situations where we need to verify whether it is null or empty.

In this quick tutorial, we’ll explore how to effectively perform these checks.

2. Introduction to the Problem

Before we implement checking if a StringBuilder is null or empty, let’s quickly recap what StringBuilder is. In Java, a StringBuilder is a mutable sequence of characters that allows us to modify String values without creating new instances, making it more memory-efficient when we perform frequent string manipulations.

Simply put, we can solve the problem by connecting a null check and an empty check by a logical OR operator (||):

is-null-check || is-empty-check

First, let’s prepare some StringBuilder objects as our inputs:

static final StringBuilder SB_NULL = null;
static final StringBuilder SB_EMPTY = new StringBuilder();
static final StringBuilder SB_EMPTY_STR = new StringBuilder("");
static final StringBuilder SB_BLANK_STR = new StringBuilder("   ");
static final StringBuilder SB_WITH_TEXT = new StringBuilder("I am a magic string");

As we can see, we try to make our input examples cover different cases, such as StringBuilder instances instantiated by the default constructor, an empty String, a blank String, and so on.

In this tutorial, we’ll leverage unit test assertions to verify whether each approach yields the expected result.

Next, let’s first look at the null checking part.

3. Implementing a null Check

Checking whether a StringBuilder is null isn’t a challenge to us. In Java, we can verify any object is null using theObject == null:

static boolean isNull(StringBuilder sb) {
    return sb == null;
}

Next, let’s test the method quickly with our prepared inputs:

assertTrue(isNull(SB_NULL));
 
assertFalse(isNull(SB_EMPTY));
assertFalse(isNull(SB_EMPTY_STR));
assertFalse(isNull(SB_BLANK_STR));
assertFalse(isNull(SB_WITH_TEXT));

As the test shows, the method produces the expected results: It returns true only for the input SB_NULL (the null reference).

Next, let’s combine sb == null and the empty-check part to solve the problem.

4. Combining ‘sb == null’ and the Empty-Check

Verifying a StringBuild is null is a simple task. But, there are several ways to check if a StringBuilder is empty. Next, let’s take a closer at them.

4.1. Converting the StringBuilder to a String

As we’ve mentioned, StringBuilder maintains a sequence of characters. The StringBuilder.toString() method can convert the character sequence to a String. Then, we can simply check if the converted String is empty:

static boolean isNullOrEmptyByStrEmpty(StringBuilder sb) {
    return sb == null || sb.toString().isEmpty();
}

In this example, we use String.isEmpty() to examine whether the converted String is empty. Let’s pass our inputs to this method and see if it can return the expected results:

assertTrue(isNullOrEmptyByStrEmpty(SB_NULL));
assertTrue(isNullOrEmptyByStrEmpty(SB_EMPTY));
assertTrue(isNullOrEmptyByStrEmpty(SB_EMPTY_STR));
 
assertFalse(isNullOrEmptyByStrEmpty(SB_BLANK_STR));
assertFalse(isNullOrEmptyByStrEmpty(SB_WITH_TEXT));

As the test shows, the method returns true for null and empty StringBuilder objects. Since the blank String converted from SB_BLANK_STR has a positive length, it isn’t empty.

4.2. Using the StringBuilder.length() Method

The StringBuilder class implements the CharSequence interface. So, it implements the length() method to report the length of the character sequence. Therefore, we can also determine if a StringBuilder is empty by checking whether its length() returns 0:

static boolean isNullOrEmptyByLength(StringBuilder sb) {
    return sb == null || sb.length() == 0;
}

Next, let’s check this method using our inputs:

assertTrue(isNullOrEmptyByLength(SB_NULL));
assertTrue(isNullOrEmptyByLength(SB_EMPTY));
assertTrue(isNullOrEmptyByLength(SB_EMPTY_STR));
  
assertFalse(isNullOrEmptyByLength(SB_BLANK_STR));
assertFalse(isNullOrEmptyByLength(SB_WITH_TEXT));

The test shows that our method worked as expected.

4.3. Using the StringBuilder.isEmpty() Method

We’ve learned that the length() method is defined in the CharSequence interface. Additionally, CharSequence provides another convenient method isEmpty(), which offers a concise way to examine if the CharSequence object is empty by performing the length() == 0 check:

default boolean isEmpty() {
    return this.length() == 0;
}

StringBuilder is an implementation of CharSequence. Therefore, isEmpty() is also available in StringBuilder. Next, let’s create a method to leverage StringBuilder.isEmpty() to verify if a StringBuilder is empty:

static boolean isNullOrEmpty(StringBuilder sb) {
    return sb == null || sb.isEmpty();
}

Finally, let’s test it with our inputs:

assertTrue(isNullOrEmpty(SB_NULL));
assertTrue(isNullOrEmpty(SB_EMPTY));
assertTrue(isNullOrEmpty(SB_EMPTY_STR));
 
assertFalse(isNullOrEmpty(SB_BLANK_STR));
assertFalse(isNullOrEmpty(SB_WITH_TEXT));

As the test shows, the method produces the correct results.

4. Conclusion

In this article, we’ve explored different approaches to check whether a StringBuilder is null or empty in Java. Performing these checks prevents our code from falling into the NullPointerException pitfall or processing on empty inputs unexpectedly when we work with StringBuilder objects.