String: String-Typ
1. Konstrukteur
Kopieren Sie den Codecode wie folgt:
String(Byte[] Bytes): Konstruieren Sie ein String-Objekt aus einem Byte-Array.
String(char[ ] value): Konstruieren Sie ein String-Objekt aus einem char-Array.
String (Sting-Original): Erstellen Sie eine Kopie des Originals. Das heißt: ein Original kopieren.
String (StringBuffer-Puffer): Konstruieren Sie ein String-Objekt über das StringBuffer-Array.
Zum Beispiel:
Kopieren Sie den Codecode wie folgt:
byte[] b = {'a','b','c','d','e','f','g','h','i','j'};
char[] c = {'0','1','2','3','4','5','6','7','8','9'};
String sb = new String(b); //abcdefghij
String sb_sub = new String(b,3,2); //de
String sc = new String(c); //0123456789
String sc_sub = new String(c,3,2);
String sb_copy = new String(sb); //abcdefghij
System.out.println("sb:"+sb);
System.out.println("sb_sub:"+sb_sub);
System.out.println("sc:"+sc);
System.out.println("sc_sub:"+sc_sub);
System.out.println("sb_copy:"+sb_copy);
Ausgabeergebnis: sb:abcdefghij
sb_sub:de
sc:0123456789
sc_sub:34
sb_copy:abcdefghij
2. Methode :
Hinweis: ① Alle Methoden sind öffentlich.
②. Schreibformat: [Modifikator] <Rückgabetyp><Methodenname ([Parameterliste])>
Zum Beispiel: static int parseInt(String s)
Zeigt an, dass diese Methode (parseInt) eine Klassenmethode (statisch) ist, der Rückgabetyp (int) ist und die Methode einen String-Typ erfordert.
1. char charAt(int index): Ruft ein bestimmtes Zeichen in der Zeichenfolge ab, wobei sich der Parameterindex auf die Ordnungszahl in der Zeichenfolge bezieht. Die Ordnungszahl der Zeichenfolge beginnt bei 0 und reicht bis zur Länge()-1.
Zum Beispiel: String s = new String("abcdefghijklmnopqrstuvwxyz");
System.out.println("s.charAt(5): " + s.charAt(5) );
Das Ergebnis ist: s.charAt(5): f
2. int CompareTo(String anotherString): Vergleichen Sie das aktuelle String-Objekt mit anotherString. Die Gleichheitsbeziehung gibt 0 zurück. Wenn sie nicht gleich sind, beginnt der Vergleich mit dem ersten ungleichen Zeichenunterschied. In einem anderen Fall ist der vordere Teil der längeren Zeichenfolge zufällig die kürzere Zeichenfolge. geben ihre Längendifferenz zurück.
3. int CompareTo(Object o): Wenn o ein String-Objekt ist, ist die Funktion dieselbe wie 2; andernfalls wird eine ClassCastException ausgelöst.
Zum Beispiel: String s1 = new String("abcdefghijklmn");
String s2 = new String("abcdefghij");
String s3 = new String("abcdefghijalmn");
System.out.println("s1.compareTo(s2): " + s1.compareTo(s2) ); //Die Längendifferenz zurückgeben
System.out.println("s1.compareTo(s3): " + s1.compareTo(s3) ); //Das Differenzergebnis von 'k'-'a' zurückgeben: s1.compareTo(s2): 4
s1.compareTo(s3): 10
4. String concat(String str): Verketten Sie das String-Objekt mit str.
5. boolean contentEquals(StringBuffer sb): Vergleichen Sie das String-Objekt mit dem StringBuffer-Objekt sb.
6. statischer String copyValueOf(char[] data):
7. static String copyValueOf(char[] data, int offset, int count): Diese beiden Methoden konvertieren das char-Array in einen String, ähnlich einem der Konstruktoren.
8. boolean endWith(String suffix): Gibt an, ob das String-Objekt mit einem Suffix endet.
Zum Beispiel: String s1 = new String("abcdefghij");
String s2 = new String("ghij");
System.out.println("s1.endsWith(s2): " + s1.endsWith(s2) );
Das Ergebnis ist: s1.endsWith(s2): true
9. boolean equal(Object anObject): Wenn anObject nicht leer und mit dem aktuellen String-Objekt identisch ist, wird true zurückgegeben, andernfalls false.
10. byte[] getBytes(): Konvertieren Sie das String-Objekt in ein Byte-Array.
11. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin): Diese Methode kopiert die Zeichenfolge in das Zeichenarray. Unter diesen ist srcBegin die Startposition der Kopie, srcEnd die Endposition der Kopie, der Zeichenfolgenwert dst das Zielzeichenarray und dstBegin die Startposition der Kopie des Zielzeichenarrays.
Zum Beispiel: char[] s1 = {'I',' ','l','o','v','e',' ','h','e','r','!' } ;//s1=Ich liebe sie!
String s2 = new String("you!"); s2.getChars(0,3,s1,7); //s1=Ich liebe dich!
System.out.println( s1 );
Das Ergebnis ist: Ich liebe dich!
12. int hashCode(): Gibt den Hash-Tabellencode des aktuellen Zeichens zurück.
13. int indexOf(int ch): Finden Sie nur die erste übereinstimmende Zeichenposition.
14. int indexOf(int ch, int fromIndex): Finden Sie die erste übereinstimmende Zeichenposition ausgehend von fromIndex.
15. int indexOf(String str): Finden Sie nur die erste übereinstimmende String-Position.
16. int indexOf(String str, int fromIndex): Finden Sie die erste übereinstimmende String-Position beginnend bei fromIndex.
Zum Beispiel: String s = new String("einmal schreiben, überall ausführen!");
String ss = new String("run");
System.out.println("s.indexOf('r'): " + s.indexOf('r') );
System.out.println("s.indexOf('r',2): " + s.indexOf('r',2) );
System.out.println("s.indexOf(ss): " + s.indexOf(ss) );
Das Ergebnis ist: s.indexOf('r'): 1
s.indexOf('r',2): 12
s.indexOf(ss): 12
17. int lastIndexOf(int ch)
18. int lastIndexOf(int ch, int fromIndex)
19. int lastIndexOf(String str)
20. int lastIndexOf(String str, int fromIndex) Die oben genannten vier Methoden ähneln 13, 14, 15 und 16. Der Unterschied besteht darin, den letzten übereinstimmenden Inhalt zu finden.
öffentliche Klasse CompareToDemo {
public static void main (String[] args) {
String s1 = new String("acbdebfg");
System.out.println(s1.lastIndexOf((int)'b',7));
}
}
Laufergebnis: 5
(Der Parameter von fromIndex ist 7. Dies ist die Anzahl der Ziffern, die vom letzten Zeichen g der Zeichenfolge acbdebfg vorwärts gezählt werden. Da die Übereinstimmung mit dem Zeichen c beginnt, wird nach der letzten Position gesucht, die mit b übereinstimmt. Das Ergebnis ist also 5.)
21. int length(): Gibt die aktuelle Stringlänge zurück.
22. String replace(char oldChar, char newChar): Ersetzen Sie das erste oldChar in der Zeichenfolge durch newChar.
23. boolean getsWith(String prefix): Gibt an, ob das String-Objekt mit einem Präfix beginnt.
24. boolean getsWith(String prefix, int tooffset): Gibt an, ob das String-Objekt mit einem Präfix beginnt, gezählt ab der Toffset-Position.
Zum Beispiel: String s = new String("einmal schreiben, überall ausführen!");
String ss = new String("write");
String sss = new String("once");
System.out.println("s.startsWith(ss): " + s.startsWith(ss) );
System.out.println("s.startsWith(sss,6): " + s.startsWith(sss,6) );
Das Ergebnis ist: s.startsWith(ss): true
s.startsWith(sss,6): wahr
25. String-Teilzeichenfolge (int beginIndex): Rufen Sie die Teilzeichenfolge ab der Position beginIndex bis zum Ende ab.
26.String-Teilzeichenfolge (int beginIndex, int endIndex): Nehmen Sie die Teilzeichenfolge von der Position beginIndex bis zur Position endIndex.
27. char[ ] toCharArray(): Konvertieren Sie das String-Objekt in ein char-Array.
28. String toLowerCase(): Wandelt die Zeichenfolge in Kleinbuchstaben um.
29. String toUpperCase(): Wandelt den String in Großbuchstaben um.
Zum Beispiel: String s = new String("java.lang.Class String");
System.out.println("s.toUpperCase(): " + s.toUpperCase() );
System.out.println("s.toLowerCase(): " + s.toLowerCase() );
Das Ergebnis ist: s.toUpperCase(): JAVA.LANG.CLASS STRING
s.toLowerCase(): java.lang.class-Zeichenfolge
30. statischer String valueOf(boolean b)
31. statischer String valueOf(char c)
32. statischer String valueOf(char[] data)
33. statischer String valueOf(char[] data, int offset, int count)
34. statischer String valueOf(double d)
35. statischer String valueOf(float f)
36. statischer String valueOf(int i)
37. statischer String valueOf(long l)
38. statischer String valueOf(Object obj)
Die oben genannten Methoden werden verwendet, um verschiedene Typen in Java-Zeichentypen zu konvertieren. Dies sind Klassenmethoden.
Gängige Methoden der String-Klasse in Java:
öffentliches Zeichen charAt(int index)
Gibt das Indexzeichen in der Zeichenfolge zurück;
öffentliche int-Länge()
Gibt die Länge der Zeichenfolge zurück;
public int indexOf(String str)
Gibt die Position des ersten Vorkommens von str in der Zeichenfolge zurück;
public int indexOf(String str,int fromIndex)
Gibt die Position des ersten Vorkommens von str in der Zeichenfolge zurück, beginnend mit fromIndex;
public boolean equalIgnoreCase(String another)
Vergleicht, ob die Zeichenfolge mit einer anderen identisch ist (Groß- und Kleinschreibung wird ignoriert).
public String replace(char oldchar,char newChar)
Ersetzen Sie oldChar-Zeichen durch newChar-Zeichen in einer Zeichenfolge
öffentlicher boolescher StartWith(String-Präfix)
Bestimmen Sie, ob die Zeichenfolge mit der Präfixzeichenfolge beginnt.
öffentlicher boolescher Wert endWith(String-Suffix)
Bestimmen Sie, ob eine Zeichenfolge mit einer Suffixzeichenfolge endet.
öffentlicher String toUpperCase()
Gibt eine Zeichenfolge zurück, die die Großbuchstabenversion der Zeichenfolge darstellt.
öffentlicher String toLowerCase()
Gibt eine Zeichenfolge zurück, die die Kleinbuchstabenversion der Zeichenfolge ist
public String substring(int beginIndex)
Gibt den Teilstring von beginIndex bis zum Ende des Strings zurück;
public String substring(int beginIndex,int endIndex)
Gibt den Teilstring des Strings von beginIndex bis zum Ende von endIndex zurück
public String trim()
Gibt die Zeichenfolge zurück, nachdem führende und nachfolgende Leerzeichen entfernt wurden.
public String[] split(String regex)
Trennen Sie einen String entsprechend dem angegebenen Trennzeichen und geben Sie die getrennte String-Array-Instanz zurück:
Kopieren Sie den Codecode wie folgt:
öffentliche Klasse SplitDemo{
public static void main (String[] args) {
String date = "10.09.2008";
String[ ] dateAfterSplit= new String[3];
dateAfterSplit=date.split("/"); //Verwenden Sie „/“ als Trennzeichen, um die Datumszeichenfolge aufzuteilen und die Ergebnisse in drei Zeichenfolgen zusammenzufassen.
for(int i=0;i<dateAfterSplit.length;i++)
System.out.print(dateAfterSplit[i]+" ");
}
}
Laufergebnis: 2008 09 10 //Das Ergebnis sind 3 Split-String-Instanzen:
TestString1.java:
Programmcode
Kopieren Sie den Codecode wie folgt:
öffentliche Klasse TestString1
{
public static void main(String args[]) {
String s1 = „Hallo Welt“;
String s2 = „Hallo Welt“;
System.out.println(s1.charAt(1));
System.out.println(s2.length());
System.out.println(s1.indexOf("World"));
System.out.println(s2.indexOf("World"));
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
String s = „Ich bin ein J2EE-Programmierer“;
String sr = s.replace('I','you');
System.out.println(sr);
}
}
TestString2.java:
Programmcode
Kopieren Sie den Codecode wie folgt:
öffentliche Klasse TestString2
{
public static void main(String args[]) {
String s = „Willkommen in der Java-Welt!“;
String s2 = „magci“;
System.out.println(s.startsWith("Welcome"));
System.out.println(s.endsWith("World"));
String sL = s.toLowerCase();
String sU = s.toUpperCase();
System.out.println(sL);
System.out.println(sU);
String subS = s.substring(11);
System.out.println(subS);
String s1NoSp = s2.trim();
System.out.println(s1NoSp);
}