Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1 Comment
Oldest
Newest