Warum hat es der Vergleich der Operatorzeichenfolgenwerte nicht nach Java geschafft?

Jeder kompetente Java-Programmierer weiß, dass Sie String.equals () verwenden müssen, um einen String zu vergleichen, anstatt == weil == auf Referenzgleichheit prüft.

Wenn ich mit Strings zu tun habe, überprüfe ich die meiste Zeit auf Wertgleichheit und nicht auf Referenzgleichheit. Es scheint mir, dass es intuitiver wäre, wenn die Sprache den Vergleich von Zeichenfolgenwerten nur mit == zulässt.

Zum Vergleich prüft der Operator == von C # die Wertgleichheit für die Zeichenfolge s. Und wenn Sie wirklich nach Referenzgleichheit suchen mussten, können Sie String.ReferenceEquals verwenden.

Ein weiterer wichtiger Punkt ist, dass Strings unveränderlich sind, sodass diese Funktion keinen Schaden anrichtet.

Gibt es einen bestimmten Grund, warum dies nicht in Java implementiert ist?

Ich denke, es ist nur Beständigkeit oder "Grundsatz des geringsten Erstaunens". String ist ein Objekt, daher wäre es überraschend, wenn es anders behandelt würde als andere Objekte.

Zu der Zeit, als Java herauskam (~ 1995), Stringwar es für die meisten Programmierer, die es gewohnt waren, Strings als nullterminierte Arrays darzustellen, ein absoluter Luxus , nur so etwas zu haben . StringDas Verhalten ist jetzt das, was es damals war, und das ist gut so. Eine nachträgliche subtile Änderung des Verhaltens könnte überraschende, unerwünschte Auswirkungen auf die Arbeitsprogramme haben.

Als Randnotiz könnten Sie verwenden String.intern(), um eine kanonische (internierte) Darstellung der Zeichenfolge zu erhalten, nach der Vergleiche mit vorgenommen werden könnten ==. Das Internieren dauert einige Zeit, aber danach sind die Vergleiche sehr schnell.

Zusatz: Im Gegensatz zu einigen anderen Antworten geht es nicht darum, das Überladen von Operatoren zu unterstützen . Der +Operator (Verkettung) funktioniert auf Strings, obwohl Java das Überladen von Operatoren nicht unterstützt. Es wird einfach als Sonderfall im Compiler behandelt, in den es aufgelöst wird StringBuilder.append(). Ebenso ==hätte als Sonderfall gehandelt werden können.

Warum dann mit Sonderfall überraschen, +aber nicht mit ==? Weil es +einfach nicht kompiliert, wenn es auf Nicht- StringObjekte angewendet wird, sodass dies schnell ersichtlich wird. Das unterschiedliche Verhalten von ==wäre viel weniger auffällig und damit viel erstaunlicher, wenn es dich trifft.

James Gosling , der Schöpfer von Java, hat es im Juli 2000 so erklärt :

Ich habe das Überladen von Operatoren als eine ziemlich persönliche Wahl ausgelassen, weil ich zu viele Leute gesehen habe, die es in C ++ missbraucht haben. Ich habe in den letzten fünf bis sechs Jahren viel Zeit damit verbracht, Leute über das Überladen von Betreibern zu befragen, und es ist wirklich faszinierend, weil man die Community in drei Teile zerlegt: Wahrscheinlich denken 20 bis 30 Prozent der Bevölkerung, dass Betreiber überladen werden Laich des Teufels; Jemand hat etwas mit Überladen von Operatoren gemacht, das sie nur wirklich angekreuzt hat, weil sie wie + zum Einfügen von Listen verwendet haben und das Leben wirklich verwirrend macht. Ein Großteil dieses Problems beruht auf der Tatsache, dass es nur etwa ein halbes Dutzend Operatoren gibt, die Sie sinnvoll überladen können, und dass es dennoch Tausende oder Millionen von Operatoren gibt, die die Leute definieren möchten - Sie müssen also auswählen,

Konsistenz innerhalb der Sprache. Einen Operator zu haben, der sich anders verhält, kann für den Programmierer überraschend sein. Java erlaubt Benutzern nicht, Operatoren zu überladen. Daher ist die Referenzgleichheit die einzig sinnvolle Bedeutung für ==Objekte.

Innerhalb von Java:

