Teilen Sie einige Quellcode-Interpretationen von Java String

Damit Sie einen Artikel über die teilweise Interpretation des Java-String-Quellcodes verstehen, werfen wir einen Blick darauf mit dem Editor

Mitgliedsvariablen vom Typ String

/** String的属性值 */  
    private final char value[];    /** The offset is the first index of the storage that is used. */
    /**数组被使用的开始位置**/
    private final int offset;    /** The count is the number of characters in the String. */
    /**String中元素的个数**/
    private final int count;    /** Cache the hash code for the string */
   /**String类型的hash值**/
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

Mit den oben genannten Mitgliedsvariablen können Sie wissen, dass der Wert der String-Klasse endgültig ist und nicht geändert werden kann. Solange sich also ein Wert ändert, wird ein neues Objekt vom Typ String generiert und gespeichert Zeichenfolgendaten beginnen nicht unbedingt am ersten Punkt im Array mit 0 Elementen, sondern beginnen an dem Element, auf das der Offset zeigt.

Der folgende Code generiert ein neues Objekt und das Endergebnis ist ein neuer String-Wert mit dem neuen Wert „bbaa“.

     String a = new String("bb");
     String b = new String("aa");
     String c =  a + b;

Man kann auch sagen, dass die Länge von Objekten vom Typ String unveränderlich ist und jedes Mal ein neues Objekt generiert, sodass die Effizienz des Zusammenfügens von Zeichenfolgen definitiv nicht so hoch ist wie die von Variablen Die Länge von StringBuffer und StringBuilder ist schnell.

In der folgenden Situation werden jedoch zwei Zeichenfolgen schnell gespleißt:

    String a = "aa" + "bb";

Der Grund dafür ist: Java hat eine kleine Optimierung für das direkte Spleißen von „aa“ und „bb“ vorgenommen " in „aabb“ umwandeln und dann den Wert a zuweisen. Sie müssen das String-Objekt nur einmal generieren, was im Vergleich zur oben genannten Methode die doppelte Generierung von String einspart und offensichtlich viel effizienter ist.

Werfen wir einen Blick auf einige der gängigen Konstruktionsmethoden von String

1. Parameterlose Konstruktionsmethode:

public String() {    this.offset = 0;    this.count = 0;    this.value = new char[0];    }

2. Übergeben Sie den Konstruktor eines String-Objekts

public String(String original) {    int size = original.count;    char[] originalValue = original.value;    char[] v;      if (originalValue.length > size) {         // The array representing the String is bigger than the new         // String itself.  Perhaps this constructor is being called         // in order to trim the baggage, so make a copy of the array.
            int off = original.offset;
            v = Arrays.copyOfRange(originalValue, off, off+size);
     } else {         // The array representing the String is the same         // size as the String, so no point in making a copy.
        v = originalValue;
     }    this.offset = 0;    this.count = size;    this.value = v;
    }

3. Übergeben Sie den Konstruktor eines Zeichenarrays

public String(char value[]) {    int size = value.length;    this.offset = 0;    this.count = size;    this.value = Arrays.copyOf(value, size);
    }

4. Übergeben Sie eine Zeichen-String-Nummer, Startelement , und Anzahl der Elementkonstruktoren

