Check whether a String is not Null and not Empty

Question

How can I check whether a string is not null and not empty?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

Answer 1

What about isEmpty() ?

if(str != null && !str.isEmpty())

Be sure to use the parts of && in this order, because java will not proceed to evaluate the second part if the first part of && fails, thus ensuring you will not get a null pointer exception from str.isEmpty() if str is null.

Beware, it's only available since Java SE 1.6. You have to check str.length() == 0 on previous versions.

---

To ignore whitespace as well:

if(str != null && !str.trim().isEmpty())

(since Java 11 str.trim().isEmpty() can be reduced to str.isBlank() which will also test for other Unicode white spaces)

Wrapped in a handy function:

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

Becomes:

if( !empty( str ) )

Answer 2

Use org.apache.commons.lang.StringUtils

I like to use Apache commons-lang for these kinds of things, and especially the StringUtils utility class:

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 

Answer 3

Just adding Android in here:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

Answer 4

To add to @BJorn and @SeanPatrickFloyd The Guava way to do this is:

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Commons Lang is more readable at times but I have been slowly relying more on Guava plus sometimes Commons Lang is confusing when it comes to isBlank() (as in what is whitespace or not).

Guava's version of Commons Lang isBlank would be:

Strings.nullToEmpty(str).trim().isEmpty()

I will say code that doesn't allow "" (empty) AND null is suspicious and potentially buggy in that it probably doesn't handle all cases where is not allowing null makes sense (although for SQL I can understand as SQL/HQL is weird about '').

Answer 5

str != null && str.length() != 0

alternatively

str != null && !str.equals("")

or

str != null && !"".equals(str)

Note: The second check (first and second alternatives) assumes str is not null. It's ok only because the first check is doing that (and Java doesn't does the second check if the first is false)!

IMPORTANT: DON'T use == for string equality. == checks the pointer is equal, not the value. Two strings can be in different memory addresses (two instances) but have the same value!

Answer 6

Almost every library I know defines a utility class called StringUtils, StringUtil or StringHelper, and they usually include the method you are looking for.

My personal favorite is Apache Commons / Lang, where in the StringUtils class, you get both the

1. StringUtils.isEmpty(String) and the
2. StringUtils.isBlank(String) method

(The first checks whether a string is null or empty, the second checks whether it is null, empty or whitespace only)

There are similar utility classes in Spring, Wicket and lots of other libs. If you don't use external libraries, you might want to introduce a StringUtils class in your own project.

---

Update: many years have passed, and these days I'd recommend using Guava's Strings.isNullOrEmpty(string) method.

Answer 7

This works for me:

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

Returns true if the given string is null or is the empty string.

Consider normalizing your string references with nullToEmpty. If you do, you can use String.isEmpty() instead of this method, and you won't need special null-safe forms of methods like String.toUpperCase either. Or, if you'd like to normalize "in the other direction," converting empty strings to null, you can use emptyToNull.

Answer 8

There is a new method in java-11: String#isBlank

Returns true if the string is empty or contains only white space codepoints, otherwise false.

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

This could be combined with Optional to check if string is null or empty

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

String#isBlank

Answer 9

How about:

if(str!= null && str.length() != 0 )

Answer 10

For completeness: If you are already using the Spring framework, the StringUtils provide the method

org.springframework.util.StringUtils.hasLength(String str)

Returns: true if the String is not null and has length

as well as the method

org.springframework.util.StringUtils.hasText(String str)

Returns: true if the String is not null, its length is greater than 0, and it does not contain whitespace only

Answer 11

Returns true or false based on input

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);

Answer 12

You should use org.apache.commons.lang3.StringUtils.isNotBlank() or org.apache.commons.lang3.StringUtils.isNotEmpty. The decision between these two is based on what you actually want to check for.

The isNotBlank() checks that the input parameter is:

• not Null,
• not the empty string ("")
• not a sequence of whitespace characters (" ")

The isNotEmpty() checks only that the input parameter is

• not null
• not the Empty String ("")

Answer 13

You can use the functional style of checking:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

Answer 14

Use Apache StringUtils' isNotBlank method like

StringUtils.isNotBlank(str)

It will return true only if the str is not null and is not empty.

Answer 15

If you don't want to include the whole library; just include the code you want from it. You'll have to maintain it yourself; but it's a pretty straight forward function. Here it is copied from commons.apache.org

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}

Answer 16

test equals with an empty string and null in the same conditional:

if(!"".equals(str) && str != null) {
    // do stuff.
}

Does not throws NullPointerException if str is null, since Object.equals() returns false if arg is null.

the other construct str.equals("") would throw the dreaded NullPointerException. Some might consider bad form using a String literal as the object upon wich equals() is called but it does the job.

Also check this answer: https://stackoverflow.com/a/531825/1532705

Answer 17

Simple solution :

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}

Answer 18

I've made my own utility function to check several strings at once, rather than having an if statement full of if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). This is the function:

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

so I can simply write:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

Answer 19

You can use StringUtils.isEmpty(), It will result true if the string is either null or empty.

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

will result in

str1 is null or empty

str2 is null or empty

Answer 20

As seanizer said above, Apache StringUtils is fantastic for this, if you were to include guava you should do the following;

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

May I also recommend that you refer to the columns in your result set by name rather than by index, this will make your code much easier to maintain.

Answer 21

In case you are using Java 8 and want to have a more Functional Programming approach, you can define a Function that manages the control and then you can reuse it and apply() whenever is needed.

Coming to practice, you can define the Function as

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

Then, you can use it by simply calling the apply() method as:

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

If you prefer, you can define a Function that checks if the String is empty and then negate it with !.

