isempty - Cómo comprobar una cadena contra null en java?

java validate null or empty

Question

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

stringname.equalsignorecase(null)

pero no está funcionando.

Answer 1

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

someString.equals("null")

Sin embargo, esta "corrección" solo oculta el problema mayor de cómo null vuelve "null" .

Answer 2

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

;)

Answer 3

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.

Answer 4

Hay dos formas de hacerlo ... Say 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);

    }

}

Mira este ejemplo ... Aquí hay otro ejemplo de versión abreviada de If Else ..

Answer 5

Método simple:

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

Answer 6

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 comprobaciones nulas, me gusta usar:

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

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

Answer 7

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 sabe que no es una referencia nula, entonces haga 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.

Answer 8

Por supuesto, user351809, stringname.equalsignorecase(null) lanzará NullPointerException.
Mira, tienes un string string object, 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 valor null :
   Aquí su código se atascará, como
   null.equalsignorecase(null)
   Sin embargo, parece bueno a primera vista y puede esperar que la respuesta sea true ,
   pero, null no es un objeto que puede ejecutar el método equalsignorecase() .

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

Answer 9

Puedes consultar con String == null

Esto funciona para mí

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

Answer 10

Si el value devuelto es nulo, use:

if(value.isEmpty());

En algún momento para verificar null, if(value == null) en java, es posible que no sea verdadero incluso si String es nulo.

Answer 11

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

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

Por lo tanto, siempre devolverá false si el argumento es null . Y esto es obviamente correcto, porque el único caso en el que debería volverse true es cuando se invocó IgualIgnoreCase en una null String , pero

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

definitivamente dará como resultado una NullPointerException.

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

Answer 12

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

if(null == stringName){

  [code]

}

else

[Error Msg]

Answer 13

Use el método TextUtils.

TextUtils.isEmpty (str) : devuelve verdadero si la cadena es nula o 0-length. 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

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

Answer 14

importarlo en tu clase

import org.apache.commons.lang.StringUtils;

luego úsala, ambas regresarán verdaderas

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

Answer 15

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 iguales, 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 quiere StringUtils , 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.

Answer 16

s == null

no funcionará?