Utiliser org.Apache.commun.lang.StringUtils

j'aime utiliser Apache commons-lang pour ces sortes de choses, et surtout le StringUtils utilitaire de la classe:

import org.apache.commons.lang.StringUtils;

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

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

vient d'ajouter Android ici:

import android.text.TextUtils;

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

pour ajouter à @BJorn et @SeanPatrickFloyd la façon Guava de faire ceci est:

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

Commons Lang est plus lisible à certains moments, mais j'ai lentement compté plus sur la goyave plus Parfois Commons Lang est confus quand il s'agit de isBlank() (comme dans ce qui est espace ou pas).

Goyave de la version de Communes Lang isBlank serait:

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

je dirai code qui ne permet pas "" (vide) et null est suspect et potentiellement bogué en ce qu'il ne traite probablement pas tous les cas où ne permet pas null est logique (bien que pour SQL je peux comprendre que SQL/HQL est étrange au sujet de '' ).

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

alternativement

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

ou

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

Note: le deuxième contrôle (premier et deuxième choix) suppose que la DOD n'est pas nulle. C'est ok seulement parce que la première vérification fait cela (et Java ne fait pas la deuxième vérification si la première est fausse)!

IMPORTANT: N'utilisez pas == pour l'égalité des chaînes. == vérifie le pointeur est égal, non pas la valeur. Deux chaînes peuvent être dans des adresses mémoire différentes (deux occurrences), mais ont la même valeur!

ça marche pour moi:

import com.google.common.base.Strings;

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

retourne true si la chaîne donnée est nulle ou est la chaîne vide.

envisagez de normaliser vos références string avec nullToEmpty. Si vous faire, vous pouvez utiliser des chaînes de caractères.isEmpty () au lieu de cette méthode, et vous ne besoin de formes spéciales null-safe de méthodes comme la chaîne.toUpperCase soit. Ou, si vous souhaitez normaliser "dans l'autre sens," conversion des chaînes vides en null, vous pouvez utiliser emptyToNull.

presque toutes les bibliothèques que je connais définissent une classe d'utilité appelée StringUtils , StringUtil ou StringHelper , et ils comprennent généralement la méthode que vous recherchez.

mon préféré est Apache Commons / Lang , où dans la StringUtils classe, vous obtenez à la fois le

1. StringUtils.isEmpty (String) et le
2. StringUtils.isBlank (String) method

(la première vérifie si une chaîne est nulle ou vide, la seconde vérifie si elle est nulle, vide ou espace seulement)

il y a des classes d'utilité similaires dans Spring, Wicket et beaucoup d'autres libs. Si vous n'utilisez pas de bibliothèques externes, vous pouvez introduire une classe StringUtils dans votre propre projet.

mise à jour: de nombreuses années ont passé, et ces jours-ci je recommande d'utiliser Goyave 's Strings.isNullOrEmpty(string) méthode.

Que Diriez-vous de:

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

l'Utilisation d'Apache StringUtils' isNotBlank méthode comme

StringUtils.isNotBlank(str)

il retournera true seulement si la DOD n'est pas nulle et n'est pas vide.

si vous ne voulez pas inclure toute la bibliothèque, il vous suffit d'inclure le code que vous voulez. Vous aurez à maintenir vous-même; mais c'est une simple fonction. Ici, il est copié de 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;
}

vous devez utiliser org.apache.commons.lang3.StringUtils.isNotBlank() ou org.apache.commons.lang3.StringUtils.isNotEmpty . La décision entre ces deux est basée sur ce que vous souhaitez vérifier.

le isNotBlank () vérifie que le paramètre d'entrée est:

• n'est pas Null,
• pas la chaîne vide ("")
• pas une séquence de caractères espace (" ")

Le isNotEmpty () vérifie seulement que le paramètre d'entrée est

• not null
• pas la Chaîne Vide ("")

il est un peu trop tard, Mais voici un style fonctionnel de vérification:

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

comme seanizer l'a dit plus haut, Apache StringUtils est fantastique pour cela, si vous deviez inclure la goyave, vous devriez faire ce qui suit;

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

puis-je également vous recommander de vous référer aux colonnes de votre résultat défini par nom plutôt que par index, ce qui rendra votre code beaucoup plus facile à maintenir.

test égale avec une chaîne vide et nulle dans le même conditionnel:

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

ne lance pas NullPointerException si str est nul, puisque Object.equals() retourne false si arg est null .

l'autre construction str.equals("") lancerait le redouté NullPointerException . Certains pourraient considérer la mauvaise forme en utilisant une chaîne littérale comme l'objet sur lequel equals() est appelé mais il fait le travail.

vérifiez aussi cette réponse: https://stackoverflow.com/a/531825/1532705

j'ai créé ma propre fonction utilitaire pour vérifier plusieurs chaînes à la fois, plutôt que d'avoir une instruction if pleine de if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty) . C'est la fonction:

public class StringUtils{

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

        return true;
    }   

}

donc je peux simplement écrire:

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

solution Simple:

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

retourne vrai ou faux basé sur l'entrée

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

il y a une nouvelle méthode dans java-11 : String#isBlank

retourne true si la chaîne est vide ou ne contient que des points blancs, sinon false.

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

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

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

peut être combiné avec Optional pour vérifier si la chaîne est nulle ou vide

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

String#estvide

vous pouvez utiliser StringUtils.isEmpty(), true si la chaîne est null ou vide.

 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");
 }

résultera en

str1 est null ou vide

str2 est null ou vide

je conseillerais Guava ou Apache Commons selon vos besoins. Vérifier les différents comportements dans mon exemple de 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");
    }
  }
}

résultat:

Apache:

A est blanc

B est blanc

c est blanc

Google:

b est NullOrEmpty

C is NullOrEmpty

dans le cas où vous utilisez Java 8 et que vous voulez avoir une approche de programmation plus fonctionnelle, vous pouvez définir un Function qui gère le contrôle et ensuite vous pouvez le réutiliser et apply() chaque fois que c'est nécessaire.

en venant à la pratique, vous pouvez définir le Function comme

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

alors, vous pouvez l'utiliser en appelant simplement la méthode apply() comme:

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

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

Si vous préférez, vous pouvez définir un Function qui vérifie si le String est vide et le nie ensuite avec ! .

Dans ce cas, le Function :

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

alors, vous pouvez l'utiliser en appelant simplement la méthode apply() comme:

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

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

pour l'exhaustivité: si vous êtes déjà en utilisant le cadre de ressort , le StringUtils fournir la méthode

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

retourne: true si la chaîne n'est pas nulle et a une longueur

ainsi que la méthode

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

retourne: true si la chaîne n'est pas nulle, sa longueur est supérieure à 0, et elle ne contient pas seulement des espaces

simplement, pour ignorer l'espace blanc aussi bien:

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

si vous utilisez Spring framework puis vous pouvez utiliser la méthode:

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

cette méthode accepte n'importe quel objet comme argument, en le comparant à null et à la chaîne vide. Par conséquent, cette méthode ne retournera jamais true pour un objet non-null non-String.

avec Java 8 optionnel vous pouvez faire:

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

dans cette expression, vous manipulerez String qui se composent d'espaces ainsi.

la meilleure façon de gérer null dans la chaîne est,

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

en bref,

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