[Java] Ich fühlte mich als Java-Anfänger. "Warum wird das erste Zeichen nur im String-Typ großgeschrieben?" Ich sah mich dem String-Typ gegenüber.

Einführung

Dies ist ein Memo von dem, was ich gelernt habe, um mein Verständnis für den Umgang mit dem String-Typ zu vertiefen, während ich lernte, die Java-Silber-Qualifikation zu erwerben. Ich würde mich freuen, wenn Sie auf Fehler bei der Interpretation hinweisen könnten.

Der Zeichenfolgentyp scheint ein Referenztyp zu sein, kein grundlegender Datentyp

Bei der Definition der Variablen habe ich den Datentyp wie "int", "double", "boolean", "char" angegeben und die Variable definiert. Bei der Definition einer Variablen, die Zeichenfolgen auf die gleiche Weise behandelt, war es ganz natürlich, den Typ "Zeichenfolge" anzugeben und die Variable zu definieren.

So ↓

Variablendefinition.java

int i = 100
 // ->Ersetzen Sie den Typ int durch Ganzzahl 100, der Ganzzahlen verarbeiten kann
char c = 'Ah'
 /* ->Zeichentyp, der Zeichen verarbeiten kann`Ah`Ersatz
Für den Zeichentyp einfaches Anführungszeichen anstelle von doppeltem Anführungszeichen*/
double d = 10.0
 // ->10 für "Gleitkommatyp", der Dezimalstellen verarbeiten kann.Ersatz 0
String s = "Es ist eine Zeichenkette."
 /* ->Zeichenfolgentyp, der Zeichenfolgen verarbeiten kann"Es ist eine Zeichenkette."Ersatz
Doppelte Anführungszeichen anstelle von einfachen Anführungszeichen für String*/

Ich habe mich jedoch immer gefragt. Das heißt ** "Warum beginnt nur der String-Typ mit einem Großbuchstaben?" **

Es gibt grundlegende Datentypen und Referenztypen

** "Warum beginnt nur der String-Typ mit Großbuchstaben?" ** Die Antwort war, dass der String-Typ ** kein Basisdatentyp ** ist. Mit anderen Worten, der Typ ** String war eine Klasse **. Klar, der erste Buchstabe der Klasse ist groß geschrieben, verstehe ich! Ich bin überzeugt.

Werfen Sie einen Blick in die String-Klasse

String ist eine Klasse. Wenn ja, können Sie den Inhalt sehen. Wenn Sie sich also den Inhalt der String-Klasse ansehen, hat eines der Instanzfelder diese Definition.

String.java

private final char value[];

Dies ist ein Array des Basisdatentyps "char type"! Es scheint also, dass die Identität von String eine Reihe von Arrays vom Basisdatentyp "char type" war. Mit anderen Worten, der String s =" string ". Definiert in der variable definition.java früher.

private final char value[] = {'Satz','Charakter','Säule','damit','Su','。'}

Das war's.

Es scheint, dass es nicht nur String-Typen gibt, sondern auch StringBuilder-Typen.

Wenn Sie so lernen, gibt es auch einen anderen StringBuilder als String.

Was ist der Unterschied?

Das verstehe ich an dieser Stelle.

~~ Es war nicht genug, um daraus einen Tisch zu machen ... ~~

Wie bei der Art und Weise, wie Daten behandelt werden, unterscheiden sich die Klassen in erster Linie, und auch die bereitgestellten Methoden unterscheiden sich.

Deklaration von Variablen

Die Methode der Variablendefinition wird zwischen String und StringBuilder festgelegt.

Variablendefinition.java

String a = "AIUEO"; // ->es kann
String b = new String("Kakikukeko");  // ->es kann
StringBuilder c = "SA Shi Su Se So."; // ->Kann nicht
StringBuilder d = "TA Chi Tsu Te zu"; // ->es kann

Was ist der Unterschied zwischen der Deklarationsmethode für den String-Typ?

Es scheint, dass die Art und Weise der Verwaltung von Zeichenketten unterschiedlich ist. Wenn new nicht verwendet wird, wird eine Zeichenfolge für den von der String-Klasse verwalteten Bereich vorbereitet. Wenn Sie new verwenden, wird eine Zeichenfolge getrennt von dem von der String-Klasse verwalteten Bereich erstellt.

Selbst wenn es sich um denselben String-Typ handelt, scheint es, als würde eine String-Variable eines Wolfes erstellt, wenn Sie ihn mit new definieren. Sie können sich wahrscheinlich vorstellen, wie es anders sein wird, wenn Sie die Methode intern () der String-Klasse verwenden. (Siehe unten)

Informationen zur Neuzuweisung zu Variablen

