Compruebe si una cadena no es nula y no está vacía

490

¿Cómo puedo verificar si una cadena no es nula y no está vacía?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}
Bernhard Barker
fuente
8
Probablemente debería usar PreparedStatementy tal en lugar de construir una consulta SQL mediante primitivas de concatenación de cadenas. Evita todo tipo de vulnerabilidades de inyección, mucho más fácil de leer, etc.
polygenelubricants
2
Puede crear una clase que verifique valores nulos u objetos nulos. Eso le ayudará a mejorar la capacidad de reutilización de .. stackoverflow.com/a/16833309/1490962
Bhushankumar Lilapara

Respuestas:

895

¿Qué pasa con isEmpty () ?

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

Asegúrese de usar las partes de &&en este orden, ya que Java no procederá a evaluar la segunda parte si la primera parte &&falla, asegurando así que no obtendrá una excepción de puntero nulo de str.isEmpty()si stres nulo.

Cuidado, solo está disponible desde Java SE 1.6. Tienes que consultar str.length() == 0las versiones anteriores.


Para ignorar también los espacios en blanco:

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

(ya que Java 11 str.trim().isEmpty()puede reducirse, str.isBlank()lo que también probará otros espacios en blanco Unicode)

Envuelto en una práctica función:

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

Se convierte en:

if( !empty( str ) )
Colin Hebert
fuente
80
Tenga en cuenta que isEmpty()parece requerir una instancia de String (no estática). Invocar esto en una referencia nula arrojará una NullPointerException.
James P.
38
O if (str! = Null &&! Str.trim (). IsEmpty ()), para ignorar los espacios en blanco.
PapaFreud
if ((txt.getText (). length ()) == 0) // obtiene el elemento del diseño
jruzafa
32
Recomiendo usar TextUtils.isEmpty(String)para verificar si la cadena está vacía o es nula. Agradable y corto. La clase TextUtils es parte del SDK de Android.
George Maisuradze
1
@ user1154390: a veces vale la pena usar explícitamente verdadero y falso para mayor claridad, pero cuando la condición devuelve verdadero para verdadero y falso para falso, su complejidad innecesaria. Simplemente di (str != null && str.length() > 0).
ToolmakerSteve
213

Use org.apache.commons.lang.StringUtils

Me gusta usar Apache commons-lang para este tipo de cosas, y especialmente la clase de utilidad StringUtils :

import org.apache.commons.lang.StringUtils;

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

if (StringUtils.isBlank(str)) {
    ...
} 
Romain Linsolas
fuente
17
¿no es Apache commons-lang una exageración si solo puedes usar isEmpty? Sólo curioso.
zengr
17
@zengr - no, porque seguramente también
usarías
2
@zengr De hecho, si solo usa isEmptyo isBlank, tal vez no sea útil incluir una biblioteca de terceros. Simplemente puede crear su propia clase de utilidad para proporcionar dicho método. Sin embargo, como explica Bozho, ¡el commons-langproyecto proporciona muchos métodos útiles!
Romain Linsolas
13
Porque StringUtils.isNotBlank(str)la comprobación nula también.
sdesciencelover
1
Si usa Spring Framework, esto YA podría estar incluido en los frascos del framework.
linuxunil
103

Solo agrego Android aquí:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}
phreakhead
fuente
1
@staticx, el método StringUtils cambió en Lang versión 2.0. Ya no recorta la secuencia Char. Esa funcionalidad está disponible en isBlank ().
Nick
50

Para agregar a @BJorn y @SeanPatrickFloyd La forma en que Guava hace esto es:

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

Commons Lang es más legible a veces, pero poco a poco he estado confiando más en la guayaba y, a veces, Commons Lang es confuso cuando se trata de isBlank()(como en el espacio en blanco o no).

La versión de Guava de Commons Lang isBlanksería:

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

Diré que el código que no permite ""(vacío) Y null es sospechoso y potencialmente defectuoso, ya que probablemente no maneja todos los casos en los que no está permitido tener nullsentido (aunque para SQL puedo entender que SQL / HQL es extraño '').

Adam Gent
fuente
segunda guayaba también. La guayaba sigue una convención de clases estáticas plurales. Para String, pruebe Strings para métodos estáticos como isNullOrEmpty (str).
Thupten
34
str != null && str.length() != 0

alternativamente

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

o

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

Nota: La segunda verificación (primera y segunda alternativa) asume que str no es nulo. ¡Está bien solo porque la primera verificación está haciendo eso (y Java no hace la segunda verificación si la primera es falsa)!

IMPORTANTE: NO use == para la igualdad de cadena. == comprueba que el puntero es igual, no el valor. ¡Dos cadenas pueden estar en diferentes direcciones de memoria (dos instancias) pero tienen el mismo valor!

