Java "gleich" und "==" Ähnlichkeiten
Lassen Sie uns zunächst kurz über "Gleich" und "==" sprechen
== Die Operation vergleicht, ob die Werte der beiden Variablen für den Basis -Datentyp gleich sind.
Als Referenzvariablen bedeutet dies, ob die im Haufen gespeicherten Adressen gleich sind,
Ist der Inhalt im Stapel gleich?
Ob die beiden durch die Equals Operation dargestellten Variablen Referenzen auf dasselbe Objekt sind, sind
Das heißt, ob der Inhalt im Haufen gleich ist.
Zusammenfassend vergleicht == die Adressen von 2 Objekten, während Equals den Inhalt von 2 Objekten vergleicht.
Lassen Sie mich kurz die Saitenklasse vorstellen
Die String -Klasse wird auch als unveränderliche Zeichensequenz bezeichnet
String verwendet einen privaten endgültigen Charwert [], um die Speicherung von Zeichenfolgen zu realisieren. Das heißt, nachdem das String -Objekt erstellt wurde, kann der in diesem Objekt gespeicherte String -Inhalt nicht geändert werden. Die String -Klasse verfügt über eine spezielle Erstellungsmethode, bei der "Doppelzitate" zum Erstellen verwendet werden sollen. Zum Beispiel erstellt New String ("123") 2 String -Objekte, einer wird durch "123" durch "" Double Quotes erstellt, und das andere wird von neu erstellt. Die Zeiträume, die sie erzeugen, sind jedoch unterschiedlich, eine ist die Zusammenstellungsperiode und die andere ist die Laufzeit. Java überlädt den + Bediener für den String -Typ und Sie können direkt + verwenden, um zwei Zeichenfolgen zu verkettet. Wenn Sie die Praktikum () -Methode der String -Klasse während der Laufzeit aufrufen, können Sie Objekte zum String -Pool dynamisch hinzufügen.
Unterscheiden Sie zwischen zwei Methoden zum Erstellen von String -Objekten "" und neu ()
String sind spezielle Verpackungsdaten. Kann verwendet werden:
String str1 = new String ("123"); String str2 = "123";Erstellen Sie zwei Formen
Der erste besteht darin, New () zu verwenden, um ein neues Objekt zu erstellen, das im Haufen gespeichert wird. Jedes Mal, wenn es aufgerufen wird, wird ein neues Objekt erstellt. (Es ist tatsächlich zwei, wie oben erwähnt, aber nach der Existenz von "123" im konstanten Pool wird das neue "123" nicht mehr im konstanten Pool erstellt.)
Der zweite Typ besteht darin, zuerst eine variable STR zum Objekt der String -Klasse im Stapel zu erstellen und dann eine symbolische Referenz zu verwenden, um herauszufinden, ob es im String Constant Pool "ABC" gibt. Wenn nicht, speichern Sie "ABC" in den String Constant Pool und lassen Sie String auf "ABC" zeigen. Wenn es bereits "ABC" vorhanden ist, lassen Sie STR direkt auf "ABC" verweisen.
Wir sollten zu diesem Zeitpunkt aufpassen
Einerseits ist die erste Schreibmethode vorteilhaft und spart Speicherplatz. Gleichzeitig kann es die Laufgeschwindigkeit des Programms bis zu einem gewissen Grad verbessern, da die JVM automatisch entscheidet, ob es erforderlich ist, ein neues Objekt basierend auf der tatsächlichen Situation der Daten im Stapel zu erstellen. Für den Code von String Str = New String ("123"), werden neue Objekte im Heap erstellt, unabhängig davon, ob die Stringwerte gleich sind oder nicht, ob es erforderlich ist, neue Objekte zu erstellen, wodurch die Belastung des Programms erhöht wird. Wenn wir andererseits eine Klasse unter Verwendung eines Formats wie String Str = "123" definieren, halten wir es immer als selbstverständlich an, dass wir ein Objekt -STR der String -Klasse erstellen.
Das Objekt wurde möglicherweise nicht erstellt! Und vielleicht nur auf ein Objekt verweisen, das zuvor erstellt wurde. Nur durch die neue () -Methode kann wir sicherstellen, dass jedes Mal ein neues Objekt erstellt wird.
Bitte beachten Sie das folgende Beispiel
Paketteststring; public class testString {public static void main (String [] args) {String a = "123"; Zeichenfolge b = "123"; System.out.println (a == b); System.out.println (A.Equals (b)); System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And Der Inhalt der beiden referenzierten Objekte im Heap ist der gleiche, so A.Equals (b) true */ string c = new String ("1234"); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Das gleiche wie D Heap, also ist C.Equals (d) wahr */ String e = "a1"; Zeichenfolge f = "a" +1; System.out.println (e == f); System.out.println (E.Equals (f)); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------. * Ja, die Überlastung von Operationen selbst hat die Überlastung des Bedieners, der sich im Gegensatz zu C ++ definiert "H"; System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!