"Kannst du nicht einer Variablen zuordnen? Nein. Das kannst du!" Diejenigen, die das glauben. nicht wahr. Ich fühle mich wie es definitiv getan ist

Variable Neuzuweisung.java

String a = "AIUEO";
a = "Kakikukeko";
// ->Der Inhalt von a"Kakikukeko"werden

Dies wird jedoch nicht umgeschrieben, aber es scheint, dass das Referenzziel von a ** von "aiueo" auf "kakikukeko" ** umgeschaltet wird.

Streng genommen wird es also nicht umgeschrieben, sondern umgeschaltet. wie es scheint.

Informationen zum Vergleich von Zeichenfolgentypen

Ich denke, dass es notwendig sein kann, Zeichenfolgen vom Typ String für die Implementierung zu vergleichen. In einem solchen Fall ist es üblich, den Vergleichsoperator zu verwenden, aber im Fall des String-Typs verwenden Sie anstelle des Vergleichsoperators die Methode equals ().

Ist es Naze?

Aus der Schlussfolgerung geht hervor, dass der Vergleichsoperator ** den Referrer ** vergleicht. Einfacher ausgedrückt sind s1 und s2 dasselbe "aiueo", aber wenn s1 == s2 ist, wird es in einigen Fällen falsch.

Zeichenfolgenvergleich mit Vergleichsoperator.java

package sample20200728;

public class Sample02 {
    public static void main(String[] args){
        String s1 = new String("Ah");
        String s2 = "Ah";
        String s3 = "Ah";

        //Vergleichen Sie s1 und s2 mit dem Vergleichsoperator
        if(s1 == s2){
            System.out.println("Die Zeichenfolgen für s1 und s2 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s1 und s2 sind unterschiedlich");
        }

        //Vergleichen Sie s1 und s3 mit dem Vergleichsoperator
        if(s1 == s3){
            System.out.println("Die Zeichenfolgen für s1 und s3 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s1 und s3 sind unterschiedlich");
        }

        //Vergleichen Sie s2 und s3 mit dem Vergleichsoperator
        if(s2 == s3){
            System.out.println("Die Zeichenfolgen für s2 und s3 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s2 und s3 sind unterschiedlich");
        }
    }
}

** Ausgabeergebnis ** Die Saiten sind gleich, aber einige sind unterschiedlich. Wurde verweigert. Dies scheint ein Vergleichsoperator zu sein, der Referrer vergleicht, ohne Zeichenfolgen zu vergleichen.

Ich denke, dies ist in Ordnung, wenn entschieden wird, ob die Referenzquellen identisch sind, aber unter Berücksichtigung der tatsächlichen Operation, ob die Zeichenfolgen übereinstimmen. Überprüfst du oft? Ich denke. Wenn in diesem Fall false zurückgegeben wird, weil die Referenzquelle unterschiedlich ist, obwohl die Zeichenfolgen identisch sind, führt dies zu einem Fehler, oder?

Die Details sind mir egal. Alles was Sie tun müssen, ist die Saiten abzugleichen! Die männliche Methode equals () ist aktiv.

equals()Vergleich in.java

public class Sample02 {
    public static void main(String[] args){
        String s1 = new String("Ah");
        String s2 = "Ah";
        String s3 = "Ah";

        //Vergleichen Sie s1 und s2 mit der Methode equals
        if(s1.equals(s2)){
            System.out.println("Die Zeichenfolgen für s1 und s2 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s1 und s2 sind unterschiedlich");            
        }

        //Vergleichen Sie s1 und s3 mit der Methode equals
        if(s1.equals(s3)){
            System.out.println("Die Zeichenfolgen für s1 und s3 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s1 und s3 sind unterschiedlich");            
        }

        //Vergleichen Sie s2 und s3 mit der Methode equals
        if(s2.equals(s3)){
            System.out.println("Die Zeichenfolgen für s2 und s3 sind gleich");
        }else{
            System.out.println("Die Zeichenketten von s2 und s3 sind unterschiedlich");            
        }
    }
}

** Ausführungsergebnis **

Jep. Sie vergleichen die Zeichenketten gut!

Bonus Praktikant Methode

Die String-Klasse verfügt über eine interne Methode. In der Beschreibung der Methode heißt es: "Gibt eine eindeutige Zeichenfolge im Zeichenfolgenpool zurück." Auf Japanisch k.

Aber ich dachte, dass es im Java-Test erscheinen würde.

Ich habe den Quellcode geschrieben, um die interne Methode zu verstehen

"Die Zeichenfolge mit dem ersten Rang im Zeichenfolgenpool zurückgeben" kam mir überhaupt nicht in den Sinn, also habe ich die Quelle geschrieben und das Verhalten überprüft.

