CODEWITHSUNDEEP
javaregexstringtrimis-empty
prash
prash

Reputation: 1016

Best way to verify string is empty or null

i am sure this must have been asked before in different ways - as isEmptyOrNull is so common yet people implement it differently. but i have below curious query in terms of best available approach which is good for memory and performance both.

1) Below does not account for all spaces like in case of empty XML tag

return inputString==null || inputString.length()==0;

2) Below one takes care but trim can eat some performance + memory 

return inputString==null || inputString.trim().length()==0;

3) Combining one and two can save some performance + memory (As Chris suggested in comments)

return inputString==null || inputString.trim().length()==0 || inputString.trim().length()==0;

4) Converted to pattern matcher (invoked only when string is non zero length)

private static final Pattern p = Pattern.compile("\\s+");

return inputString==null || inputString.length()==0 || p.matcher(inputString).matches();

5) Using libraries like - Apache Commons (StringUtils.isBlank/isEmpty) or Spring (StringUtils.isEmpty) or Guava (Strings.isNullOrEmpty) or any other option?

Upvotes: 43

Views: 166017

Answers (15)

Joop Eggen
Joop Eggen

Reputation: 109567

Just to show java 8's stance to remove null values.

String s = Optional.ofNullable(myString).orElse("");
if (s.trim().isEmpty()) {
    ...
}

Makes sense if you can use Optional<String>.

Java update

if (s.isBlank()) {

The more recent isBlank fits better.

Upvotes: 16

MAREESKANNNAN RAJENDRAN
MAREESKANNNAN RAJENDRAN

Reputation: 557

latest spring using hasText to validate a String as shown below

import org.springframework.util.StringUtil;
    
    class Test {
       public boolean isNullOrEmpty(String data) {
          return !StringUtils.hasText(data);
       }
    }

Upvotes: 1

gifpif
gifpif

Reputation: 4917

Using the Spring Framework library check whether the given String is empty:

f(ObjectUtils.isEmpty(str)) {
    //... The string is blank or null
}

Upvotes: 4

naveen
naveen

Reputation: 21

We can make use of below

Optional.ofNullable(result).filter(res -> StringUtils.isNotEmpty(res))
            .ifPresent( s-> val.set(s));

Upvotes: 0

sachyy
sachyy

Reputation: 622

With the openJDK 11 you can use the internal validation to check if the String is null or just white spaces

import jdk.internal.joptsimple.internal.Strings;
...

String targetString;
if (Strings.isNullOrEmpty(tragetString)) {}

Upvotes: 1

rsa
rsa

Reputation: 339

If you have to test more than one string in the same validation, you can do something like this:

import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StringHelper {

  public static Boolean hasBlank(String ... strings) {

    Predicate<String> isBlank = s -> s == null || s.trim().isEmpty();

    return Optional
      .ofNullable(strings)
      .map(Stream::of)
      .map(stream -> stream.anyMatch(isBlank))
      .orElse(false);
  }

}

So, you can use this like StringHelper.hasBlank("Hello", null, "", " ") or StringHelper.hasBlank("Hello") in a generic form.

Upvotes: 0

gzak
gzak

Reputation: 4110

Haven't seen any fully-native solutions, so here's one:

return str == null || str.chars().allMatch(Character::isWhitespace);

Basically, use the native Character.isWhitespace() function. From there, you can achieve different levels of optimization, depending on how much it matters (I can assure you that in 99.99999% of use cases, no further optimization is necessary):

return str == null || str.length() == 0 || str.chars().allMatch(Character::isWhitespace);

Or, to be really optimal (but hecka ugly):

int len;
if (str == null || (len = str.length()) == 0) return true;
for (int i = 0; i < len; i++) {
  if (!Character.isWhitespace(str.charAt(i))) return false;
}
return true;

One thing I like to do:

Optional<String> notBlank(String s) {
  return s == null || s.chars().allMatch(Character::isWhitepace))
    ? Optional.empty()
    : Optional.of(s);
}

...

notBlank(myStr).orElse("some default")

Upvotes: 4

Deepak Pandey
Deepak Pandey

Reputation: 628

You can make use of Optional and Apache commons Stringutils library

Optional.ofNullable(StringUtils.noEmpty(string1)).orElse(string2);

here it will check if the string1 is not null and not empty else it will return string2

Upvotes: 0

GregH
GregH

Reputation: 5459

To detect if a string is null or empty, you can use the following without including any external dependencies on your project and still keeping your code simple/clean: 

if(myString==null || myString.isEmpty()){
    //do something
}

or if blank spaces need to be detected as well:

if(myString==null || myString.trim().isEmpty()){
    //do something
}

you could easily wrap these into utility methods to be more concise since these are very common checks to make:

public final class StringUtils{

    private StringUtils() { }   

    public static bool isNullOrEmpty(string s){
        if(s==null || s.isEmpty()){
            return true;
        }
        return false;
    }

    public static bool isNullOrWhiteSpace(string s){
        if(s==null || s.trim().isEmpty()){
            return true;
        }
        return false;
    }
}

and then call these methods via:

if(StringUtils.isNullOrEmpty(myString)){...}

and

if(StringUtils.isNullOrWhiteSpace(myString)){...}

Upvotes: 25

simhumileco
simhumileco

Reputation: 34563

Simply and clearly:

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

Upvotes: 1

Adarsh Thimmappa
Adarsh Thimmappa

Reputation: 21

In most of the cases, StringUtils.isBlank(str) from apache commons library would solve it. But if there is case, where input string being checked has null value within quotes, it fails to check such cases.

Take an example where I have an input object which was converted into string using String.valueOf(obj) API. In case obj reference is null, String.valueOf returns "null" instead of null.

When you attempt to use, StringUtils.isBlank("null"), API fails miserably, you may have to check for such use cases as well to make sure your validation is proper.

Upvotes: 1

haneenCo
haneenCo

Reputation: 169

Optional.ofNullable(label)
.map(String::trim)
.map(string -> !label.isEmpty)
.orElse(false)

OR

TextUtils.isNotBlank(label);

the last solution will check if not null and trimm the str at the same time

Upvotes: 2

Evgeniy Dorofeev
Evgeniy Dorofeev

Reputation: 136042

Apache Commons Lang has StringUtils.isEmpty(String str) method which returns true if argument is empty or null

Upvotes: 5

mavis.chen
mavis.chen

Reputation: 101

This one from Google Guava could check out "null and empty String" in the same time.

Strings.isNullOrEmpty("Your string.");

Add a dependency with Maven

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>20.0</version>
</dependency>

with Gradle

dependencies {
  compile 'com.google.guava:guava:20.0'
}

Upvotes: 9

puczo
puczo

Reputation: 727

Useful method from Apache Commons:

 org.apache.commons.lang.StringUtils.isBlank(String str)

https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/StringUtils.html#isBlank(java.lang.String)

Upvotes: 45

Related Questions