• ==Vergleicht zwischen numerischen Typen die numerische Gleichheit
• ==Vergleicht die boolesche Gleichheit zwischen booleschen Typen
• ==Vergleicht die Referenzidentität zwischen Objekten
  • Verwenden Sie .equals(Object o)Werte vergleichen

Das ist es. Einfache Regel und einfach zu identifizieren, was Sie wollen. Dies alles wird in Abschnitt 15.21 des JLS behandelt . Es enthält drei Unterabschnitte, die leicht zu verstehen, zu implementieren und zu verstehen sind.

Sobald Sie das Überladen von zulassen== , können Sie nicht mehr auf die JLS schauen und mit dem Finger auf ein bestimmtes Element zeigen und sagen, "so funktioniert es". Der Code ist möglicherweise schwer zu überlegen. Das genaue Verhalten von ==kann für einen Benutzer überraschend sein. Jedes Mal, wenn Sie es sehen, müssen Sie zurückgehen und überprüfen, was es tatsächlich bedeutet.

Da Java keine Überladung von Operatoren zulässt, muss ein Wertegleichheitstest möglich sein, mit dem Sie die Basisdefinition von überschreiben können. Daher wurde es von diesen Entwurfsentscheidungen beauftragt. ==In Java werden numerische Tests für numerische Typen, boolesche Gleichheit für boolesche Typen und Referenzgleichheit für alle anderen Tests (die überschreiben können .equals(Object o), was immer sie für die Wertgleichheit wollen) durchgeführt.

Hierbei handelt es sich nicht um "Gibt es einen Anwendungsfall für eine bestimmte Konsequenz dieser Entwurfsentscheidung", sondern um "Dies ist eine Entwurfsentscheidung, um diese anderen Dinge zu erleichtern. Dies ist eine Konsequenz daraus."

String-Internierung ist ein Beispiel dafür. Gemäß JLS 3.10.5 werden alle String-Literale interniert. Andere Zeichenketten werden interniert, wenn man sie aufruft .intern(). Dies "foo" == "foo"ist eine Konsequenz von Entwurfsentscheidungen, die getroffen wurden, um den von String-Literalen beanspruchten Speicherbedarf zu minimieren. Darüber hinaus ist das Internieren von Zeichenfolgen etwas auf der JVM-Ebene, das für den Benutzer ein wenig exponiert ist. In den allermeisten Fällen sollte es jedoch nicht den Programmierer betreffen (und Anwendungsfälle für Programmierer nicht) Dies stand für die Designer ganz oben auf der Liste, als sie diese Funktion in Betracht zogen.

Die Leute werden darauf hinweisen +und +=sind für String überladen. Das ist jedoch weder hier noch da. Es bleibt der Fall, ==dass eine andere Methode (die nur in String vorhanden ist) für die Referenzgleichheit benötigt wird, wenn der Wert für String (und nur für String) die Bedeutung Gleichheit hat. Darüber hinaus würde dies unnötigerweise Methoden verkomplizieren, die Object benötigen und erwarten ==, dass sie sich in die eine und .equals()in die andere Richtung verhalten, wobei die Benutzer alle diese Methoden für String in Sonderfällen ausführen müssen.

Der konsistente Vertrag für ==on Objects ist, dass es sich nur um Referenzgleichheit handelt und dass er .equals(Object o)für alle Objekte existiert, die auf Wertgleichheit getestet werden sollen . Dies zu komplizieren, kompliziert viel zu viele Dinge.

Java unterstützt das Überladen von Operatoren nicht, was bedeutet, dass es ==nur für primitive Typen oder Referenzen gilt. Alles andere erfordert den Aufruf einer Methode. Warum die Designer dies taten, ist eine Frage, die nur sie beantworten können. Wenn ich raten musste, liegt es wahrscheinlich daran, dass das Überladen von Operatoren Komplexität mit sich bringt, an deren Hinzufügen sie nicht interessiert waren.

Ich bin kein Experte für C #, aber die Designer dieser Sprache scheinen es so eingerichtet zu haben, dass jedes Primitiv ein Objekt ist structund jedes structein Objekt. Da C # das Überladen von Operatoren ermöglicht, ist es für jede Klasse sehr einfach String, sich mit jedem Operator auf die "erwartete" Weise arbeiten zu lassen. C ++ erlaubt dasselbe.

Dies wurde in anderen Sprachen anders gemacht.

