¿Cómo comprobar si mi cadena es igual a nulo?

Question

Quiero realizar alguna acción SÓLO SI mi cuerda 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 doSomething a pesar de que mi cadena ESTÁ VACÍA. Es igual a null. Entonces, ¿qué está mal con eso?

añadido:

he encontrado la razón del problema. La variable se declaró como una cadena y, como consecuencia, null asignado a esta variable se transformó en "null"! Por lo tanto, if (!myString.equals("null")) funciona.

Answer 1

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

---

Como comentario adicional, usted debe ser consciente de este término en el equals contrato:

De Object.equals(Object):

Para cualquier valor de referencia no nula x, x.equals(null) debe return false.

La manera de comparar con null es utilizar x == null y x != null.

Por otra parte, x.field y x.method() arroja NullPointerException si x == null.

Answer 2

Es necesario comprobar que el objeto es myStringnull:

if (myString != null) { 
    doSomething 
} 

Answer 3

intento,

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

Answer 4

Si es myStringnull, a continuación, llamar myString.equals(null) o myString.equals("") fallará con un NullPointerException. No puede llamar a ningún método de instancia en una variable nula.

comprobar NULL primero como esto:

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

Esto hace uso de short-circuit evaluation a no intentar la .equals si myString no pasa la comprobación nula.

Answer 5

Si la cadena es nula, llamadas como esta debe lanzar una NullReferenceException:

myString.equals (nulo)

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

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

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

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

Answer 6

este debería funcionar:

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

Si no, entonces myString probablemente tenga un valor que no está esperando. Pruebe a imprimir hacia fuera como esto:

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

El uso de los símbolos '+' para rodear la cadena le mostrará si hay espacios en blanco extra ahí que no se está representando.

Answer 7

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

     // your magic here 

} 

Dicho sea de paso, si usted está haciendo mucho la manipulación de cadenas, hay una gran clase de primavera con todo tipo de métodos útiles:

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

Answer 8

me gustaría hacer algo como esto:

(myString != null && myString.length() > 0) 
    ? doSomething() : System.out.println("Non valid String"); 

• Comprobando si null comprueba si myString contiene una instancia de String.
• length() devuelve la longitud y es equivalente a iguales ("").
• Comprobando si myString es nulo primero evitará una NullPointerException.

Answer 9

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

Answer 10

Yo animaría a usar una utilidad existente o crear su propio método:

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

A continuación, sólo usarlo cuando lo necesite:

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

Como se ha señalado arriba, el || y & & cortocircuito de los operadores. Eso significa que tan pronto como puedan determinar su valor, se detendrán. Entonces, si (cadena == nulo) es verdadero, la parte de longitud no necesita ser evaluada, 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 necesita evaluación adicional.

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

Answer 11

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 verificación de longitud (en cualquier caso NUNCA cree una nueva Cadena vacía con la marca).

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

Por cierto, si la comparación con literales de cadena como lo hace, podría revertir la declaración de manera que no tiene que tener un cheque nulo, es decir,

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

en lugar de:

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

Answer 12

Cada vez que tengo que lidiar con cadenas (casi todas las veces) me detengo y me pregunto cuál es la forma más rápida de buscar 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 procesamiento que no sea recuperar el valor de la propiedad. Pero luego me pregunto, ¿por qué hay un String.Empty? Debería ser más rápido buscar Cadena. 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 un control determinado de 10 millones de repeticiones. Comprobé 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 == null || str.length == 0. A continuación se presentan los resultados:

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, el promedio para la comprobación str == null es el más rápido, pero no siempre puede dar lo que estamos buscando. if str = String.Empty o str = "", resulta en falso. Luego tiene 2 que están empatados en el segundo lugar: String.IsNullOrEmpty() y str == null || str.length == 0. Como el String.IsNullOrEmpty() se ve mejor y es más fácil (y más rápido) de escribir, recomendaría usarlo sobre la otra solución.

Answer 13

Apache commons StringUtils.isNotEmpty es la mejor manera de proceder.

Answer 14

tuve este problema en androide y yo uso esta manera (Trabajo para mí):

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

Pero en código Java que utilizo:

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

Answer 15

Creo que myString no es una cadena sino una matriz de cadenas. Esto es lo que tiene que hacer:

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

Answer 16

Puede comprobar cadena igual a null usando la siguiente:

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

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

Answer 17

Yo prefiero usar:

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

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

Answer 18

usted tiene que comprobar con nula if(str != null).

Answer 19

En Android se puede comprobar esto con método de utilidad isEmpty de TextUtils,

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

isEmpty(CharSequence str) método de verificar tanto la condición, por null y longitud.

Answer 20

Probé la mayoría de los ejemplos anteriores para un nulo en una aplicación de Android que estaba compilando y TODO FALLÓ. Así que 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 concatenar una cadena vacía como lo hice arriba y prueba en contra de "nulo" y funciona bien. De hecho, no se arroja ninguna excepción

Answer 21

WORKING !!!!

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

Answer 22

I estado usando StringUtil.isBlank(string)

Comprueba si una cadena está en blanco: null, emtpy o sólo espacios en blanco.

Así que éste es el mejor hasta ahora

Aquí es el método orignal 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; 
    } 

Answer 23

de excepción también puede ayudar:

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

Answer 24

Está bien así es como tipos de datos de trabajo en Java. (Tiene que excusar mi inglés, no estoy usando el vocabulario correcto. Tiene que diferenciar entre dos de ellos. Los tipos de datos base y los tipos de datos normales. Los tipos de datos básicos conforman prácticamente todo lo que existe. Por ejemplo , hay todos los números, char, boolean, etc. los tipos de datos normales o tipos de datos complejos es todo lo demás. una cadena es una serie de caracteres, por lo tanto, un tipo de datos.

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

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

la var iable "s" NO contiene una cadena. Es un puntero. Este puntero apunta a la variable en su memoria. Cuando llama al System.out.println(anyObject), se llama al método toString() de ese objeto. Si no anuló toString desde Objeto, 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. De hecho, no hay puntero y los valores se almacenan directamente.

Por ejemplo:

int i = 123; 

i no almacena un puntero en este caso. Voy a almacenar el valor entero 123 (en bytes de c).

Bien, 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 

Este tanto de cadena tiene un puntero diferente. String.equals (String other) sin embargo 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.

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

Saludos

Answer 25

Para mí, la mejor manera de verificar si una cadena tiene ningún contenido significativo en Java es la siguiente:

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

En primer lugar, comprobar si la cadena es null para evitar NullPointerException y luego recortar todos caracteres de espacio para evitar la comprobación de cadenas que solo tienen espacios en blanco y, finalmente, comprobar si la cadena recortada no está vacía, es decir, tiene longitud 0.