¿Cómo verificar si mi cadena es igual a nula?


172

Quiero realizar alguna acción SOLO SI mi cadena tiene un valor significativo. Entonces, intenté esto.

if (!myString.equals("")) {
doSomething
}

y esto

if (!myString.equals(null)) {
doSomething
}

y esto

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

y esto

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

y esto

if ( myString.length()>0) {
doSomething
}

Y en todos los casos mi programa doSomethinga pesar del hecho de que mi cadena está VACÍA. Es igual a null. Entonces, ¿qué hay de malo en eso?

ADICIONAL:

Encontré la razón del problema. La variable fue declarada como una cadena y, como consecuencia, nullasignada a esta variable se transformó en "null"! Entonces, if (!myString.equals("null"))funciona.


2
nullno tiene ningún método, así que tampoco equals(). Si myStringfuera así null, ¿cómo invocarías un método? :)
BalusC

1
¿Puedo sugerirle que esté System.out.println(myString)inmediatamente antes del bloque if para que pueda ver qué hay allí?
Michael Myers

1
¿Cómo sabes que "es igual a null"?
Richard JP Le Guen

66
nullasignado a esta variable se transformó en "null"- esta es una idea terrible. Intenta cambiar este diseño si es posible.
polygenelubricants

8
Yuck: no creo que comprobar si (! MyString.equals ("null")) sea la mejor solución. Sospecho que la mayoría consideraría que el punto en el que la cadena "nula" se asignó a myString es un error.
Bert F

Respuestas:


231
if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Como comentario adicional, debe tener en cuenta este término en el equalscontrato:

De Object.equals(Object):

Para cualquier valor de referencia no nulo x, x.equals(null)debería return false.

La forma de comparar nulles usar x == nully x != null.

Por otra parte, x.fieldy x.method()tira NullPointerExceptionsi x == null.


2
Debe hacer una verificación de longitud en lugar de iguales para fines de eficiencia. Consulte este enlace hanuska.blogspot.com/2006/08/empty-string.html
CoolBeans

77
Yo diría que deberías hacerlo en s.isEmpty()lugar de s.length() == 0por legibilidad. Cualquier diferencia en el rendimiento es insignificante. Estoy de acuerdo en que s.equals("")es terrible.
polygenelubricants

66
Estoy de acuerdo con la legibilidad. Depende de si estamos usando Java 5 vs Java 6 ya que isEmpty () solo está en Java 6.
CoolBeans

@CoolBeans: ¡Buen comentario! ¡No me había dado cuenta de eso! Llego un poco tarde a la fiesta de Java =)
polygenelubricants

26

Si myStringes así null, entonces llamar myString.equals(null)o myString.equals("")fallará con a NullPointerException. No puede llamar a ningún método de instancia en una variable nula.

Compruebe nulo primero así:

if (myString != null && !myString.equals("")) {
    //do something
}

Esto hace uso de la evaluación de cortocircuito para no intentar .equalssi myStringfalla la verificación nula.


+1 para cortocircuito; Es esencial que la expresión funcione. Sin embargo, realmente debería usar en .isEmpty()lugar de .equals("").
polygenelubricants

1
De acuerdo, tenía la intención de dejar mi comentario en esta publicación. jajaja -> "Debe realizar una verificación de longitud en lugar de iguales para fines de eficiencia. Consulte este enlace hanuska.blogspot.com/2006/08/empty-string.html"
CoolBeans

@CoolBeans: Claro, y con Java 6 incluso podrías hacerlo myString.isEmpty(). Pero en este nivel, la legibilidad supera a la optimización, y las personas podrían estar más acostumbradas a la lectura myString.equals(""). (O posiblemente no.)
Michael Myers

20

Apache commons StringUtils.isNotEmptyes el mejor camino a seguir.


13

Si myString es de hecho nulo, cualquier llamada a la referencia fallará con una excepción de puntero nulo (NPE). Desde java 6, use #isEmpty en lugar de la verificación de longitud (en cualquier caso, NUNCA cree una nueva cadena vacía con la verificación).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Por cierto, si se compara con los literales de cadena como lo hace, invertiría la declaración para no tener que tener una comprobación nula, es decir,

if ("some string to check".equals(myString)){
  doSomething();
} 

en vez de :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}

1
Buen punto, pero los últimos dos si no son equivalentes. Con myString = "abc", el medio no llama a doSomething pero el tercero sí.
rimsky

@rimsky eso está arreglado
pavi2410

7

TRABAJANDO !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}