In Object Pascal (Delphi / Free Pascal) und C # ist der Gleichheitsoperator definiert, um Werte und keine Referenzen zu vergleichen, wenn Zeichenfolgen verarbeitet werden.

Insbesondere in Pascal ist string ein primitiver Typ (eines der Dinge, die ich an Pascal sehr liebe, weil es einfach irritierend ist, NullreferenceException nur wegen eines nicht initialisierten Strings zu erhalten) und hat eine Schreib-Kopier-Semantik, die (die meiste Zeit) String-Operationen sehr macht billig (mit anderen Worten, erst bemerkbar, wenn Sie anfangen, Multi-Megabyte-Strings zu verketten).

Es ist also eine Entscheidung für das Sprachdesign in Java. Als sie die Sprache entwarfen, folgten sie dem C ++ - Weg (wie Std :: String), so dass Strings Objekte sind, was meiner Meinung nach ein Hack ist, um C zu kompensieren, dem ein realer String-Typ fehlt, anstatt Strings zu einem Primitiven zu machen (was sie sind).

Aus einem bestimmten Grund kann ich nur spekulieren, dass sie das so einfach gemacht haben und nicht, dass der Operator eine Ausnahme für den Compiler für Strings darstellt.

In Java gibt es keinerlei Überladung von Operatoren, weshalb die Vergleichsoperatoren nur für die primitiven Typen überladen sind.

Die 'String'-Klasse ist kein Grundelement, hat also keine Überladung für' == 'und verwendet die Standardeinstellung zum Vergleichen der Adresse des Objekts im Arbeitsspeicher des Computers.

Ich bin mir nicht sicher, aber ich denke, dass in Java 7 oder 8 Orakel eine Ausnahme im Compiler gemacht hat, str1 == str2als zu erkennenstr1.equals(str2)

Java wurde anscheinend entwickelt, um eine grundlegende Regel einzuhalten, wonach der ==Operator immer dann legal sein sollte, wenn ein Operand in den Typ des anderen konvertiert werden kann, und das Ergebnis einer solchen Konvertierung mit dem nicht konvertierten Operanden zu vergleichen.

Diese Regel ist für Java kaum einzigartig, hat jedoch einige weitreichende (und meiner Meinung nach bedauerliche) Auswirkungen auf die Gestaltung anderer typbezogener Aspekte der Sprache. Es wäre sauberer gewesen, das Verhalten in ==Bezug auf bestimmte Kombinationen von Operandentypen zu spezifizieren und Kombinationen der Typen X und Y zu verbieten, wo x1==y1und x2==y1würde dies nicht implizieren x1==x2, aber Sprachen, die dies selten tun, double1 == long1müssten entweder angeben, ob double1ist keine exakte Darstellung von long1oder lehnt die Kompilierung ab;int1==Integer1sollte verboten sein, aber es sollte ein praktisches und effizientes Nicht-Auslösemittel geben, um zu testen, ob ein Objekt eine Ganzzahl mit einem bestimmten Wert ist (ein Vergleich mit etwas, das keine Ganzzahl mit einem Kasten ist, sollte einfach zurückgeben false).

In Bezug auf das Anwenden des ==Operators auf Zeichenfolgen hätte Java, wenn direkte Vergleiche zwischen Operanden des Typs Stringund verboten worden wären Object, Überraschungen im Verhalten von ziemlich gut vermieden ==, aber es gibt kein Verhalten, das es für solche Vergleiche implementieren könnte, was nicht erstaunlich wäre. Es wäre weitaus weniger verwunderlich gewesen, wenn zwei Zeichenfolgenverweise, die in Typ gehalten werden, Objectsich anders verhalten als Verweise, die in Typ gehalten werden String, als wenn sich eines dieser Verhalten von dem eines legalen Vergleichs gemischter Typen unterscheidet. Wenn dies String1==Object1legal ist, würde dies bedeuten, dass die Verhaltensweisen von String1==String2und Object1==Object2nur übereinstimmen String1==Object1, wenn sie übereinstimmen.

Im Allgemeinen gibt es sehr gute Gründe, testen zu wollen, ob zwei Objektreferenzen auf dasselbe Objekt verweisen. Ich hatte viele Male, die ich geschrieben habe

Address oldAddress;
Address newAddress;
... populate values ...
if (oldAddress==newAddress)
... etc ...

