Irgendwie habe ich beschlossen, auch die JDK-Quelle zu lesen. Trotzdem habe ich keine Zeit, jede Zeile sorgfältig zu lesen, also habe ich sie kurz gelesen und diesen Code gefunden. Das letzte Mal ich habe die Quelle von Long gelesen, also als nächstes String.
Die String-Klasse ist eine String-Klasse. Da wir Byte, Short, Integer und Long entwickelt haben, kann man sagen, dass String auch eine Wrapper-Klasse für char [] ist. Na dann das Feld.
String.java
private final char value[];
private int hash; // Default to 0
public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();
Es gibt char [], das der Hauptteil der Zeichenfolge ist. Hash wird nur im folgenden Konstruktor zugewiesen. Ansonsten bleibt es 0.
String.java
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
Berechnet, wenn die Länge der Zeichenfolge größer als 0 ist und Hash 0 ist, wenn die hashCode-Methode aufgerufen wird. Wenn der zufällig berechnete Hash-Wert 0 ist, sollte er meiner Meinung nach nicht jedes Mal berechnet werden, aber das ist unwahrscheinlich.
String.java
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
Es gab eine Konstante namens CASE_INSENSITIVE_ORDER. Ich habe mich gefragt, ob es in letzter Zeit möglich war, aber es war von JDK 1.2.
Die Längenmethode gibt die Länge zurück. C-like strlen sucht jedes Mal bis zu NULL Zeichen, aber Java gibt nur die Größe des Arrays zurück. Dies bedeutet, dass der Wert die perfekte Größe sichert. Nun, es ist unveränderlich, so dass Sie keinen Spielraum haben müssen.
String.java
public int length() {
return value.length;
}
IsEmpty wurde seit JDK 1.6 hinzugefügt.
String.java
public boolean isEmpty() {
return value.length == 0;
}
Der Inhalt ist der gleiche wie length () == 0, aber es ist eine sehr Java-ähnliche Methode, die anhand des Booleschen Typs beurteilt werden kann, ohne die Größe des numerischen Werts zu vergleichen.
charAt ist eine Methode, um jeweils ein Zeichen abzurufen, und toCharArray ist eine Methode, um einen Stapel von Arrays abzurufen.
String.java
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}
charAt ruft Elemente nur durch Abonnement des Arrays ab, toCharArray sichert jedoch ein anderes Array derselben Größe und kopiert es. Sofern es keinen besonderen Grund gibt, ist es besser, mit charAt zuzugreifen, indem Sie sich mit der for-Anweisung an length () wenden.
Übrigens habe ich in den Quellen anderer Leute gesehen, dass Sie es mit str.split ("") in eine einzelne Zeichenkette aufteilen können; aber stoppen Sie es so. Dies bedeutet, dass Sie Zeichenfolgeninstanzen nur für die in der Zeichenfolge enthaltenen Zeichentypen erstellen können.
Es gibt eine interne Methode. Um ehrlich zu sein, möchte ich, dass Sie damit aufhören. Die Implementierung ist eine native Methode. Es fühlt sich an, als würde ich den Referenzwert intern ausführen.
String.java
public native String intern();
Wie benutzt man Praktikanten ...
Main.java
public static void main(String[] args) {
String s01 = "abc";
String s02 = "abcdef".substring(0, 3);
System.out.println(s01 == s02);
System.out.println(s01.equals(s02));
String s03 = s02.intern();
System.out.println(s01 == s03);
System.out.println(s01.equals(s03));
}
Wenn du rennst ...
false
true
true
true
Der Referenzwert ist unterschiedlich, wenn Teilzeichenfolgen verwendet werden, aber der Referenzwert ist der gleiche, wenn intern verwendet wird.
Hier ist die gleiche Methode,
String.java
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
Achten Sie am Anfang auf dieses == anObject. Anstatt immer den Vergleichsoperator == unter der Voraussetzung zu schreiben, dass alles intern ist, ist es schneller, wenn es intern und dieselbe Instanz ist, wenn Sie es vorerst gleich schreiben.
Bei gleich wird die Schleife an verschiedenen Stellen unterbrochen, wenn die Zeichenfolgenlängen unterschiedlich sind oder von Anfang an verglichen werden. Die Verarbeitung wird jedoch angewendet, wenn das letzte Zeichen unterschiedlich ist oder dieselbe Zeichenfolge. Es ist also am schnellsten, nach Referenzwert zu vergleichen, aber irgendwie scheint es effektiv zu sein, false zurückzugeben, wenn es nach dem Vergleich der Länge nicht durch Vergleich mit hashCode übereinstimmt. Wenn hashCode nicht berechnet wird, wird es bis zu 2 Mal wiederholt.
indexOf gibt es schon lange, aber wenn Sie sich fragen, warum das Argument int ch ...
String.java
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
// Note: fromIndex might be near -1>>>1.
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value;
for (int i = fromIndex; i < max; i++) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return indexOfSupplementary(ch, fromIndex);
}
}
private int indexOfSupplementary(int ch, int fromIndex) {
if (Character.isValidCodePoint(ch)) {
final char[] value = this.value;
final char hi = Character.highSurrogate(ch);
final char lo = Character.lowSurrogate(ch);
final int max = value.length - 1;
for (int i = fromIndex; i < max; i++) {
if (value[i] == hi && value[i + 1] == lo) {
return i;
}
}
}
return -1;
}
Oh, hat es Ersatzpaare unterstützt? Der indexOfSupplementary sucht nach jedem der beiden Zeichen, aber die erste Hälfte ist U + D800 bis U + DBFF und die zweite Hälfte ist U + DC00 bis U + DFFF.
Suchen Sie einfach von hinten nach lastIndexOf, und es gibt eine Methode für Ersatzpaare namens lastIndexOfSupplementary. Es scheint, dass JDK 1.5 mit Ersatzpaaren kompatibel ist. In der Quelle für JDK 1.4 war kein MIN_SUPPLEMENTARY_CODE_POINT enthalten. Seit JDK 1.4 lautet das Argument von indexOf int ch. So etwas ist erstaunlich.
Ich weiß nicht, ob es Menschen auf der Welt gibt, die "abc" .toString () schreiben ...
String.java
public String toString() {
return this;
}
Gib dich zurück.
Ich bin nicht sicher, ob die String-Klasse eine Laufzeitbibliothek oder Teil einer Sprachspezifikation ist. Der Standardkonstruktor ist beispielsweise ...
String.java
public String() {
this.value = "".value;
}
Recommended Posts