public String(char value[], int offset, int count) {        if (offset < 0) {            throw new StringIndexOutOfBoundsException(offset);
        }        if (count < 0) {            throw new StringIndexOutOfBoundsException(count);
        }        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {            throw new StringIndexOutOfBoundsException(offset + count);
        }        this.offset = 0;        this.count = count;        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

Aus den oben genannten allgemeinen Konstruktoren können wir ersehen, dass wir beim Generieren eines String-Objekts den Offset festlegen müssen. Die drei Attribute count und value werden zugewiesen, damit wir kann einen vollständigen String-Typ erhalten.

Allgemeine Funktionen:

1. Funktion zur Bestimmung, ob zwei Zeichenfolgen gleich sind (Gleich): Tatsächlich dient sie zunächst dazu, festzustellen, ob die Vergleichsinstanz vom Typ String ist Daten, nicht Geben Sie dann False zurück, wenn sie jedes Zeichenelement vergleichen, um zu sehen, ob sie gleich sind. Wenn sie gleich sind, geben Sie True zurück, andernfalls geben Sie False zurück

public boolean equals(Object anObject) { if (this == anObject) {     return true;
 } if (anObject instanceof String) {
     String anotherString = (String)anObject;     int n = count;     if (n == anotherString.count) {  char v1[] = value;  char v2[] = anotherString.value;  int i = offset;  int j = anotherString.offset;  while (n-- != 0) {      if (v1[i++] != v2[j++])   return false;
  }  return true;
     }
 } return false;
    }

2. Funktion zum Vergleichen der Größen von zwei Zeichenfolgen (compareTo): Die Eingabe besteht aus zwei Zeichenfolgen. Die zurückgegebene 0 bedeutet, dass die beiden Zeichenfolgen den gleichen Wert haben. Die Rückgabe von weniger als 0 bedeutet, dass der Wert der ersten Zeichenfolge kleiner ist als der Wert der zweiter String. Wenn er größer als 0 ist, bedeutet dies, dass der Wert des ersten Strings größer als der Wert des zweiten Strings ist.

Der Vergleichsprozess läuft im Wesentlichen wie folgt ab: Beginnend mit dem ersten Element der beiden Zeichenfolgen ist der eigentliche Vergleich der ACII-Code der beiden Zeichen. Wenn unterschiedliche Werte hinzugefügt werden, wird der erste unterschiedliche Wert angezeigt zurückgegeben. Differenz, andernfalls 0 zurückgeben

public int compareTo(String anotherString) { int len1 = count; int len2 = anotherString.count; int n = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; if (i == j) {     int k = i;     int lim = n + i;     while (k < lim) {  char c1 = v1[k];  char c2 = v2[k];  if (c1 != c2) {      return c1 - c2;
  }
  k++;
     }
 } else {     while (n-- != 0) {  char c1 = v1[i++];  char c2 = v2[j++];  if (c1 != c2) {      return c1 - c2;
  }
     }
 } return len1 - len2;
    }

Code anzeigen

3. Bestimmen Sie, ob eine Zeichenfolge mit einer Präfixzeichenfolge beginnt und der Offset dieselbe Länge hat

public boolean startsWith(String prefix, int toffset) { char ta[] = value; int to = offset + toffset; char pa[] = prefix.value; int po = prefix.offset; int pc = prefix.count; // Note: toffset might be near -1>>>1.
 if ((toffset < 0) || (toffset > count - pc)) {     return false;
 } while (--pc >= 0) {     if (ta[to++] != pa[po++]) {         return false;
     }
 } return true;
    } public int hashCode() { int h = hash; if (h == 0) {     int off = offset;     char val[] = value;     int len = count;            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }        return h;
    }

4. Zwei Strings verbinden (concat)

public String concat(String str) { int otherLen = str.length(); if (otherLen == 0) {     return this;
 } char buf[] = new char[count + otherLen];
 getChars(0, count, buf, 0);
 str.getChars(0, otherLen, buf, count); return new String(0, count + otherLen, buf);
    }

Mehrere Möglichkeiten, Strings zu verbinden

1. Am direktesten verwenden Sie +, um direkt zu verbinden

     String a = new String("bb");
     String b = new String("aa");
     String c =  a + b;

2. Verwenden Sie die concat (String)-Methode

      String a = new String("bb");
      String b = new String("aa"); 
      String d = a.concat(b);

3. Verwenden Sie StringBuilder

 String a = new String("bb");
 String b = new String("aa");
     
StringBuffer buffer = new StringBuffer().append(a).append(b);

Die erste und zweite Methode werden häufiger verwendet, aber die Effizienz ist höher relativ schlecht. Die Verwendung von StringBuilder zum Spleißen ist effizienter.

【Verwandte Empfehlungen】

1. Ist String ein Objekt oder eine Klasse in Java? Detaillierte Erklärung von String in Java

2.

Zusammenfassung der Beispiel-Tutorials der String-Klasse in Java

3. Was sind die gängigen Methoden? String-Klasse in Java? Fassen Sie die gängigen Methoden der String-Klasse in Java zusammen

4

Teilen Sie Beispiel-Tutorials der String-Klasse in Java

Das obige ist der detaillierte Inhalt vonTeilen Sie einige Quellcode-Interpretationen von Java String. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!