Java-Zeichenfolgen: "String s = new String("albern");"

Question

Ich bin ein C++-Typ, der Java lernt. Ich lese Effective Java und etwas hat mich verwirrt. Es sagt, man solle niemals Code wie diesen schreiben:

String s = new String("silly");

Da es unnötige String-Objekte erstellt. Stattdessen sollte es so geschrieben werden:

String s = "Nicht mehr albern";

Ok bis hierher ... Aber, gegeben diese Klasse:

public final class CaseInsensitiveString {
    private String s;
    public CaseInsensitiveString(String s) {
        if (s == null) {
            throw new NullPointerException();
        }
        this.s = s;
    }
    :
    :
}

CaseInsensitiveString cis = new CaseInsensitiveString("Polnisch");
String s = "polnisch";

1. Warum ist die erste Aussage in Ordnung? Sollte es nicht sein

   CaseInsensitiveString cis = "Polnisch";

2. Wie mache ich CaseInsensitiveString so, dass es sich wie String verhält, damit die obige Aussage in Ordnung ist (mit und ohne Erweiterung von String)? Was macht String zu etwas, das es erlaubt, einfach einen Literal zu übergeben? Nach meinem Verständnis gibt es kein Konzept des "Kopierkonstruktors" in Java?

Answer 1

String ist eine spezielle integrierte Klasse der Sprache. Es handelt sich nur um die String-Klasse, bei der du vermeiden solltest, zu sagen

String s = new String("Polish");

Weil das Literal "Polish" bereits vom Typ String ist und du dadurch ein zusätzliches unnötiges Objekt erstellst. Für jede andere Klasse ist es korrekt (und in diesem Fall die einzige Aktion), zu sagen

CaseInsensitiveString cis = new CaseInsensitiveString("Polish");

ist das Richtige zu tun.

Answer 2

Ich glaube, der Hauptvorteil der Verwendung der Literalform (dh "foo" statt new String("foo")) besteht darin, dass alle String-Literale von der VM 'interned' werden. Mit anderen Worten, es wird zu einem Pool hinzugefügt, so dass jeder andere Code, der dieselbe Zeichenkette erstellt, die gepoolte Zeichenkette anstelle einer neuen Instanz verwendet.

Zur Veranschaulichung: Der folgende Code gibt true für die erste Zeile aus, aber false für die zweite:

System.out.println("foo" == "foo");
System.out.println(new String("bar") == new String("bar"));

Answer 3

Saiten werden in Java etwas speziell behandelt, sie sind unveränderlich, sodass es sicher ist, sie durch Referenzzählung zu handhaben.

Wenn Sie Folgendes eingeben

String s = "Polish";
String t = "Polish";

dann beziehen sich s und t tatsächlich auf dasselbe Objekt, und s==t gibt true zurück, für "==" für Objekte bedeutet "ist dasselbe Objekt" (oder kann es sowieso, ich bin mir nicht sicher, ob dies Teil der tatsächlichen Sprachspezifikation ist oder einfach ein Detail der Compiler-Implementierung - also vielleicht ist es nicht sicher, sich darauf zu verlassen) .

Wenn Sie Folgendes eingeben

String s = new String("Polish");
String t = new String("Polish");

dann s!=t (weil Sie explizit eine neue Zeichenfolge erstellt haben), obwohl s.equals(t) true zurückgibt (weil String dieses Verhalten zu equals hinzufügt).

Das, was Sie schreiben möchten,

CaseInsensitiveString cis = "Polish";

funktioniert nicht, weil Sie denken, dass die Anführungszeichen eine Art Kurzschlusskonstruktor für Ihr Objekt sind, wenn dies tatsächlich nur für normale java.lang.Strings funktioniert.

Answer 4

String s1="foo";

der Literal landet im Pool und s1 wird darauf verweisen.

String s2="foo";

Dieses Mal wird überprüft, ob der Literal "foo" bereits im StringPool vorhanden ist, da er jetzt existiert, wird s2 auf denselben Literal verweisen.

String s3=new String("foo");

Der Literal "foo" wird zuerst im StringPool erstellt, dann wird durch den String-Argument-Konstruktor ein String-Objekt erstellt, d.h. "foo" im Heap aufgrund der Objekterstellung durch den new-Operator, dann wird s3 darauf verweisen.

String s4=new String("foo");

genau wie s3

also System.out.println(s1==s2);// **true** aufgrund des Literalvergleichs.

und System.out.println(s3==s4);// **false** aufgrund des Objektvergleichs

(s3 und s4 werden an unterschiedlichen Orten im Heap erstellt)

Answer 5

Strings sind in Java speziell - sie sind unveränderlich, und Zeichenkettenkonstanten werden automatisch in String-Objekte umgewandelt.

Es gibt keine Möglichkeit für Ihr SomeStringClass cis = "value"-Beispiel, auf eine andere Klasse anzuwenden.

Sie können auch nicht String erweitern, da es als final deklariert ist, was bedeutet, dass keine Unterklassierung erlaubt ist.