6

Debe verificar que el myStringobjeto es null:

if (myString != null) {
    doSomething
}

5

Si su cadena es nula, las llamadas como esta deberían arrojar una NullReferenceException:

myString.equals (nulo)

Pero de todos modos, creo que un método como este es lo que quieres:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

Luego, en su código, puede hacer cosas como esta:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

5

Recomiendo usar una utilidad existente o crear su propio método:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

Luego, úsalo cuando lo necesites:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Como se señaló anteriormente, el || y && operadores de corto circuito. Eso significa que tan pronto como puedan determinar su valor, se detienen. Entonces, si (string == null) es verdadero, no es necesario evaluar la parte de longitud, ya que la expresión siempre sería verdadera. Del mismo modo con &&, donde si el lado izquierdo es falso, la expresión siempre es falsa y no es necesario evaluarla más.

Como nota adicional, usar longitud es generalmente una mejor idea que usar .equals. El rendimiento es ligeramente mejor (no mucho) y no requiere la creación de objetos (aunque la mayoría de los compiladores pueden optimizar esto).


4

Tratar,

myString!=null && myString.length()>0

esto no es posible si myString es nulo
hsmit

44
esto es bastante posible cuando myString es nulo. Debe saber que cuando la parte izquierda de && falla, la expresión correcta no se evaluará en absoluto ...
bragboy


4

Cada vez que tengo que lidiar con cadenas (casi cada vez) me detengo y me pregunto cuál es realmente la forma más rápida de verificar si hay una cadena vacía. Por supuesto, la comprobación string.Length == 0 debería ser la más rápida ya que Length es una propiedad y no debería haber ningún otro procesamiento que no sea recuperar el valor de la propiedad. Pero luego me pregunto, ¿por qué hay una cadena vacía? Debería ser más rápido verificar String. Vacío que por longitud, me digo. Bueno, finalmente decidí probarlo. Codifiqué una pequeña aplicación de la Consola de Windows que me dice cuánto tiempo lleva hacer una determinada verificación de 10 millones de repeticiones. Verifiqué 3 cadenas diferentes: una cadena NULL, una cadena vacía y una cadena "". Utilicé 5 métodos diferentes: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null || str == "", str == nulo || str.

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

De acuerdo con estos resultados, la verificación promedio str == nulles la más rápida, pero puede que no siempre produzca lo que estamos buscando. if str = String.Emptyo str = ""da como resultado falso. Luego tienes 2 que están empatados en segundo lugar: String.IsNullOrEmpty()y str == null || str.length == 0. Como se String.IsNullOrEmpty()ve mejor y es más fácil (y más rápido) de escribir, recomendaría usarlo sobre la otra solución.


3

Haría algo como esto:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");
  • La prueba de nulos comprueba si myString contiene una instancia de String.
  • length () devuelve la longitud y es equivalente a igual a "(").
  • Comprobar si myString es nulo primero evitará una NullPointerException.

3

He estado usando StringUtil.isBlank(string)

Comprueba si una cadena está en blanco: nulo, vacío o solo espacio en blanco.

Este es el mejor hasta ahora.

Aquí está el método original de los documentos

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 

2

Esto debería funcionar:

if (myString != null && !myString.equals(""))
    doSomething
}

De lo contrario, es probable que myString tenga un valor que no espera. Intente imprimirlo así:

System.out.println("+" + myString + "+");

El uso de los símbolos '+' para rodear la cadena le mostrará si hay un espacio en blanco adicional que no está contando.


2

if(str.isEmpty() || str==null){ do whatever you want }


3
isEmpty se invierte ... si llama al método en un objeto nulo, obtiene NPE
Brian

Si la cadena es nula, obtiene una excepción de puntero nulo, incluso antes de comprobar que es nula. ¡Este código nunca debe usarse!
gil.fernandes

2

