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

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 progtwig hace algo a pesar del hecho de que mi cuerda está VACÍA. Es igual a null . Entonces, ¿qué está mal con eso?

ADICIONAL:

Encontré la razón del problema. La variable se declaró como una cadena y, como consecuencia, ¡ null asignado 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 contrato de equals :

Desde Object.equals(Object) :

Para cualquier valor de referencia no nulo x , x.equals(null) debería return false .

La forma de comparar con null es usar x == null y x != null .

Además, x.field y x.method() arrojan NullPointerException si x == null .

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

Compruebe null primero como este:

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

Esto hace uso de la evaluación de cortocircuito para no intentar el .equals si myString falla la verificación nula.

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

Si myString es de hecho nulo, cualquier llamada a la referencia fallará con una Excepción de puntero nulo (NPE Poin Exception). 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 marca).

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

Por cierto, si comparas con los literales String como lo haces, invertirías la statement para no tener que tener una verificación nula, es decir,

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

en lugar de :

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

Si su cadena es nula, las llamadas como esta deben arrojar una NullReferenceException:

myString.equals (null)

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 tu código, puedes hacer cosas como esta:

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

myString verificar que el objeto myString sea null :

 if (myString != null) { doSomething } 

Tratar,

 myString!=null && myString.length()>0 
  if (myString != null && myString.length() > 0) { // your magic here } 

Incidentemente, si estás haciendo mucha manipulación de cuerdas, 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

Yo recomendaría utilizar una utilidad existente o crear su propio método:

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

Entonces solo úsalo cuando lo necesites:

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

Como se señaló anteriormente, el || y & operadores cortocircuito. 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 length 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 comstackdores podrían optimizar esto).

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 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 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 muestran 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 chequeo promedio de str == null es el más rápido, pero no siempre da lo que estamos buscando. if str = String.Empty o str = "" , da como resultado falso. Entonces tienes 2 que están empatados en el segundo lugar: String.IsNullOrEmpty() y str == null || str.length == 0 str == null || str.length == 0 . Como 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.

TRABAJANDO !!!!

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

Haría 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 (“”).
  • Comprobar si myString es nulo primero evitará una NullPointerException.

He estado usando StringUtil.isBlank(string)

Prueba si una cadena está en blanco: null, emtpy o solo en blanco.

Así que este es el mejor hasta ahora

Aquí está 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; } 

Esto debería funcionar:

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

Si no, entonces myString probablemente tenga un valor que no estás esperando. Intente imprimirlo así:

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

El uso de los símbolos ‘+’ para rodear la cuerda le mostrará si hay espacio en blanco adicional que no está teniendo en cuenta.

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

Tuve este problema en Android y lo usé de esta manera (Work for me):

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

Pero en el código de Java 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); } 

Prefiero usar:

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

Lea StringUtils.isBlank () frente a String.isEmpty () .

En Android puedes verificar esto con el método de utilidad isEmpty de TextUtils ,

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

isEmpty(CharSequence str) verifica ambas condiciones, para null y largo.

De acuerdo, así es como funcionan los tipos de datos en Java. (Tienes que excusar mi inglés, no estoy usando el vocabulario correcto. Tienes que diferenciar entre dos de ellos. Los tipos de datos base y los tipos de datos normales. Los tipos de datos base conforman prácticamente todo lo que existe. Por ejemplo, hay son todos los números, char, booleano, etc. Los tipos de datos normales o 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 creas es en realidad un puntero sobre el valor en tu 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 llama a System.out.println(anyObject) , se llama al método toString() de ese objeto. Si no anuló toString from 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 lo que está detrás de “@” 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; 

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

De acuerdo, 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 

Ambas cadenas tienen 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

Para mí, la mejor comprobación de si una cadena tiene contenido significativo en Java es esta:

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

Primero comprueba si la cadena es null para evitar NullPointerException y luego recorta todos los caracteres de espacio para evitar la verificación de cadenas que solo tienen espacios en blanco y finalmente comprueba si la cadena recortada no está vacía, es decir, tiene longitud 0.

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 } 

Puedes verificar cadena igual a nulo usando esto:

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

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

Intenté la mayoría de los ejemplos indicados anteriormente para un nulo en una aplicación de Android que estaba comstackndo 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 probar contra “nulo” y funciona bien. De hecho, no se arroja 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=""; } 

Tienes que verificar con null if(str != null).