¿Debo usar string.isEmpty () o "" .equals (string)?

El título básicamente lo dice todo. Por lo general, estoy probando esto junto con un string == null, así que no estoy realmente preocupado por una prueba nula-segura. ¿Cuál debería usar?

String s = /* whatever */;
...
if (s == null || "".equals(s))
{
    // handle some edge case here
}

o

if (s == null || s.isEmpty())
{
    // handle some edge case here
}

En esa nota, ¿ isEmpty()hace algo más que return this.equals("");o return this.length() == 0;?

El principal beneficio de "".equals(s)es que no necesita la verificación nula ( equalsverificará su argumento y devolverá falsesi es nula), que parece no importarle. Si no le preocupa sser nulo (o de lo contrario lo está comprobando), definitivamente lo usaría s.isEmpty(); muestra exactamente lo que está comprobando, le importa si sestá vacío o no , no si es igual a la cadena vacía

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

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

Entonces, para responder a su pregunta, ¡en isEmpty()realidad hará mucho menos! y eso es bueno

Una cosa que quizás desee considerar además de los otros problemas mencionados es que isEmpty()se introdujo en 1.6, por lo que si lo usa, no podrá ejecutar el código en Java 1.5 o inferior.

Puede usar Apache commons StringUtils isEmpty () o isNotEmpty ().

Realmente no importa. "".equals(str)Es más claro en mi opinión.

isEmpty()vuelve count == 0;

Escribí una clase de probador que puede probar el rendimiento:

public class Tester
{
    public static void main(String[] args)
    {
        String text = "";

        int loopCount = 10000000;
        long startTime, endTime, duration1, duration2;

        startTime = System.nanoTime();
        for (int i = 0; i < loopCount; i++) {
            text.equals("");
        }
        endTime = System.nanoTime();
        duration1 = endTime - startTime;
        System.out.println(".equals(\"\") duration " +": \t" + duration1);

        startTime = System.nanoTime();
        for (int i = 0; i < loopCount; i++) {
            text.isEmpty();
        }
        endTime = System.nanoTime();
        duration2 = endTime - startTime;
        System.out.println(".isEmpty() duration "+": \t\t" + duration2);

        System.out.println("isEmpty() to equals(\"\") ratio: " + ((float)duration2 / (float)duration1));
    }
}

Descubrí que usar .isEmpty () tomó alrededor de la mitad del tiempo de .equals ("").