Diferencia entre String.isEmpty() y String.equals ("")

Question

Creé un "Selector de color" con tres cuadros de texto donde el usuario define los valores de rgb.
para comprobar si los valores introducidos son correctos (sólo números entre 0-255) Estoy utilizando el siguiente:

public Color getColor() { 
    if (tfRed.getText().equals("") || tfGreen.getText().equals("") || tfBlue.getText().equals("")) { 
       return new Color(0, 0, 0, 0); 
    } else { 
     if (tfRed.getText().matches("\\d+") && tfGreen.getText().matches("\\d+") && tfBlue.getText().matches("\\d+")) { 
      // ... 
     } else { 
      return new Color(0, 0, 0, 0); 
     } 
    } 
} 

Lo que estoy preguntando: ¿es mejor utilizar String.isEmpty()? Nunca encontré una respuesta satisfactoria y siempre me he preguntado si hay alguna diferencia.

Answer 1

Creo que isEmpty() es un poco más eficiente. Sin embargo, un compilador inteligente puede optimizar la llamada equals("") de todos modos. Desde el OpenJDK source:

671  public boolean isEmpty() { 
    672   return count == 0; 
    673  } 

1013  public boolean equals(Object anObject) { 
1014   if (this == anObject) { 
1015    return true; 
1016   } 
1017   if (anObject instanceof String) { 
1018    String anotherString = (String)anObject; 
1019    int n = count; 
1020    if (n == anotherString.count) { 
1021     char v1[] = value; 
1022     char v2[] = anotherString.value; 
1023     int i = offset; 
1024     int j = anotherString.offset; 
1025     while (n-- != 0) { 
1026      if (v1[i++] != v2[j++]) 
1027       return false; 
1028     } 
1029     return true; 
1030    } 
1031   } 
1032   return false; 
1033  } 

También el answer here sobre si utilizar o str.isEmpty()"".equals(str) es impecable:

El principal beneficio de "".equals(s) es que no es necesario el cheque nulo (equals se verifique su argumento y devuelva false si es nulo), que no parece importarle. Si no está preocupado porque s sea nulo (o lo esté comprobando de otra manera), definitivamente usaría s.isEmpty(); que muestra exactamente lo que está comprobando, te importa si es o no s está vacía, no se si es igual a la cadena vacía

Answer 2

Sí, utilizar String.isEmpty(). Es limpio (semánticamente) (rendimiento es también ligeramente mejor, pero eso sería unnoticable) Si la instancia puede ser nulo, utilice commons-lang StringUtils.isEmpty(string)

Answer 3

Con myString.equals(""), en primer lugar, el compilador crea un objeto String (que es equivalente a myString.equals(new String("")).

Así, estaVacia() debe ser una mejor opción (aunque iguales ("") es muy popular).

Answer 4

Desde isEmpty() comprueba si la longitud de la String es 0 y "" es el únicaString con longitud 0, cada String para el cual isEmpty() devuelve true también devolvería true a .equals(""). Técnicamente, hacen lo mismo.

Puede haber una diferencia mínima en el rendimiento, pero no me molestaría en absoluto (me sorprendería mucho si fuera notable en el código de producción).

Otra diferencia es si escribió "".equals(someString), entonces sería "null-safe". En otras palabras: si someString era null, esta construcción simplemente evaluaría a false y no lanzaría un NullPointerException. Sin embargo, si tiene someString.equals(""), entonces se aplicaría no.

El más importante diferencia es cómo se lee: isEmpty() hace que la intención muy clara: se quiere tratar de manera diferente las cadenas vacías..equals("") es ligeramente menos claro ("si esa cadena es igual a la otra cadena, que está vacía").

Answer 5

En teoría, lo es. Para isEmpty(), solo deben examinarse los metadatos internos de la cadena (por ejemplo, su longitud). Para la comparación, esperaría que ocurrieran un poco más de diferenciaciones de casos.

En la práctica, no importa. No observarías la diferencia de velocidad.

Regla de golpe: utilice el método que mejor se entienda/sea más legible por el programador. Si es una prueba de cadena vacía, creo que isEmpty() se adapta mejor a ese propósito.

Answer 6

isEmpty() es más rápido, ya que sólo se compara el campo entero en lengthString clase para 0 mientras que en comparación a una cadena vacía en el mejor de comparar las referencias (velocidad similar) y en el peor - ejecutar un bucle con 0 iteraciones.

Pero la mayor diferencia es la legibilidad: isEmpty() es más corta y fácil de entender. Por cierto, me gustaría que hubiera una taquigrafía para isBlank().trim().isEmpty() ...

Answer 7

Por lo general, me gusta usar iguales pero a la inversa, es decir:

"".equals(someString); 

nulo seguro :)

Pero sí, estaVacia() es una operación más simple, pero no tanto como para ver que hace una contribución significativa al rendimiento (a menos que estés escribiendo material incrustado en tiempo real).

Answer 8

isEmpty solo se introdujo en 1.6. Compruebe Desde etiqueta en javadoc.

Por lo tanto, si está compilando para 1.5 y menos equals("") es su única opción.

Sin embargo, si la compatibilidad de la versión no es de su incumbencia, usaría isEmpty. Como señaló Bozho, es semánticamente más limpio (y un poco más rápido).

Answer 9

Es en parte una cuestión de historia y usos heredados. isEmpty() solamente se añadió en el JDK 6:

/** 
* Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>. 
* 
* @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise 
* <tt>false</tt> 
* 
* @since 1.6 
*/ 
public boolean isEmpty() { 

Antes de eso, todo el mundo en comparación con "" para ver si hay una cadena vacía o no. Los viejos hábitos se vuelven difíciles, por lo que muchas personas siguen usando la comparación "".

Por supuesto, como ya lo mencionó otra persona, si usa "".equals(someString), entonces será automáticamente nulo. Muchas personas combinan la idea de isEmpty con null safeness, haciendo un static isEmpty method.

Answer 10

Una razón más usando myString.equals("") o myString.length() == 0 es que el método String#isEmpty() se introdujo en Java 1.6.

Los argumentos para no utilizar String#isEmpty() pueden ser motivos de compatibilidad con las versiones anteriores de Java.

Answer 11

Siempre había utilizado .isEmpty() ... hasta hoy, cuando descubrí que no existe en Java 5.

Así:

• En Java 6 y posteriores, tenemos la opción, y recomiendo usar .isEmpty(), es más fácil de escribir y más claro de leer.
• En Java 5 y anteriores tenemos que usar .equals("").

Answer 12

String.equals ("") es un poco más lento que una simple llamada isEmpty(). Las cadenas almacenan una variable de conteo inicializada en el constructor, ya que las cadenas son inmutables.

isEmpty() compara la variable de conteo a 0, mientras que igual comprobará el tipo, la longitud de la cadena y luego iterará sobre la cadena para comparar si los tamaños coinciden.

Para responder a su pregunta, isEmpty() en realidad hará mucho menos! y eso es algo bueno