Vérifier si une chaîne n'est ni nulle ni vide
Comment puis-je vérifier si une chaîne n'est ni nulle ni vide?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
Qu'en est-il isEmpty () ?
if(str != null && !str.isEmpty())
Veillez à 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. Ainsi, vous ne recevrez pas d'exception de pointeur null de str.isEmpty() si str est null.
Attention, il n'est disponible que depuis Java SE 1.6. Vous devez vérifier str.length() == 0 sur les 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 particulièrement la classe StringUtils utility:
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 façon de faire ceci est la suivante:
Strings.nullToEmpty(str).isEmpty();
// or
Strings.isNullOrEmpty(str);
Commons Lang est parfois plus lisible, mais je m'appuie lentement sur Guava et parfois sur Commons Lang est déroutant lorsqu'il est question de isBlank() (comme dans un espace ou non).
La version de Commons Lang isBlank de Guava serait:
Strings.nullToEmpty(str).trim().isEmpty()
Je dirai que le code qui ne permet pas à "" (vide)ETnull est suspect et potentiellement bogué dans la mesure où il ne gère probablement pas tous les cas où n'autorisant pas null est logique (bien que je puisse comprendre pour SQL comme SQL/HQL est bizarre sur '').
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 est faite (et Java ne fait pas la deuxième vérification si la première est fausse)!
IMPORTANT: NE PAS utiliser == 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!
Cela fonctionne pour moi:
import com.google.common.base.Strings;
if (!Strings.isNullOrEmpty(myString)) {
return myString;
}
Renvoie true si la chaîne donnée est null ou est la chaîne vide.
Pensez à normaliser vos références de chaîne avec nullToEmpty. Si vous Pour ce faire, vous pouvez utiliser String.isEmpty () à la place de cette méthode, mais pas besoin de formes spéciales de méthodes null-safe comme String.toUpperCase non plus. Ou, si vous souhaitez normaliser "dans l'autre sens", " convertir des chaînes vides en null, vous pouvez utiliser emptyToNull.
Presque toutes les bibliothèques que je connais définissent une classe d’utilitaires appelée StringUtils, StringUtil ou StringHelper et elles incluent généralement la méthode que vous recherchez.
Mon favori personnel est Apache Commons/Lang , où dans le StringUtils class, vous obtenez les deux
(Le premier vérifie si une chaîne est nulle ou vide, le second vérifie si elle est vide, vide ou uniquement)
Il existe des classes d'utilitaires similaires dans Spring, Wicket et beaucoup d'autres bibliothèques. Si vous n'utilisez pas de bibliothèques externes, vous pouvez introduire une classe StringUtils dans votre propre projet . </ S>
Mise à jour: de nombreuses années ont passé et je recommande ces jours-ci d'utiliser la méthode Guava 's Strings.isNullOrEmpty(string) .
Que diriez-vous:
if(str!= null && str.length() != 0 )
Utilisez la méthode isNotBlank de Apache StringUtils comme
StringUtils.isNotBlank(str)
Il ne retournera vrai que si str n'est pas nul 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 vérifier.
Le 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 d'espacement ("")
Le isNotEmpty () vérifie seulement que le paramètre d’entrée est
- pas nul
- pas la chaîne vide ("")
Si vous ne voulez pas inclure toute la bibliothèque; incluez simplement le code que vous voulez en tirer. Vous devrez le maintenir vous-même; mais c'est une fonction assez simple. 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;
}
C'est un peu trop tard, mais voici un style de vérification fonctionnel:
Optional.ofNullable(str)
.filter(s -> !(s.trim().isEmpty()))
.ifPresent(result -> {
// your query setup goes here
});
Renvoie vrai ou faux en fonction de 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
Renvoie true si la chaîne est vide ou ne contient que des points de code d'espaces, sinon false.
jshell> "".isBlank()
$7 ==> true
jshell> " ".isBlank()
$8 ==> true
jshell> " ! ".isBlank()
$9 ==> false
Ceci 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);
test est égal à avec une chaîne vide et null dans la même condition:
if(!"".equals(str) && str != null) {
// do stuff.
}
Ne lance pas NullPointerException si str est null, puisque Object.equals() renvoie false si arg est null.
l'autre construction str.equals("") jetterait le redouté NullPointerException. Certains pourraient considérer une mauvaise forme en utilisant un littéral String comme objet sur lequel equals() est appelé, mais cela fait le travail.
Cochez également cette réponse: https://stackoverflow.com/a/531825/1532705
Solution simple:
private boolean stringNotEmptyOrNull(String st) {
return st != null && !st.isEmpty();
}
Comme dit seanizer ci-dessus, Apache StringUtils est fantastique pour cela. Si vous incluiez de 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 faire référence aux colonnes de votre jeu de résultats par nom plutôt que par index, cela rendra votre code beaucoup plus facile à gérer.
J'ai créé ma propre fonction utilitaire pour vérifier plusieurs chaînes à la fois, plutôt que d'avoir une instruction if remplie 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;
}
}
pour que je puisse simplement écrire:
if(!StringUtils.areSet(firstName,lastName,address)
{
//do something
}
Si vous utilisez Java 8 et souhaitez adopter une approche de programmation plus fonctionnelle, vous pouvez définir une variable Function qui gère le contrôle. Vous pouvez ensuite la réutiliser ainsi que apply() chaque fois que nécessaire.
En venant à la pratique, vous pouvez définir la Function comme
Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)
Ensuite, vous pouvez l’utiliser en appelant simplement la méthode apply() en tant que:
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 une Function qui vérifie si la String est vide, puis l'annuler avec !.
Dans ce cas, la Function ressemblera à:
Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)
Ensuite, vous pouvez l’utiliser en appelant simplement la méthode apply() en tant que:
String emptyString = "";
!isEmpty.apply(emptyString); // this will return false
String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
Vous pouvez utiliser StringUtils.isEmpty (). Le résultat sera 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");
}
aura pour résultat
str1 est null 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)
Résultats: 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)
Résultats: true si la chaîne n'est pas nulle, sa longueur est supérieure à 0 et ne contient pas uniquement d'espaces
Pour vérifier si tous les attributs de chaîne d'un objet sont vides (au lieu d'utiliser! = Null pour tous les noms de champs suivant l'approche de l'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 du champ String sont vides. Elle renverrait false si une seule valeur est présente dans les attributs String.
Le meilleur moyen de gérer null dans la chaîne est,
str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()
En bref,
str.length()>0 && !str.equalsIgnoreCase("null")
Simplement, ignorer également les espaces:
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 n'importe quel objet en tant qu'argument, en la comparant à null et à la chaîne vide. En conséquence, cette méthode ne renverra jamais la valeur true pour un objet non-null non-String.
J'ai rencontré une situation dans laquelle je dois vérifier que "null" (en tant que chaîne) doit être considéré comme vide. De plus, les espaces et un null doivent renvoyer la valeur true. J'ai finalement choisi la fonction suivante ...
public boolean isEmpty(String testString) {
return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}
Avec Java 8 Facultatif 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 allez manipuler String qui contient également des espaces.