Vérifiez si une chaîne n'est pas nulle et non vide


490

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 */
    }
    /* ... */
}

8
Vous devriez probablement utiliser PreparedStatementand such au lieu de construire une requête SQL par des primitives de concaténation de chaînes. Évite toutes sortes de vulnérabilités d'injection, beaucoup plus lisibles, etc.
polygenelubricants

2
Vous pouvez créer une classe qui vérifiera les valeurs nulles ou l'objet nul. Cela vous aidera à améliorer la réutilisation capacité .. stackoverflow.com/a/16833309/1490962
Bhushankumar Lilapara

Réponses:


895

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

80
Notez que cela isEmpty()semble nécessiter une instance de chaîne (non statique). L'invocation de ceci sur une référence null lèvera une NullPointerException.
James P.

38
Ou si (str! = Null &&! Str.trim (). IsEmpty ()), pour ignorer les espaces.
PapaFreud

if ((txt.getText (). length ()) == 0) // récupère l'élément de la mise en page
jruzafa

32
Je recommanderais d'utiliser TextUtils.isEmpty(String)pour vérifier si la chaîne est vide ou nulle. Agréable et court. La classe TextUtils fait partie du SDK Android.
George Maisuradze

1
@ user1154390: parfois cela vaut la peine d'utiliser explicitement true et false pour plus de clarté, mais lorsque la condition retourne true pour true et false pour false, sa complexité inutile Dites simplement (str != null && str.length() > 0).
ToolmakerSteve

213

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

17
Apache commons-lang n'est-il pas exagéré si vous pouvez simplement utiliser isEmpty? Juste curieux.
zengr

17
@zengr - non, car vous utiliseriez certainement d'autres choses aussi :)
Bozho

2
@zengr En effet, si vous utilisez uniquement isEmptyou isBlank, il n'est peut-être pas utile d'inclure une bibliothèque tierce. Vous pouvez simplement créer votre propre classe d'utilitaires pour fournir une telle méthode. Cependant, comme l'explique Bozho, le commons-langprojet propose de nombreuses méthodes utiles!
Romain Linsolas

13
Parce StringUtils.isNotBlank(str)que la vérification nulle aussi.
sdesciencelover

1
Si vous utilisez Spring Framework, cela pourrait déjà être inclus dans les pots du framework.
linuxunil

103

Il suffit d'ajouter Android ici:

import android.text.TextUtils;

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

1
@staticx, la méthode StringUtils a changé dans Lang version 2.0. Il ne supprime plus la CharSequence. Cette fonctionnalité est disponible dans isBlank ().
Nick

50

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 '').


deuxième goyave aussi. La goyave suit une convention de plusieurs classes statiques. Pour String, essayez Strings pour les méthodes statiques comme isNullOrEmpty (str).
Jeudi

34
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!


merci ... le str.length () a fonctionné pour moi. Mon cas était que j'obtiens les valeurs du tableau après avoir interrogé la base de données. Même si les données étaient vides, quand j'ai fait la longueur de str, cela donnait une longueur de "1". Très étrange mais merci de me l'avoir montré.
arn-arn

Cela a à voir avec les éléments internes de la base de données. Soit c'est un champ char au lieu d'un champ varchar (donc il remplit avec des espaces) ou la base de données n'aime pas les chaînes vides. Je suppose que le mieux est de prétraiter ces valeurs après / pendant la requête (dans l'accès aux données plus tard de l'application).
helios

Je pense que la vérification de la longueur est meilleure que «égale» car c'est une opération O (1) car la longueur est mise en cache en cas de chaîne.
bluelurker

26

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

  1. StringUtils.isEmpty (String) et le
  2. StringUtils.isBlank (String) Méthode

(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) .


Je voudrais demander pourquoi vous recommandez maintenant ceci? Je voudrais savoir s'il y a une différence entre les Strings.isNullOrEmpty (string) et StringUtils.isEmpty (String)
vicangel

Les méthodes @vicangel Apache Commons sont pleines d'hypothèses et de choses que je n'ai pas demandées. Avec Goyave, j'obtiens exactement ce que j'ai demandé et rien de plus ou moins
Sean Patrick Floyd

24

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.


2
<dependency> <groupId> com.google.guava </groupId> <artifactId> goyave </artifactId> <version> 12.0 </version> </dependency>
Junchen Liu

11

Que diriez-vous:

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

lève NullPointerException si str est NULL.
Mindwin

13
@Mindwin Ce n'est pas vrai. Il n'exécutera pas le code à droite de &&if str == null, empêchant ainsi une NullPointerException. (Source: je viens d'essayer)
Zach Lysobey

Je me suis trompé. Ne supprimera pas le commentaire par honte, donc Zach et GI Joe ne se retrouveront pas avec des réponses suspendues de nulle part. Lolz. MAIS il est bon de savoir que ce saut peut provoquer des échecs logiques si vous faites autre chose que de simplement tester des choses et renvoyer un booléen sur les appels de méthode ignorés.
Mindwin

2
@Mindwin C'est agréable de savoir comment fonctionne réellement la langue que vous utilisez. Si vous ne comprenez pas l'évaluation des courts-circuits, ne l'utilisez pas ou, mieux encore, apprenez-en plus.
Marquis de Lorne

7

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.


en fait, si str est nul ici, la déclaration renvoie vrai
Alexandr

C'est vrai, mon mauvais !! À la place, utiliser StringUtils.isNotEmpty (str) d'apache-commons ferait le travail.
A Null Pointer

6

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

6

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

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

5

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

5

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

1
Je recommanderais d'utiliser une carte pour le trim, par exemple: Optional.ofNullable (str) .map (String :: trim) .filter (String :: isEmpty) .ifPresent (this :: setStringMethod);
bachph

5

Il existe une nouvelle méthode : 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


3

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


1
alors pourquoi ajouter du code jamais atteint str != null. !"".equals(str)font déjà le travail
amdev

3

Solution simple:

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

2

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.


Pas besoin d'utiliser apache commons de goyave cependant, il y a aussi une classe Strings en goyave: guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/…
Sean Patrick Floyd

J'ai ajouté quelques exemples de Guava pour les utilisateurs Java novices qui se posent sur cette question: stackoverflow.com/a/13146903/318174 .
Adam Gent

2

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
}

2
Serait plus agréable d'utiliser la signature: areSet(String... strings)peut alors être invoqué sans la création du tableau:if(!StringUtils.areSet(firstName, lastName, address))
weston

2

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

C'est ainsi que j'aime le faire, lorsque je m'inquiète du coût des performances ou des effets secondaires, et qu'aucune importation n'est à portée de main.
david.pfx

2

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.


1

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


Ou utilisez simplementisNotBlank
Brian

1

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


1

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

StringUtils.hasLength(str)

0

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


nous pouvons utiliser la méthode StringUtils.isEmpty (param).
Supun Dharmarathne

0

Pour ignorer également les espaces blancs:

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

0

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.


1
Notez que la documentation pour StringUtilsexplicitement indique "Principalement pour un usage interne dans le cadre; considérez le Langage commun d'Apache pour une suite plus complète d'utilitaires String."
Fredrik Jonsén

0

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

0

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


0

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

0

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;
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.