helios
fuente
gracias ... str.length () funcionó para mí. Mi caso fue que obtengo los valores de la matriz después de consultar desde la base de datos. Incluso si los datos estaban vacíos, cuando hice la longitud de la cadena estaba dando una longitud de "1". Muy extraño pero gracias por mostrarme esto.
arn-arn
Eso tiene que ver con lo interno de la base de datos. O es un campo char en lugar de un campo varchar (por lo que se rellena con espacios) o la base de datos no le gustan las cadenas vacías. Supongo que lo mejor es preprocesar esos valores después / durante la consulta (en el acceso a los datos más adelante de la aplicación).
helios
Creo que verificar la longitud es mejor que 'igual' porque es una operación O (1) ya que la longitud se almacena en caché en el caso de String.
bluelurker
26

Casi todas las bibliotecas que conozco definen una clase de utilidad llamada StringUtils, StringUtilo StringHelper, y generalmente incluyen el método que está buscando.

Mi favorito personal es Apache Commons / Lang , donde en la clase StringUtils , obtienes ambos

  1. StringUtils.isEmpty (String) y el
  2. StringUtils.isBlank (String) método

(La primera verifica si una cadena es nula o vacía, la segunda verifica si es nula, vacía o solo en blanco)

Hay clases de utilidad similares en Spring, Wicket y muchas otras bibliotecas. Si no usa bibliotecas externas, es posible que desee introducir una clase StringUtils en su propio proyecto.


Actualización: han pasado muchos años, y en estos días recomendaría usar el método de GuavaStrings.isNullOrEmpty(string) .

Sean Patrick Floyd
fuente
Me gustaría preguntar por qué recomienda ahora esto. Me gustaría saber si hay una diferencia entre Strings.isNullOrEmpty (string) y StringUtils.isEmpty (String)
vicangel
Los métodos de @vicangel Apache Commons están llenos de suposiciones y cosas que no pedí. Con Guava, obtengo exactamente lo que pedí y nada más ni menos
Sean Patrick Floyd el
24

Esto funciona para mi:

import com.google.common.base.Strings;

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

Devuelve verdadero si la cadena dada es nula o es la cadena vacía.

Considere normalizar sus referencias de cadena con nullToEmpty. Si lo hace, puede usar String.isEmpty () en lugar de este método, y tampoco necesitará formas especiales de métodos nulos seguros como String.toUpperCase. O, si desea normalizar "en la otra dirección", convirtiendo cadenas vacías a nulas, puede usar emptyToNull.

Javatar
fuente
2
<dependency> <groupId> com.google.guava </groupId> <artifactId> guava </artifactId> <version> 12.0 </version> </dependency>
Junchen Liu el
11

Qué tal si:

if(str!= null && str.length() != 0 )
codictorio
fuente
lanza NullPointerException si str es NULL.
Mindwin
13
@Mindwin Eso no es cierto. No ejecutará el código a la derecha de &&if str == null, evitando así una NullPointerException. (Fuente: acabo de probar)
Zach Lysobey
Estoy corregido. No borrará el comentario por vergüenza, por lo que Zach y GI Joe no se quedarán con respuestas colgando de la nada. Lolz PERO es bueno saber que este salto puede causar fallas lógicas si haces algo más que solo probar cosas y devolver un valor booleano en las llamadas al método omitido.
Mindwin
2
@Mindwin Es bueno saber cómo funciona realmente el lenguaje que está utilizando. Si no comprende la evaluación de cortocircuito, no la use o, mejor aún, aprenda sobre ella.
Marqués de Lorne
7

Utilice el método isNotBlank de Apache StringUtils como

StringUtils.isNotBlank(str)

Volverá verdadero solo si el str no es nulo y no está vacío.

Un puntero nulo
fuente
en realidad, si str es nulo aquí, la declaración devuelve verdadero
Alexandr el
Eso es verdad, mi mal !! En cambio, el uso de Apache-commons 'StringUtils.isNotEmpty (str) haría el trabajo.
Un puntero nulo
6

Deberías usar org.apache.commons.lang3.StringUtils.isNotBlank()o org.apache.commons.lang3.StringUtils.isNotEmpty. La decisión entre estos dos se basa en lo que realmente desea verificar.

Los isNotBlank () comprueba que el parámetro de entrada es:

  • no nulo,
  • no la cadena vacía ("")
  • no es una secuencia de espacios en blanco ("")

El isNotEmpty () comprueba sólo que el parámetro de entrada es

  • no nulo
  • no la cadena vacía ("")
gprasant
fuente
6

Devuelve verdadero o falso según la entrada

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

Si no desea incluir toda la biblioteca; solo incluye el código que quieras de él. Tendrás que mantenerlo tú mismo; pero es una función bastante sencilla. Aquí se copia 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;
}
Tom
fuente
5

Es un poco tarde, pero aquí hay un estilo funcional de verificación:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });
piloto
fuente
1
Recomendaría usar un mapa para el recorte, por ejemplo: Opcional.ofNullable (str) .map (String :: trim) .filter (String :: isEmpty) .ifPresent (this :: setStringMethod);
bachph
5

Hay un nuevo método en : String#isBlank

Devuelve verdadero si la cadena está vacía o contiene solo puntos de código de espacio en blanco, de lo contrario es falso.

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

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

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

Esto podría combinarse Optionalpara verificar si la cadena es nula o está vacía

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

Cadena # isBlank

Anton Balaniuc
fuente
3

prueba es igual a una cadena vacía y nula en el mismo condicional:

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