In this case, the Function will look like as :

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

Then, you can use it by simply calling the apply() method as:

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true

Answer 22

With Java 8 Optional you can do:

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

In this expression, you will handle Strings that consist of spaces as well.

Answer 23

If you are using Spring Boot then below code will do the Job

StringUtils.hasLength(str)

Answer 24

To check if a string is not empty you can check if it is null but this doesn't account for a string with whitespace. You could use str.trim() to trim all the whitespace and then chain .isEmpty() to ensure that the result is not empty.

if(str != null && !str.trim().isEmpty()) { /* do your stuffs here */ }

Answer 25

I would advise Guava or Apache Commons according to your actual need. Check the different behaviors in my example code:

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

Result:
Apache:
a is blank
b is blank
c is blank
Google:
b is NullOrEmpty
c is NullOrEmpty

Answer 26

Simply, to ignore white space as well:

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}

Answer 27

Consider the below example, I have added 4 test cases in main method. three test cases will pass when you follow above commented snipts.

public class EmptyNullBlankWithNull {
    public static boolean nullEmptyBlankWithNull(String passedStr) {
        if (passedStr != null && !passedStr.trim().isEmpty() && !passedStr.trim().equals("null")) {
            // TODO when string is null , Empty, Blank
            return true;
        }else{
            // TODO when string is null , Empty, Blank
            return false;
        }
    }

    public static void main(String[] args) {
        String stringNull = null; // test case 1
        String stringEmpty = ""; // test case 2
        String stringWhiteSpace = "  "; // test case 3
        String stringWhiteSpaceWithNull = " null"; // test case 4
        System.out.println("TestCase result:------ "+nullEmptyBlankWithNull(stringWhiteSpaceWithNull));
        
    }
}

BUT test case 4 will return true(it has white space before null) which is wrong:

String stringWhiteSpaceWithNull = " null"; // test case 4

We have to add below conditions to make it work propper:

!passedStr.trim().equals("null")

Answer 28

TL;DR

java.util.function.Predicate is a Functional interface representing a boolean-valued Function.

Predicate offers several static and default methods which allow to perform logical operations AND &&, OR ||, NOT ! and chain conditions in a fluent way.

Logical condition "not empty && not null" can be expressed in the following way:

Predicate.not(Predicate.<String>isEqual(null).or(String::isEmpty));

Or, alternatively:

Predicate.<String>isEqual(null).or(String::isEmpty).negate();

Or:

Predicate.<String>isEqual(null).or(""::equals).negate();

Predicate.equal() is your friend

Static method Predicate.isEqual() expects a reference to the target object for equality comparison (an empty string in this case). This comparison is not hostile to null, which means isEqual() performs a null-check internally as well as utility method Objects.equals(Object, Object), so that comparison of null and null would return true without raising an exception.

A quote from the Javadoc:

Returns:

a predicate that tests if two arguments are equal according to Objects.equals(Object, Object)

The predicate the compares the given element against the null can be written as:

Predicate.isEqual(null)

Predicate.or() OR ||

Default method Predicate.or() allows chaining the conditions relationship among which can be expressed through logical OR ||.

That's how we can combine the two conditions: empty || null

Predicate.isEqual(null).or(String::isEmpty)

Now we need to negate this predicate

Predicate.not() & Predicate.negete()

To perform the logical negation, we have two options: static method not() and default method negate().

Here's how resulting predicates might be written:

public static final Predicate<String> NON_EMPTY_NON_NULL =
    Predicate.<String>isEqual(null).or(String::isEmpty).negate();

Note that in this case the type of the predicate Predicate.isEqual(null) would be inferred as Predicate<Object> since null gives no clue to the compiler what should be the type of the argument, and we can resolve this issue using a so-called Type-witness <String>isEqual().

Or, alternatively

public static final Predicate<String> NON_EMPTY_NON_NULL =
    Predicate.not(Predicate.<String>isEqual(null).or(String::isEmpty));

*Note: String::isEmpty can be also written as ""::equals, and if you need to check whether the string is Blank (contains various forms of unprintable characters or empty) you can use method reference String::isBlank. And if you need to verify a few more conditions, you can add as many as you need by chaining them via or() and and() methods.

Usage Example

Predicate is used an argument of such method as Stream.filter(), Collection.removeIf(), Collectors.partitioningBy(), etc. and you can create your custom ones.

Consider the following example:

List<String> strings = Stream.of("foo", "bar", "", null, "baz")
    .filter(NON_EMPTY_NON_NULL)
    .map("* "::concat) // append a prefix to make sure that empty string can't sneak in
    .toList();
        
strings.forEach(System.out::println);

Output:

* foo
* bar
* baz

Answer 29

If you use Spring framework then you can use method:

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

This method accepts any Object as an argument, comparing it to null and the empty String. As a consequence, this method will never return true for a non-null non-String object.

Answer 30

To check on if all the string attributes in an object is empty(Instead of using !=null on all the field names following java reflection api approach

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

This method would return true if all the String field values are blank,It would return false if any one values is present in the String attributes

Answer 31

I've encountered a situation where I must check that "null" (as a string) must be regarded as empty. Also white space and an actual null must return true. I've finally settled on the following function...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

Answer 32

In case you need to validate your method parameters you can use follow simple method

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

Example:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}

Answer 33

If anyone using springboot, then the following option might be helpful,

import static org.springframework.util.StringUtils.hasLength;

if (hasLength(str)) {
  // do stuff
}

Answer 34

The better way to handle null in the string is,

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

In short,

str.length()>0 && !str.equalsIgnoreCase("null")

Answer 35

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)||!str.equalsIgnoreCase("") {
    ...
}