Comment puis-je vérifier si une chaîne n'est pas nulle et non vide?

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

Et isEmpty () ?

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

Assurez-vous d'utiliser les parties de &&dans cet ordre, car java ne procédera pas à l'évaluation de la deuxième partie si la première partie de &&échoue, vous garantissant ainsi que vous n'obtiendrez pas d'exception de pointeur nul str.isEmpty()si if strest nul.

Attention, il n'est disponible que depuis Java SE 1.6. Vous devez vérifier str.length() == 0les versions précédentes.

Pour ignorer également les espaces:

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

(puisque Java 11 str.trim().isEmpty()peut être réduit, str.isBlank()ce qui permettra également de tester d'autres espaces blancs Unicode)

Enveloppé dans une fonction pratique:

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

Devient:

if( !empty( str ) )

Utilisez org.apache.commons.lang.StringUtils

J'aime utiliser Apache commons-lang pour ce genre de choses, et en particulier la classe utilitaire StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Il suffit d'ajouter Android ici:

import android.text.TextUtils;

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

Pour ajouter à @BJorn et @SeanPatrickFloyd La manière Guava de le faire est la suivante:

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

Commons Lang est parfois plus lisible, mais je me fie lentement à Guava et parfois Commons Lang est déroutant en ce qui concerne isBlank()(comme dans les espaces blancs ou non).

La version de Guava de Commons Lang isBlankserait:

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

Je dirai du code qui n'autorise pas ""(vide) ET null est suspect et potentiellement bogué en ce qu'il ne gère probablement pas tous les cas où l' nullinterdiction est logique (bien que pour SQL, je peux comprendre que SQL / HQL est bizarre '').

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

alternativement

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

ou

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

Remarque: La deuxième vérification (première et deuxième alternatives) suppose que str n'est pas nul. C'est ok seulement parce que la première vérification fait ça (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 que le pointeur est égal, pas la valeur. Deux chaînes peuvent être dans des adresses mémoire différentes (deux instances) mais ont la même valeur!

Presque toutes les bibliothèques que je connais définissent une classe utilitaire appelée StringUtils, StringUtilou StringHelper, et elles incluent généralement la méthode que vous recherchez.

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

(Le premier vérifie si une chaîne est nulle ou vide, le second vérifie si elle est nulle, vide ou blanc uniquement)

Il existe des classes utilitaires similaires dans Spring, Wicket et de nombreuses autres bibliothèques. Si vous n'utilisez pas de bibliothèques externes, vous souhaiterez peut-être introduire une classe StringUtils dans votre propre projet.

Mise à jour: de nombreuses années se sont écoulées et ces jours-ci, je recommanderais d'utiliser la méthode de GuavaStrings.isNullOrEmpty(string) .

Cela fonctionne pour moi:

import com.google.common.base.Strings;

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

Renvoie vrai si la chaîne donnée est nulle ou est la chaîne vide.

Envisagez de normaliser vos références de chaîne avec nullToEmpty. Si vous le faites, vous pouvez utiliser String.isEmpty () au lieu de cette méthode, et vous n'aurez pas non plus besoin de formes spéciales de méthodes sans danger comme String.toUpperCase. Ou, si vous souhaitez normaliser "dans l'autre sens", la conversion de chaînes vides en null, vous pouvez utiliser emptyToNull.

Que diriez-vous:

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

Utilisez la méthode isNotBlank d'Apache StringUtils comme

StringUtils.isNotBlank(str)

Il ne retournera vrai que si la chaîne n'est pas nulle et n'est pas vide.

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 voulez réellement vérifier.

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

• pas nul,
• pas la chaîne vide ("")
• pas une séquence de caractères blancs ("")

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

• pas nul
• pas la chaîne vide ("")

Renvoie vrai ou faux en fonction de l'entrée

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

Si vous ne voulez pas inclure la bibliothèque entière; il suffit d'inclure le code que vous souhaitez en tirer. Vous devrez l'entretenir vous-même; mais c'est une fonction assez simple. Ici, il est copié depuis 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;
}

C'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
    });

Il existe une nouvelle méthode java-11: String#isBlank

Renvoie true si la chaîne est vide ou ne contient que des points de code d'espace blanc, sinon false.

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

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

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

Cela pourrait être combiné avec Optionalpour vérifier si la chaîne est nulle ou vide

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

String # isBlank

test est égal à une chaîne vide et null dans le même conditionnel:

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

Ne lance pas NullPointerExceptionsi str est nul, car Object.equals()renvoie faux si arg l'est null.

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

Vérifiez également cette réponse: https://stackoverflow.com/a/531825/1532705

Solution simple:

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

Comme l'a dit seanizer ci-dessus, 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 jeu de résultats par nom plutôt que par index, cela rendra votre code beaucoup plus facile à maintenir.

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). Voici 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
}

Dans le cas où vous utilisez Java 8 et souhaitez avoir une approche de programmation plus fonctionnelle, vous pouvez définir un Functionqui gère le contrôle, puis vous pouvez le réutiliser et apply()chaque fois que cela est nécessaire.

En venant à la pratique, vous pouvez définir le Functioncomme

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

Ensuite, vous pouvez l'utiliser en appelant simplement la apply()méthode 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 Functionqui vérifie si le Stringest vide, puis le nier avec !.

Dans ce cas, le Functionressemblera à:

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

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

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

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

Avec Java 8 en option, 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 gérerez également les Strings composés d'espaces.

Vous pouvez utiliser StringUtils.isEmpty (), il en résultera vrai si la chaîne est nulle 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");
 }

aura pour résultat

str1 est nul ou vide

str2 est nul ou vide

Je conseillerais Guava ou Apache Commons en fonction de vos besoins réels. Vérifiez 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 vide
b est vide
c est vide
Google:
b est NullOrEmpty
c est NullOrEmpty

Si vous utilisez Spring Boot, le code ci-dessous fera le travail

StringUtils.hasLength(str)

Pour être complet: si vous utilisez déjà le framework Spring , les StringUtils fournissent la méthode

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

Renvoie: 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)

Renvoie: true si la chaîne n'est pas nulle, sa longueur est supérieure à 0 et ne contient pas d'espace blanc uniquement

Pour ignorer également les espaces blancs:

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

Si vous utilisez le framework Spring, vous pouvez utiliser la méthode:

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

Cette méthode accepte tout 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.

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

Pour vérifier si tous les attributs de chaîne d'un objet sont vides (au lieu d'utiliser! = Null sur tous les noms de champ suivant l'approche api de réflexion java

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

Cette méthode renverrait true si toutes les valeurs de champ String sont vides, elle retournerait false si une valeur est présente dans les attributs String

J'ai rencontré une situation où je dois vérifier que "null" (en tant que chaîne) doit être considéré comme vide. De plus, un espace blanc et un nul réel doivent renvoyer true. J'ai finalement choisi la fonction suivante ...

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

Si vous devez valider les paramètres de votre méthode, vous pouvez utiliser la méthode simple suivante

public class StringUtils {

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

}

Exemple:

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