Pregunta Cómo comprobar una cadena contra null en java?


¿Cómo puedo verificar una cadena contra null en java? estoy usando

stringname.equalsignorecase(null)

pero no está funcionando.


74
2018-05-27 11:11


origen


Respuestas:


string == null compara si el objeto es nulo. string.equals("foo") compara el valor dentro de ese objeto. string == "foo" no siempre funciona, porque está tratando de ver si los objetos son los mismos, no los valores que representan.


Respuesta más larga:

Si pruebas esto, no funcionará, como has encontrado:

String foo = null;
if (foo.equals(null)) {
    // That fails every time. 
}

La razón es que foo es nulo, por lo que no sabe qué es .equals; no hay objeto allí para que se llame a los iguales.

Lo que probablemente querías era:

String foo = null;
if (foo == null) {
    // That will work.
}

La forma típica de protegerse contra un nulo cuando se trata de cadenas es:

String foo = null;
String bar = "Some string";
...
if (foo != null && foo.equals(bar)) {
    // Do something here.
}

De esta forma, si foo fue nulo, no evalúa la segunda mitad del condicional, y las cosas están bien.

La manera fácil, si estás usando un literal String (en lugar de una variable), es:

String foo = null;
...
if ("some String".equals(foo)) {
    // Do something here.
}

Si quieres evitarlo, Apache Commons tiene una clase: StringUtils - que proporciona operaciones String nulas.

if (StringUtils.equals(foo, bar)) {
    // Do something here.
}

Otra respuesta fue bromear y dijo que deberías hacer esto:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

Por favor no hagas eso. Solo debe lanzar excepciones para errores que son excepcionales; Si está esperando un nulo, debe verificarlo con anticipación y no dejar que arroje la excepción.

En mi cabeza, hay dos razones para esto. Primero, las excepciones son lentas; Comprobar contra null es rápido, pero cuando la JVM lanza una excepción, lleva mucho tiempo. En segundo lugar, el código es mucho más fácil de leer y mantener si solo comprueba el puntero nulo con anticipación.


140
2018-05-27 14:21



s == null

no funcionará?


25
2018-05-27 11:12



Claro que funciona. Te estás perdiendo una parte vital del código. Solo necesitas hacer esto:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

;)


16
2018-05-27 11:16



Use el método TextUtils.

TextUtils.isEmpty (str) : Devuelve verdadero si la cadena es nula o 0-length. Parámetros: str la cuerda para ser examinado Devoluciones: true si str es nulo o de longitud cero

  if(TextUtils.isEmpty(str)) {
        // str is null or lenght is 0
    }

A continuación es código fuente de este método

 /**
     * Returns true if the string is null or 0-length.
     * @param str the string to be examined
     * @return true if str is null or zero length
     */
    public static boolean isEmpty(CharSequence str) {
        if (str == null || str.length() == 0)
            return true;
        else
            return false;
    }

9
2017-11-13 10:43



Si observamos la implementación del método equalsIgnoreCase, encontramos esta parte:

if (string == null || count != string.count) {
    return false;
}

Por lo tanto, siempre regresará false si el argumento es null. Y esto es obviamente correcto, porque el único caso en el que debería regresar true es cuando EqualsIgnoreCase fue invocado en un null String, pero

String nullString = null;
nullString.equalsIgnoreCase(null);

definitivamente dará como resultado una NullPointerException.

Así que los métodos iguales no están diseñados para probar si un objeto es nulo, simplemente porque no puede invocarlos en null.


5
2018-05-27 11:26



Esto se ve un poco extraño, pero ...

stringName == null || "".equals(stringName)

Nunca tuve problemas para hacerlo de esta manera, además de que es una forma más segura de verificar y evitar posibles excepciones de puntos nulos.


4
2017-12-03 17:00



No estoy seguro de lo que estaba mal con la respuesta de MYYN.

if (yourString != null) {
  //do fun stuff with yourString here
}

La comprobación nula anterior está bastante bien.

Si está tratando de verificar si una referencia de cadena es igual (ignorando el caso) a otra cadena que saber no es una referencia nula, luego haz algo como esto:

String x = "this is not a null reference"
if (x.equalsIgnoreCase(yourStringReferenceThatMightBeNull) ) {
  //do fun stuff
}

Si existe alguna duda sobre si tiene referencias nulas para las dos cadenas que está comparando, tendrá que buscar una referencia nula en al menos una de ellas para evitar la posibilidad de una NullPointerException.


3
2018-05-27 11:19



Si su cadena tiene un valor "nulo", entonces puede usar

if(null == stringName){

  [code]

}

else

[Error Msg]

2
2018-02-18 05:24



Puedes consultar con String == null

Esto funciona para mí

    String foo = null;
    if(foo == null){
        System.out.println("String is null");
    }

2
2017-08-19 08:38



Por supuesto usuario351809, stringname.equalsignorecase(null) lanzará NullPointerException.
Mira, tienes un objeto de cadena stringname, que sigue 2 posibles condiciones:

  1. stringname tiene un valor de cadena no nulo (digamos "computadora"):
    Tu código funcionará bien ya que toma la forma
    "computer".equalsignorecase(null)
    y obtienes la respuesta esperada como false.
  2. stringname tiene un null valor:
    Aquí su código se atascará, como
    null.equalsignorecase(null)
    Sin embargo, parece bueno a primera vista y puede esperar una respuesta como true,
    pero, null no es un objeto que puede ejecutar el equalsignorecase() método.

Por lo tanto, obtienes la excepción debido al caso 2.
Lo que te sugiero es que simplemente uses stringname == null


1
2018-01-31 08:37