Warum gibt es in Java kein String.Empty?

Ich verstehe, dass jedes Mal, wenn ich das String-Literal eingebe "", dasselbe String-Objekt im String-Pool referenziert wird.

Aber warum enthält die String-API kein a public static final String Empty = "";, sodass ich Verweise auf verwenden kann String.Empty?

Dies würde zumindest Kompilierungszeit sparen, da der Compiler wissen würde, auf den vorhandenen String zu verweisen, und nicht prüfen müsste, ob er bereits zur Wiederverwendung erstellt wurde, oder? Und ich persönlich denke, dass eine Verbreitung von String-Literalen, insbesondere von winzigen, in vielen Fällen ein "Code-Geruch" ist.

Gab es also einen großen Designgrund für kein String.Empty, oder haben die Sprachschöpfer meine Ansichten einfach nicht geteilt?

String.EMPTYist 12 Zeichen und ""ist zwei, und beide würden zur Laufzeit genau dieselbe Instanz im Speicher referenzieren. Ich bin mir nicht ganz sicher, warum String.EMPTYich Zeit beim Kompilieren sparen sollte, tatsächlich denke ich, dass es das letztere sein würde.

Insbesondere wenn man bedenkt, dass Strings unveränderlich sind, ist es nicht so, dass man zuerst einen leeren String abrufen und einige Operationen daran ausführen kann - am besten verwenden Sie einen StringBuilder(oder StringBufferwenn Sie threadsicher sein möchten) und verwandeln diesen in einen String.

Update
Von Ihrem Kommentar zur Frage:

Was das inspiriert hat, ist eigentlich TextBox.setText("");

Ich glaube, es wäre absolut legitim, eine Konstante in Ihrer entsprechenden Klasse bereitzustellen:

private static final String EMPTY_STRING = "";

Und verweisen Sie dann wie in Ihrem Code auf

TextBox.setText(EMPTY_STRING);

Auf diese Weise weisen Sie zumindest ausdrücklich darauf hin, dass Sie einen leeren String möchten, anstatt zu vergessen, den String in Ihrer IDE oder ähnlichem auszufüllen.

Verwenden org.apache.commons.lang.StringUtils.EMPTY

Wenn Sie mit einer leeren Zeichenfolge vergleichen möchten, ohne sich um Nullwerte kümmern zu müssen, können Sie Folgendes tun.

if ("".equals(text))

Letztendlich sollten Sie das tun, was Ihrer Meinung nach am klarsten ist. Die meisten Programmierer gehen davon aus, dass "" eine leere Zeichenfolge bedeutet, keine Zeichenfolge, in die jemand vergessen hat, etwas einzugeben.

Wenn Sie glauben, dass es einen Leistungsvorteil gibt, sollten Sie ihn testen. Wenn Sie nicht der Meinung sind, dass es sich lohnt, es selbst zu testen, ist dies ein guter Hinweis darauf, dass es sich wirklich nicht lohnt.

Es hört sich so an, als würden Sie versuchen, ein Problem zu lösen, das gelöst wurde, als die Sprache vor mehr als 15 Jahren entworfen wurde.

Wenn Sie wirklich eine String.EMPTY-Konstante möchten, können Sie in Ihrem Projekt eine statische Endklasse mit dem Namen "Constants" erstellen. Diese Klasse behält Ihre Konstanten bei, einschließlich der leeren Zeichenfolge ...

Mit der gleichen Idee können Sie ZERO, ONE int-Konstanten erstellen, die in der Integer-Klasse nicht vorhanden sind, aber wie ich bereits sagte, wäre es mühsam, zu schreiben und zu lesen:

for(int i=Constants.ZERO; ...) {
    if(myArray.length > Constants.ONE) {
        System.out.println("More than one element");
    }
}

Usw.

Apache StringUtils behebt auch dieses Problem.

Fehler der anderen Optionen:

• isEmpty () - nicht null sicher. Wenn die Zeichenfolge null ist, wird eine NPE ausgelöst
• length () == 0 - wieder nicht null sicher. Berücksichtigt auch keine Leerzeichenfolgen.
• Vergleich mit der LEER-Konstante - Möglicherweise nicht null-sicher. Leerzeichenproblem

Zugegeben, StringUtils ist eine weitere Bibliothek zum Herumschleppen, funktioniert jedoch sehr gut und spart viel Zeit und Aufwand beim Überprüfen auf Nullen oder beim ordnungsgemäßen Umgang mit NPEs.

Sagen Sie nicht einfach "Speicherpool von Zeichenfolgen wird in der wörtlichen Form wiederverwendet, Groß- / Kleinschreibung geschlossen". Was Compiler unter der Haube tun, ist hier nicht der Punkt. Die Frage ist vernünftig, insbesondere angesichts der Anzahl der erhaltenen Stimmen.

Es geht um die Symmetrie , ohne sie sind APIs für Menschen schwieriger zu verwenden. Frühe Java-SDKs haben die Regel notorisch ignoriert und jetzt ist es etwas zu spät. Hier sind ein paar Beispiele auf meinem Kopf, zögern Sie nicht, Ihr "Lieblings" -Beispiel einzuspielen:

• BigDecimal.ZERO, aber keine AbstractCollection.EMPTY, String.EMPTY
• Array.length but List.size ()
• List.add (), Set.add (), aber Map.put (), ByteBuffer.put () und StringBuilder.append (), Stack.push ()