In solchen Fällen kann ich eine gleiche Funktion haben oder auch nicht. In diesem Fall vergleicht die Funktion equals möglicherweise den gesamten Inhalt beider Objekte. Oft vergleicht es nur einen Bezeichner. "A und B sind Verweise auf dasselbe Objekt" und "A und B sind zwei verschiedene Objekte mit demselben Inhalt" sind natürlich zwei sehr unterschiedliche Ideen.

Es ist wahrscheinlich richtig, dass dies für unveränderliche Objekte wie Strings weniger ein Problem darstellt. Bei unveränderlichen Objekten neigen wir dazu, das Objekt und den Wert als dasselbe zu betrachten. Nun, wenn ich "wir" sage, meine ich zumindest "ich".

Integer three=new Integer(3);
Integer triangle=new Integer(3);
if (three==triangle) ...

Das ist natürlich falsch, aber ich kann sehen, dass jemand denkt, dass es wahr sein sollte.

Wenn Sie jedoch sagen, dass == Referenzhandles und nicht den Inhalt von Objekten im Allgemeinen vergleicht, wäre es möglicherweise verwirrend, einen Sonderfall für Strings zu erstellen. Wie jemand anderes hier sagte, was ist, wenn Sie die Handles zweier String-Objekte vergleichen möchten? Wäre es eine spezielle Funktion, die es nur für Strings gibt?

Und was ist mit ...

Object x=new String("foo");
Object y=new String("foo");
if (x==y) ...

Ist das falsch, weil es sich um zwei verschiedene Objekte handelt, oder wahr, weil es sich um Strings handelt, deren Inhalt gleich ist?

Also ja, ich verstehe, wie Programmierer dadurch verwirrt werden. Ich habe es selbst gemacht, ich meine schreiben, wenn meinString == "foo", wenn ich meinte, wenn meinString.equals ("foo"). Aber ohne die Bedeutung des Operators == für alle Objekte umzugestalten, verstehe ich nicht, wie man das anspricht.

Dies ist eine gültige Frage Strings, und zwar nicht nur für Streicher, sondern auch für andere unveränderliche Objekte repräsentieren einigen „Wert“, zum Beispiel Double, BigIntegerund sogar InetAddress.

Um den ==Operator mit Strings und anderen Wertklassen verwendbar zu machen, sehe ich drei Alternativen:

• Informieren Sie den Compiler über alle diese Wertklassen und die Art und Weise, wie deren Inhalte verglichen werden können. Wenn es nur eine Handvoll Klassen aus dem java.langPaket wäre, würde ich das in Betracht ziehen, aber Fälle wie InetAddress werden davon nicht abgedeckt.

• Ermöglichen Sie das Überladen von Operatoren, damit eine Klasse ihr ==Vergleichsverhalten definiert .

• Entfernen Sie die öffentlichen Konstruktoren und lassen Sie statische Methoden Instanzen aus einem Pool zurückgeben, wobei immer dieselbe Instanz für denselben Wert zurückgegeben wird. Um Speicherverluste zu vermeiden, benötigen Sie SoftReferences im Pool, die in Java 1.0 nicht vorhanden waren. Aus Gründen der Kompatibilität können die String()Konstruktoren jetzt nicht mehr entfernt werden.

Das Einzige, was heute noch getan werden könnte, wäre das Überladen von Operatoren, und ich persönlich möchte nicht, dass Java diesen Weg einschlägt.

Für mich ist die Lesbarkeit des Codes am wichtigsten, und ein Java-Programmierer weiß, dass die Operatoren eine feste Bedeutung haben, die in der Sprachspezifikation definiert ist, wohingegen Methoden durch Code definiert sind und ihre Bedeutung im Javadoc der Methode nachgeschlagen werden muss. Ich möchte bei dieser Unterscheidung bleiben, auch wenn dies bedeutet, dass Zeichenfolgenvergleiche den ==Operator nicht verwenden können.

Es gibt nur einen Aspekt von Javas Vergleichen, der mich nervt: den Effekt von Auto-Boxing und -unboxing. Es verbirgt die Unterscheidung zwischen dem primitiven und dem Wrapper-Typ. Aber wenn Sie sie mit vergleichen ==, sind sie sehr unterschiedlich.

    int i=123456;
    Integer j=123456;
    Integer k=123456;
    System.out.println(i==j);  // true or false? Do you know without reading the specs?
    System.out.println(j==k);  // true or false? Do you know without reading the specs?