Soll ich string.isEmpty () oder "" .equals (string) verwenden?

Der Titel sagt im Grunde alles. Normalerweise teste ich dies zusammen mit a string == null, daher mache ich mir keine Sorgen um einen null-sicheren Test. Welches soll ich verwenden?

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

oder

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

In diesem Sinne - macht isEmpty()überhaupt etwas anderes als return this.equals("");oder return this.length() == 0;?

Der Hauptvorteil von "".equals(s)ist, dass Sie die Nullprüfung nicht benötigen ( equalsüberprüft ihr Argument und gibt zurück, falsewenn sie null ist), was Sie anscheinend nicht interessiert. Wenn Sie sich keine Sorgen darüber machen s, null zu sein (oder auf andere Weise danach suchen), würde ich dies definitiv verwenden s.isEmpty(). Es zeigt genau, was Sie überprüfen. Es ist Ihnen swichtig, ob es leer ist oder nicht , und nicht, ob es der leeren Zeichenfolge entspricht

String.equals("")ist eigentlich etwas langsamer als nur ein isEmpty()Anruf. Strings speichern eine im Konstruktor initialisierte Zählvariable, da Strings unveränderlich sind.

isEmpty() vergleicht die Zählvariable mit 0, während equals den Typ und die Zeichenfolgenlänge überprüft und dann zum Vergleich über die Zeichenfolge iteriert, wenn die Größen übereinstimmen.

Also, um Ihre Frage zu beantworten, isEmpty()wird tatsächlich viel weniger tun! und das ist gut so.

Eine Sache, die Sie neben den anderen genannten Problemen berücksichtigen sollten, ist die isEmpty()in 1.6 eingeführte. Wenn Sie sie also verwenden, können Sie den Code nicht unter Java 1.5 oder niedriger ausführen.

Sie können Apache Commons verwenden. StringUtils isEmpty () oder isNotEmpty ().

Es ist nicht wirklich wichtig. "".equals(str)ist meiner Meinung nach klarer.

isEmpty()kehrt zurück count == 0;

Ich habe eine Testerklasse geschrieben, die die Leistung testen kann:

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

Ich fand, dass die Verwendung von .isEmpty () ungefähr die Hälfte der Zeit von .equals ("") dauerte.