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

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.

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.

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.

Apache commons StringUtils.isNotEmptyes el mejor camino a seguir.

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

TRABAJANDO !!!!

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

Debe verificar que el myStringobjeto es null:

if (myString != null) {
    doSomething
}

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

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).

Tratar,

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

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

        // your magic here

 }

Incidentalmente, si está haciendo mucha manipulación de cadenas, hay una gran clase de Spring con todo tipo de métodos útiles:

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

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.

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.

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

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.

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

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

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.

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

Prefiero usar:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

Lea StringUtils.isBlank () vs String.isEmpty () .

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.

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.

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
}

Puede verificar una cadena igual a nula usando esto:

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

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

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

La excepción también puede ayudar:

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

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.

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