StringUtils.isBlank () vs String.isEmpty ()

J'ai rencontré un code qui présente les éléments suivants:

String foo = getvalue("foo");
if (StringUtils.isBlank(foo))
    doStuff();
else
    doOtherStuff();

Cela semble être fonctionnellement équivalent à ce qui suit:

String foo = getvalue("foo");
if (foo.isEmpty())
    doStuff();
else
    doOtherStuff();

Y a-t-il une différence entre les deux ( org.apache.commons.lang3.StringUtils.isBlanket java.lang.String.isEmpty)?

StringUtils.isBlank()vérifie que chaque caractère de la chaîne est un caractère d'espacement (ou que la chaîne est vide ou qu'elle est nulle). C'est totalement différent de simplement vérifier si la chaîne est vide.

De la documentation liée:

Vérifie si une chaîne est un espace, vide ("") ou null.

 StringUtils.isBlank(null)      = true
 StringUtils.isBlank("")        = true  
 StringUtils.isBlank(" ")       = true  
 StringUtils.isBlank("bob")     = false  
 StringUtils.isBlank("  bob  ") = false

Pour comparaison StringUtils.isEmpty :

 StringUtils.isEmpty(null)      = true
 StringUtils.isEmpty("")        = true  
 StringUtils.isEmpty(" ")       = false  
 StringUtils.isEmpty("bob")     = false  
 StringUtils.isEmpty("  bob  ") = false

Avertissement: Dans java.lang.String .isBlank () et java.lang.String .isEmpty () fonctionnent de la même façon, sauf qu'ils ne reviennent pas truepour null.

java.lang.String.isBlank()

java.lang.String.isEmpty()

La réponse acceptée de @arshajii est totalement correcte. Mais en étant plus explicite en disant ci-dessous,

StringUtils.isBlank ()

 StringUtils.isBlank(null)      = true
 StringUtils.isBlank("")        = true  
 StringUtils.isBlank(" ")       = true  
 StringUtils.isBlank("bob")     = false  
 StringUtils.isBlank("  bob  ") = false

StringUtils.isEmpty

 StringUtils.isEmpty(null)      = true
 StringUtils.isEmpty("")        = true  
 StringUtils.isEmpty(" ")       = false  
 StringUtils.isEmpty("bob")     = false  
 StringUtils.isEmpty("  bob  ") = false

StringUtils isEmpty = String isEmpty vérifie + vérifie la valeur null.

StringUtils isBlank = StringUtils isEmpty vérifie + vérifie si le texte ne contient que des caractères d' espacement .

Liens utiles pour une enquête plus approfondie:

• Documentation de StringUtils isBlank
• Documentation de StringUtils isEmpty
• String isEmpty documentation

StringUtils.isBlank() vérifiera également null, alors que ceci:

String foo = getvalue("foo");
if (foo.isEmpty())

va lancer un NullPointerExceptionif fooest nul.

StringUtils.isBlankrenvoie également truejuste un espace:

isBlank (String str)

Vérifie si une chaîne est un espace, vide ("") ou null.

StringUtils.isBlank(foo)effectuera une vérification nulle pour vous. Si vous effectuez foo.isEmpty()et fooest null, vous déclencherez une NullPointerException.

StringUtils.isBlank () renvoie true pour les espaces vides (juste les espaces blancs) et pour String nul également. En fait, il coupe les séquences de caractères et effectue ensuite une vérification.

StringUtils.isEmpty () renvoie true lorsqu'il n'y a aucune conséquence dans le paramètre String ou lorsque le paramètre String est nul. La différence est que isEmpty () retourne false si le paramètre String ne contient que des whiltespaces. Il considère les espaces blancs comme un état de non vide.

La seule différence entre isBlank () et isEmpty () est:

StringUtils.isBlank(" ")       = true //compared string value has space and considered as blank

StringUtils.isEmpty(" ")       = false //compared string value has space and not considered as empty

public static boolean isEmpty(String ptext) {
 return ptext == null || ptext.trim().length() == 0;
}

public static boolean isBlank(String ptext) {
 return ptext == null || ptext.trim().length() == 0;
}

Les deux ont le même code. Comment isBlank va-t-il gérer les espaces blancs?

public static boolean isBlankString( String pString ) {
 int strLength;
 if( pString == null || (strLength = pString.length()) == 0)
 return true;
 for(int i=0; i < strLength; i++)
 if(!Character.isWhitespace(pString.charAt(i)))
 return false;
 return false;
}

Au lieu d'utiliser une bibliothèque tierce, utilisez Java 11 isBlank ()

    String str1 = "";
    String str2 = "   ";
    Character ch = '\u0020';
    String str3 =ch+" "+ch;

    System.out.println(str1.isEmpty()); //true
    System.out.println(str2.isEmpty()); //false
    System.out.println(str3.isEmpty()); //false            

    System.out.println(str1.isBlank()); //true
    System.out.println(str2.isBlank()); //true
    System.out.println(str3.isBlank()); //true

Je réponds à cela parce que c'est le meilleur résultat dans Google pour "String isBlank () Method".

Si vous utilisez Java 11 ou supérieur, vous pouvez utiliser la méthode isBlank () de la classe String . Cette méthode fait la même chose que la classe Apache Commons StringUtils.

J'ai écrit un petit post sur les exemples de cette méthode, lisez-le ici .