Was ich verstehen konnte, ist so

1. Die Methode intern () prüft, ob die Zielzeichenfolge im Bereich des Typs String vorhanden ist. Wenn es den gleichen String gibt-> Beziehen Sie sich darauf. ** Bild, das wiederverwendet werden kann ** Wenn es nicht dieselbe Zeichenfolge gibt-> Bereiten Sie die Zeichenfolge im Bereich des Zeichenfolgentyps vor.
2. Wenn Sie beim Definieren einer Zeichenfolgentypvariablen einen Wert mit new definieren, liegt dies außerhalb der Zuständigkeit des Bereichs des Zeichenfolgentyps. -> Intenr () kann nicht verwendet werden, um die Referenzquelle identisch zu machen

intern().java

public class Sample01 {
    public static void main(String[] args){

        String s1 = new String("Prüfung"); //Bereich der String-Typklasse"Draußen"Mit s1 Variable"Prüfung"Erstellen
        String s2 = s1.intern();  /* s1.intern()Vom Rückgabewert von"Prüfung"Ist s2 zugeordnet.
Da s1 jedoch mit new erstellt wird, handelt es sich um eine Zeichenfolge, die außerhalb des Bereichs der String-Typklasse erstellt wurde, also innerhalb der String-Typklasse."Prüfung"Ist nicht vorhanden.
In diesem Fall intern()Im Bereich der String-Typ-Klasse zum Zeitpunkt mit"Prüfung"Bereiten Sie die Zeichenfolge vor*/
        String s3 = "Mumumu"; //Bereich der String-Typklasse"Innerhalb"Mit s3 Variable"Mumumu"Erstellen
        String s4 = s3.intern(); /*s3.intern()Vom Rückgabewert von"Mumumu"Ist s3 zugeordnet.
Im Gegensatz zu s1 befindet sich s3 im Bereich der String-Typklasse"Mumumu"Ich habe es schon geschafft"Mumumu"(Das heißt, nicht nur die Zeichenfolge, sondern auch der Ort, auf den verwiesen werden soll)*/
        
        System.out.println("s1 ist eine Variable mit new" + s1);
        System.out.println("s2 ist s1.intern()Variable, zu der der Rückgabewert von" + s2);
        System.out.println("s3 ist\"Mumumu\"Variable zu welcher" + s3);
        System.out.println("s4 ist s3.intenr()Variable, zu der der Rückgabewert von" + s4);   

        //Neu gemacht"Prüfung"Und s1.intern()Gemacht mit"Prüfung"Vergleichen Sie
        if(s1 == s2){
            System.out.println("true:Die Referenzen für s1 und s2 sind gleich");
        }else{
            //Da das Referenzziel von s1 und s2 unterschiedlich ist, wird es falsch
            System.out.println("false:Referenzen für s1 und s2 sind unterschiedlich");
        }

        //S3 wurde unter Verwendung des vom Typ String verwalteten Bereichs vorbereitet"Mumumu"Und s3.intern()Abholt bei"Mumumu"Vergleiche s4 mit
        if(s3 == s4){
            //s3,Beide s4 werden aus dem Bereich String-Typ für s4 s3 generiert.intern()Wird unter Bezugnahme auf die Zeichenkette von s3 in zugewiesen
            System.out.println("true:Die Referenzen für s3 und s4 sind gleich");
        }else{
            System.out.println("false:Referenzen für s3 und s4 sind unterschiedlich");
        }

        /*s2 ist"Prüfung"Wird im Bereich der String-Typklasse erstellt
Daher s5= s2.intern()Dann bezieht sich s5 auf dasselbe wie s2.*/
        String s5 = s2.intern();

        //Überprüfen Sie, ob die Referrer von s2 und s5 identisch sind
        if(s2 == s5){
            //s2.intern()Da es s5 mit zugewiesen wird, ist die Referenzquelle dieselbe.
            System.out.println("true:Die Referenzen für s2 und s5 sind gleich");
        }else{
            System.out.println("false:Referenzen für s2 und s5 sind unterschiedlich");
        }
        System.out.println("============");
    }
}

** Ausführungsergebnis **

Egal wie Sie kämpfen, s1, das in new definiert ist, gehört nicht zur Gruppe.

Ende

Das Obige ist der Inhalt des String-Typs. Es gibt viele Dinge, die ich noch nicht verstanden habe, daher bin ich mir sicher, dass es einige Missverständnisse gibt. In diesem Fall entschuldigen wir uns für die Unannehmlichkeiten, aber wir würden uns freuen, wenn Sie darauf hinweisen könnten.

Dann danke m (_ _) m