Alle diese ""Literale sind dasselbe Objekt. Warum all diese zusätzliche Komplexität machen? Die Eingabe ist nur länger und weniger klar (die Kosten für den Compiler sind minimal). Da Javas Zeichenfolgen unveränderliche Objekte sind, besteht keine Notwendigkeit, zwischen ihnen zu unterscheiden, außer möglicherweise aus Effizienzgründen, aber mit dem leeren Zeichenfolgenliteral ist das keine große Sache.

Wenn Sie wirklich eine EmptyStringKonstante wollen , machen Sie es selbst. Aber alles, was es tun wird, ist, noch ausführlicheren Code zu fördern. Dies wird niemals von Nutzen sein.

Um das zu ergänzen, was Noel M gesagt hat, können Sie sich diese Frage ansehen. Diese Antwort zeigt, dass die Konstante wiederverwendet wird.

http://forums.java.net/jive/message.jspa?messageID=17122

String-Konstanten werden immer "interniert", so dass eine solche Konstante nicht wirklich benötigt wird.

String s=""; String t=""; boolean b=s==t; // true

Ich verstehe, dass jedes Mal, wenn ich das String-Literal "" eingebe, dasselbe String-Objekt im String-Pool referenziert wird.
Es gibt keine solche Garantie. Und Sie können sich in Ihrer Anwendung nicht darauf verlassen, es liegt ganz bei jvm, zu entscheiden.

oder haben die Sprachschöpfer meine Ansichten einfach nicht geteilt?
Ja. Mir scheint es eine Sache mit sehr niedriger Priorität zu sein.

Späte Antwort, aber ich denke, es fügt diesem Thema etwas Neues hinzu.

Keine der vorherigen Antworten hat die ursprüngliche Frage beantwortet. Einige haben versucht, das Fehlen einer Konstante zu rechtfertigen, während andere Wege aufgezeigt haben, wie wir mit dem Fehlen der Konstante umgehen können. Aber niemand hat eine zwingende Rechtfertigung zum Nutzen der Konstanten geliefert, so dass ihr Mangel immer noch nicht richtig erklärt wird.

Eine Konstante wäre nützlich, da sie verhindern würde, dass bestimmte Codefehler unbemerkt bleiben.

Angenommen, Sie haben eine große Codebasis mit Hunderten von Verweisen auf "". Jemand ändert eine davon, während er durch den Code blättert, und ändert sie in "". Eine solche Änderung hätte eine hohe Wahrscheinlichkeit, unbemerkt in die Produktion zu gelangen. Zu diesem Zeitpunkt könnte ein Problem auftreten, dessen Quelle schwer zu erkennen ist.

OTOH, eine Bibliothekskonstante mit dem Namen EMPTY, würde, wenn sie denselben Fehler aufweist, einen Compilerfehler für etwas wie EM PTY erzeugen.

Es ist immer noch besser, eine eigene Konstante zu definieren. Jemand könnte seine Initialisierung immer noch versehentlich ändern, aber aufgrund seiner weit verbreiteten Verwendung wäre es viel schwieriger, die Auswirkungen eines solchen Fehlers unbemerkt zu lassen als einen Fehler in einem einzelnen Anwendungsfall.

Dies ist einer der allgemeinen Vorteile, die Sie durch die Verwendung von Konstanten anstelle von Literalwerten erhalten. Normalerweise wird erkannt, dass Sie durch die Verwendung einer Konstante für einen Wert, der an Dutzenden von Stellen verwendet wird, diesen Wert einfach an nur einer Stelle aktualisieren können. Weniger häufig wird anerkannt, dass dies auch verhindert, dass dieser Wert versehentlich geändert wird, da eine solche Änderung überall angezeigt wird. Also, ja, "" ist kürzer als LEER, aber LEER ist sicherer als "".

Um auf die ursprüngliche Frage zurückzukommen, können wir nur spekulieren, dass die Sprachdesigner diesen Vorteil der Bereitstellung von Konstanten für häufig verwendete Literalwerte wahrscheinlich nicht kannten. Hoffentlich werden eines Tages String-Konstanten in Java hinzugefügt.

Für diejenigen, die behaupten ""und String.Emptyaustauschbar sind oder die ""besser sind, liegen Sie sehr falsch.

Jedes Mal, wenn Sie so etwas wie myVariable = "" tun; Sie erstellen eine Instanz eines Objekts. Wenn das String-Objekt von Java eine leere öffentliche Konstante hätte, gäbe es nur eine Instanz des Objekts ""

Z.B: -

String.EMPTY = ""; //Simply demonstrating. I realize this is invalid syntax

myVar0 = String.EMPTY;
myVar1 = String.EMPTY;
myVar2 = String.EMPTY;
myVar3 = String.EMPTY;
myVar4 = String.EMPTY;
myVar5 = String.EMPTY;
myVar6 = String.EMPTY;
myVar7 = String.EMPTY;
myVar8 = String.EMPTY;
myVar9 = String.EMPTY;

10 (11 einschließlich String.EMPTY) Zeiger auf 1 Objekt

Oder: -

myVar0 = "";
myVar1 = "";
myVar2 = "";
myVar3 = "";
myVar4 = "";
myVar5 = "";
myVar6 = "";
myVar7 = "";
myVar8 = "";
myVar9 = "";

10 Zeiger auf 10 Objekte

Dies ist ineffizient und kann in einer großen Anwendung von Bedeutung sein.

Möglicherweise ist der Java-Compiler oder die Java-Laufzeit effizient genug, um automatisch alle Instanzen von "" auf dieselbe Instanz zu verweisen, dies ist jedoch möglicherweise nicht der Fall und erfordert zusätzliche Verarbeitung, um diese Bestimmung vorzunehmen.