Difference Between String isEmpty() and isBlank()

Last updated: December 2, 2025

Written by: Pedro Lopes

Reviewed by: Luis Javier Peris

Java String

Java Null

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.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

Working with Strings in Java is sometimes confusing because we have many ways to do similar things.

In this article, we’ll look at how to validate blank and empty Strings using the isEmpty() and isBlank() methods. Although similar, the two methods are not the same.

2. Glancing at String.isEmpty()

Let’s start with the isEmpty() String operation. Simply put, the isEmpty() method returns true if the String is empty. Otherwise, it returns false.

Internally, isEmpty() relies on the length of the byte array that represents the text of a String object. Moreover, the isEmpty() method counts any type of character to calculate if a text is empty or not. Therefore, empty spaces, tabulations, new lines, or any character that can be represented as a byte counts as a valid character.

Let’s illustrate that with a simple test:

@Test
public void givenString_whenCallIsEmpty_thenReturnCorrectValues() {
    assertFalse("Example text".isEmpty());
    assertTrue("".isEmpty());
    assertFalse("  ".isEmpty());
    assertFalse("\t\n\r\f".isEmpty());
}

Notoriously, the first line tests a String that contains characters, so isEmpty() returns false.

On the other hand, the second String doesn’t contain any character, and thus, isEmpty() returns true.

Finally, for the String with only blank characters and the one with escape characters at lines 3 and 4, isEmpty() returns false.

3. Looking at Java 11’s String.isBlank()

The isBlank() method, introduced in Java 11, is identical to isEmpty() with the nuance that it also returns true for Strings that contain only whitespace characters.

The five characters considered whitespace characters in Java are the \s (space) and the \t, \n, \r, and \f escape sequences.

Behind the scenes, the isBlank() method searches for the index of the first non-whitespace character. If there are no non-whitespace characters, that index would be equal to the length of the array. Finally, it compares that index with the length of the byte array to output the correct answer.

Let’s check that out with a unit test:

@Test
public void givenString_whenCallStringIsBlank_thenReturnCorrectValues() {
    assertFalse("Example text".isBlank());
    assertTrue("".isBlank());
    assertTrue("  ".isBlank());
    assertTrue("\t\n\r\f ".isBlank());
}

Noticeably, “Example text” is considered not blank since it contains at least one non-whitespace character.

Additionally, the second String doesn’t contain any characters, so it’s blank.

The String at the third line has only whitespace characters, so isBlank() returns true.

Furthermore, the String in the last line contains all escape sequence characters that are considered as whitespaces. Therefore, isBlank() also returns true in that case.

4. Comparing isBlank() vs. isEmpty()

In summary, isEmpty() only returns true when the String doesn’t contain any character. In contrast, isBlank() returns true when the String doesn’t contain any character and all of its characters are whitespace characters.

Let’s use a table to visualize all return values of isEmpty() and isBlank() in the situations described in previous sections.

Method	no character	\t	\n	\r	\f	\s (space)	any other
isEmpty()	true	false	false	false	false	false	false
isBlank()	true	true	true	true	true	true	false

The above table summarizes that if the String doesn’t contain any character, both methods return true.

Additionally, the escape sequences \t, \n, \r, \f, and \s are considered whitespace characters, so only isBlank() returns true. In contrast, isEmpty() returns false for all of them.

Finally, for any other character different from the ones shown in the table, both methods return false.

Before Java 11, developers typically used the combination of String.trim() and String.isEmpty() to validate that a text contains only whitespace characters. However, as we saw throughout this tutorial, in applications using Java 11 or higher, we can simplify that to simply use String.isBlank().

5. Conclusion

In this tutorial, we’ve seen the differences between the isBlank() vs. isEmpty(). The critical difference is that isBlank() returns true for whitespace characters, like some escape sequences. On the other hand, isEmpty() only returns true when the String doesn’t contain any character.

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.