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 */
}
/* ... */
}
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 */
}
/* ... */
}
Réponses:
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 str
est nul.
Attention, il n'est disponible que depuis Java SE 1.6. Vous devez vérifier str.length() == 0
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 ) )
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.
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.
(str != null && str.length() > 0)
.
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)) {
...
}
isEmpty
ou 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-lang
projet propose de nombreuses méthodes utiles!
StringUtils.isNotBlank(str)
que la vérification nulle aussi.
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 isBlank
serait:
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' null
interdiction 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
, StringUtil
ou 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 )
&&
if str == null, empêchant ainsi une NullPointerException. (Source: je viens d'essayer)
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:
Le isNotEmpty () vérifie seulement que le paramètre d'entrée est
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 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 à une chaîne vide et null dans le même conditionnel:
if(!"".equals(str) && str != null) {
// do stuff.
}
Ne lance pas NullPointerException
si 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
str != null
. !"".equals(str)
font déjà le travail
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
}
areSet(String... strings)
peut alors être invoqué sans la création du tableau:if(!StringUtils.areSet(firstName, lastName, address))
Dans le cas où vous utilisez Java 8 et souhaitez avoir une approche de programmation plus fonctionnelle, vous pouvez définir un Function
qui 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 Function
comme
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 Function
qui vérifie si le String
est vide, puis le nier avec !
.
Dans ce cas, le Function
ressemblera à:
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 String
s 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
isNotBlank
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
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.
StringUtils
explicitement 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."
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;
}
PreparedStatement
and 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.