Bien, así es como funcionan los tipos de datos en Java. (Tienes que disculpar mi inglés, soy un problema. No estoy usando el vocabulario correcto. Debes diferenciar entre dos. Los tipos de datos básicos y los tipos de datos normales. Los tipos de datos básicos constituyen prácticamente todo lo que existe. Por ejemplo, hay son todos números, caracteres, booleanos, etc. Los tipos de datos normales o los tipos de datos complejos son todo lo demás. Una cadena es una matriz de caracteres, por lo tanto, un tipo de datos complejo.

Cada variable que crea es en realidad un puntero sobre el valor en su memoria. Por ejemplo:

String s = new String("This is just a test");

la variable "s" NO contiene una cadena. Es un puntero. Este puntero apunta a la variable en su memoria. Cuando llamas System.out.println(anyObject), se llama al toString()método de ese objeto. Si no se anula toStringdesde Object, imprimirá el puntero. Por ejemplo:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

Todo detrás de la "@" es el puntero. Esto solo funciona para tipos de datos complejos. Los tipos de datos primitivos se guardan DIRECTAMENTE en su puntero. Entonces, en realidad no hay un puntero y los valores se almacenan directamente.

Por ejemplo:

int i = 123;

NO almaceno un puntero en este caso. Guardaré el valor entero 123 (en byte ofc).

Bien, entonces volvamos al ==operador. Siempre compara el puntero y no el contenido guardado en la posición del puntero en la memoria.

Ejemplo:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

Estas dos cadenas tienen un puntero diferente. Sin embargo, String.equals (String other) compara el contenido. Puede comparar tipos de datos primitivos con el operador '==' porque el puntero de dos objetos diferentes con el mismo contenido es igual.

Nulo significaría que el puntero está vacío. Un tipo de datos primitivo vacío por defecto es 0 (para números). Sin embargo, nulo para cualquier objeto complejo significa que ese objeto no existe.

Saludos


2

Para mí, la mejor comprobación si una cadena tiene algún contenido significativo en Java es esta:

string != null && !string.trim().isEmpty()

Primero verifica si la cadena nulldebe evitarse NullPointerExceptiony luego recorta todos los caracteres de espacio para evitar verificar cadenas que solo tienen espacios en blanco y finalmente verifica si la cadena recortada no está vacía, es decir, tiene una longitud 0.


1

Tuve este problema en Android y lo uso de esta manera (Trabaja para mí):

String test = null;
if(test == "null"){
// Do work
}

Pero en el código Java uso:

String test = null;
if(test == null){
// Do work
}

Y:

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}


1

En Android puede verificar esto con el método de utilidad isEmptydesde TextUtils,

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

isEmpty(CharSequence str)El método verifica tanto la condición, nullcomo la longitud.


1

Yo siempre uso así:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

o puedes copiar esto a tu proyecto:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

y solo llámalo así:

boolean b = isEmptyOrNull(yourString);

devolverá verdadero si está vacío o nulo.
b=truesi está vacío o nulo

o puede usar try catch and catch cuando es nulo.


0

Creo que myString no es una cadena sino una matriz de cadenas. Aquí está lo que tú necesitas hacer:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}

Mi código es para procesar. El procesamiento es un lenguaje de programación basado en Java. Más información sobre join: processing.org/reference/join_.html .
imitar

0

Puede verificar una cadena igual a nula usando esto:

String Test = null;
(Test+"").compareTo("null")

Si el resultado es 0, entonces (Prueba + "") = "nulo".


esto solo crea una cadena innecesaria
svarog

0

Intenté la mayoría de los ejemplos dados anteriormente para un nulo en una aplicación de Android que estaba construyendo y TODO FALLÓ. Entonces se me ocurrió una solución que funcionó en cualquier momento para mí.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

Así que simplemente concatene una cadena vacía como lo hice anteriormente y pruebe contra "nulo" y funciona bien. De hecho, no se lanza ninguna excepción


1
No, esa es una solución absolutamente terrible. Las respuestas anteriores funcionan.
Konrad Rudolph

@KonradRudolph En realidad probé algunas de estas soluciones antes de llegar a mi conclusión. Intenté usar estas soluciones en un adaptador de vista de reciclaje y no me dio el resultado correcto hasta que obtuve esta respuesta.
leeCoder

Puedo decir con confianza que esto significa que hay algo más mal con su código, y simplemente está arreglando los síntomas, no la fuente del error. No tome esto de la manera incorrecta, pero este es un caso típico de programación de culto de carga .
Konrad Rudolph el

0

La excepción también puede ayudar:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}

0

Si está trabajando en Android, puede usar la clase TextUtils simple. Verifique el siguiente código:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Este es un uso simple del código. La respuesta puede repetirse. Pero es simple tener un cheque simple y simple para usted.


-5

Tienes que consultar con nulo if(str != null).


55
Su solución fue publicada por otros usuarios hace años ... ¿Cuál es el punto de repetirla?
TDG

1
No veo
ninguna

66
Correcto, no ha confirmado las respuestas desde 2010, por lo que solo repetirá una respuesta anterior y él confirmará su respuesta ...
TDG
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.