No lanza NullPointerExceptionsi str es nulo, ya que Object.equals()devuelve falso si arg es null.

la otra construcción str.equals("")arrojaría lo temido NullPointerException. Algunos podrían considerar una forma incorrecta usando un literal de cadena como el objeto sobre el cual equals()se llama pero hace el trabajo.

Compruebe también esta respuesta: https://stackoverflow.com/a/531825/1532705

Mindwin
fuente
1
Entonces, ¿por qué agregar código nunca alcanzado str != null. !"".equals(str)ya hace el trabajo
amdev
3

Solución simple :

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

Como Seanizer dijo anteriormente, Apache StringUtils es fantástico para esto, si incluyeses guayaba deberías hacer lo siguiente;

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

¿Puedo recomendar también que consulte las columnas en su conjunto de resultados por nombre en lugar de por índice, esto hará que su código sea mucho más fácil de mantener.

BjornS
fuente
Sin embargo, no es necesario usar apache commons de guava, también hay una clase Strings en guava: guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/…
Sean Patrick Floyd
Agregué algunos ejemplos de guayaba para usuarios principiantes de Java que llegan a esta pregunta: stackoverflow.com/a/13146903/318174 .
Adam Gent
2

Hice mi propia función de utilidad para verificar varias cadenas a la vez, en lugar de tener una instrucción if llena de if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Esta es la función:

public class StringUtils{

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

        return true;
    }   

}

así que simplemente puedo escribir:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}
WKS
fuente
2
Sería mejor usar la firma: areSet(String... strings)luego se puede invocar sin la creación de la matriz:if(!StringUtils.areSet(firstName, lastName, address))
weston
2

En caso de que esté utilizando Java 8 y desee tener un enfoque de Programación más funcional, puede definir uno Functionque administre el control y luego puede reutilizarlo y apply()cuando sea necesario.

Al practicar, puedes definir Functioncomo

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

Luego, puede usarlo simplemente llamando al apply()método como:

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

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

Si lo prefiere, puede definir un Functionque compruebe si Stringestá vacío y luego negarlo !.

En este caso, Functionse verá así:

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

Luego, puede usarlo simplemente llamando al apply()método como:

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

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
aracnoideo
fuente
Así es como me gusta hacerlo, cuando estoy preocupado por el costo del rendimiento o los efectos secundarios, y no hay importaciones fácilmente disponibles.
david.pfx
2

Con Java 8 Opcional puedes hacer:

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

En esta expresión, manejarás Strings que también consisten en espacios.

Johnny
fuente
1

Puede usar StringUtils.isEmpty (), resultará verdadero si la cadena es nula o vacía.

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

resultará en

str1 es nulo o está vacío

str2 es nulo o está vacío

Vivek Vermani
fuente
O simplemente useisNotBlank
Brian
1

Aconsejaría a Guava o Apache Commons según su necesidad real. Verifique los diferentes comportamientos en mi código de ejemplo:

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

Resultado:
Apache:
a está en blanco
b está en blanco
c está en blanco
Google:
b es NullOrEmpty
c es NullOrEmpty

BlondCode
fuente
1

Si está utilizando Spring Boot, el siguiente código hará el trabajo

StringUtils.hasLength(str)
Avinash
fuente
0

Para completar: si ya está utilizando Spring Framework , StringUtils proporciona el método

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

Devuelve: verdadero si la cadena no es nula y tiene longitud

así como el método

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

Devuelve: verdadero si la cadena no es nula, su longitud es mayor que 0 y no contiene solo espacios en blanco

l00tr
fuente
podemos usar el método StringUtils.isEmpty (param).
Supun Dharmarathne
0

Simplemente, para ignorar el espacio en blanco también:

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

Si usa Spring Framework, puede usar el método:

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

Este método acepta cualquier objeto como argumento, comparándolo con una cadena nula y vacía. Como consecuencia, este método nunca devolverá verdadero para un objeto no String no nulo.

Taras Melnyk
fuente
1
Tenga en cuenta que la documentación para los StringUtilsestados explícitamente "Principalmente para uso interno dentro del marco; considere Apache's Commons Lang para un conjunto más completo de utilidades de cadena".
Fredrik Jonsén
0

La mejor manera de manejar nulo en la cadena es,

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

En breve,

str.length()>0 && !str.equalsIgnoreCase("null")
Bhanu Prakash Pasupula
fuente
0

Para verificar si todos los atributos de cadena en un objeto están vacíos (en lugar de usar! = Nulo en todos los nombres de campo siguiendo el enfoque de la API de reflexión de 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;
}

Este método devolvería verdadero si todos los valores del campo String están en blanco, devolvería falso si alguno de los valores está presente en los atributos String

Lokeshkumar R
fuente
0

Me he encontrado con una situación en la que debo comprobar que "nulo" (como una cadena) debe considerarse vacío. También el espacio en blanco y un nulo real deben devolver verdadero. Finalmente me decidí por la siguiente función ...

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

En caso de que necesite validar los parámetros de su método, puede usar el método simple siguiente

public class StringUtils {

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

}

Ejemplo:

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