¿Cómo verificar una cadena contra nulo en java?

¿Cómo puedo verificar una cadena con un valor nulo en java? estoy usando

stringname.equalsignorecase(null)

pero no funciona.

string == nullcompara 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 iguales, no los valores que representan.

Respuesta más larga:

Si prueba esto, no funcionará, como ha descubierto:

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 ningún objeto allí desde el que se pueda llamar a .equals.

Lo que probablemente querías era:

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

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

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

De esa manera, si foo era nulo, no evalúa la segunda mitad del condicional y todo está bien.

La forma más fácil, si está utilizando un literal de cadena (en lugar de una variable), es:

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

Si desea solucionarlo , Apache Commons tiene una clase: StringUtils , que proporciona operaciones String seguras para nulos.

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

Otra respuesta fue en broma 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 sean excepcionales; si espera un valor 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; la comprobación contra nulos es rápida, pero cuando la JVM genera una excepción, lleva mucho tiempo. En segundo lugar, el código es mucho más fácil de leer y mantener si solo verifica el puntero nulo antes de tiempo.

s == null

no funcionará?

Seguro que funciona. Se está perdiendo una parte vital del código. Solo necesitas hacer esto:

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

;)

Utilice el método TextUtils si trabaja en Android.

TextUtils.isEmpty (str) : devuelve verdadero si la cadena es nula o de longitud 0. Parámetros: str la cadena a examinar Devuelve: verdadero si str es nulo o de longitud cero

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

A continuación se muestra el código fuente de este método. Puede utilizar direclty.

 /**
     * 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;
    }

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

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

Por lo tanto, siempre regresará falsesi el argumento es null. Y esto obviamente es correcto, porque el único caso en el que debería regresar truees cuando se invocó equalsIgnoreCase en un null String, pero

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

definitivamente resultará en una NullPointerException.

Por lo tanto, los métodos iguales no están diseñados para probar si un objeto es nulo, solo porque no puede invocarlos null.

Esto parece un poco extraño, pero ...

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

Nunca tuve problemas para hacerlo de esta manera, además, es una forma más segura de verificar mientras se evitan posibles excepciones de puntos nulos.

No estoy seguro de qué estaba mal con la respuesta de MYYN.

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

La verificación nula anterior está bastante bien.

Si está intentando verificar si una referencia de cadena es igual (ignorando mayúsculas y minúsculas) a otra cadena que sabe que no es una referencia nula, haga algo como esto:

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

Si tiene alguna duda sobre si tiene o no referencias nulas para ambas cadenas que está comparando, deberá verificar si hay una referencia nula en al menos una de ellas para evitar la posibilidad de una NullPointerException.

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

if(null == stringName){

  [code]

}

else

[Error Msg]

importarlo en tu clase

import org.apache.commons.lang.StringUtils;

luego úsalo, ambos volverán verdaderos

System.out.println(StringUtils.isEmpty(""));
System.out.println(StringUtils.isEmpty(null)); 

Puede verificar con String == null

Esto funciona para mi

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

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

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

Por lo tanto, obtiene la excepción debido al caso 2.
Lo que sugiero es que use simplementestringname == null

Método simple:

public static boolean isBlank(String value) {
    return (value == null || value.equals("") || value.equals("null") || value.trim().equals(""));
}

Si lo valuedevuelto es nulo, use:

if(value.isEmpty());

En algún momento para verificar nulo, if(value == null)en java, es posible que no dé verdadero incluso si la cadena es nula.

Con Java 7 puedes usar

if (Objects.equals(foo, null)) {
    ...
}

que devolverá truesi ambos parámetros son null.

Me doy cuenta de que esto fue respondido hace mucho tiempo, pero no he visto esto publicado, así que pensé en compartir lo que hago. Esto no es particularmente bueno para la legibilidad del código, pero si tiene que hacer una serie de verificaciones nulas, me gusta usar:

String someString = someObject.getProperty() == null ? "" : someObject.getProperty().trim();

En este ejemplo, se llama a trim en la cadena, lo que arrojaría un NPE si la cadena fuera nula o espacios, pero en la misma línea, puede verificar si hay nulos o espacios en blanco para no terminar con una tonelada de (más ) difícil de formatear si se bloquea.

Si lo entiendo correctamente, esto debería hacerlo:

if(!stringname.isEmpty())
// an if to check if stringname is not null
if(stringname.isEmpy())
// an if to check if stringname is null

Bueno, la última vez que alguien hizo esta pregunta tonta, la respuesta fue:

someString.equals("null")

Sin embargo, esta "solución" solo oculta el mayor problema de cómo se nullconvierte "null"en primer lugar.

Hay dos formas de hacerlo ... Di String == null o string.equals () ..

public class IfElse {

    public int ifElseTesting(String a){
        //return null;
        return (a== null)? 0: a.length();
    }

}

public class ShortCutifElseTesting {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("enter the string please:");
        String a=scanner.nextLine();
        /*
        if (a.equals(null)){
            System.out.println("you are not correct");
        }
        else if(a.equals("bangladesh")){
            System.out.println("you are right");
        }
        else
            System.out.println("succesful tested");

        */
        IfElse ie=new IfElse();
        int result=ie.ifElseTesting(a);
        System.out.println(result);

    }

}

Compruebe este ejemplo ... Aquí hay otro ejemplo de la versión de acceso directo de If Else ...