Java-Basis-String-Klasse

Die Klasse

一、String stellt die Zeichenfolge

dar. Alle Zeichenfolgenliterale (z. B. "abc") in Java-Programmen werden als diese Klasse dargestellt Instanzimplementierung.

Strings sind Konstanten; ihre Werte können nach ihrer Erstellung nicht geändert werden. String-Puffer unterstützen veränderliche Strings. Da String-Objekte unveränderlich sind, können sie gemeinsam genutzt werden. Zum Beispiel:

1

String str = "abc";

entspricht:

char data[] = {'a', 'b', 'c'}; 2 String str = new String(data);

Im Folgenden finden Sie einige weitere Beispiele für die Verwendung von Zeichenfolgen:

1 System.out.println("abc");2      String cde = "cde";3      System.out.println("abc" + cde);4      String c = "abc".substring(2,3);5      String d = cde.substring(1, 2);

String Die Klasse enthält Methoden, mit denen einzelne Zeichen einer Sequenz überprüft und verglichen werden können Zeichenfolgen, Suchen Sie nach einer Zeichenfolge, extrahieren Sie Teilzeichenfolgen, erstellen Sie eine Kopie der Zeichenfolge und konvertieren Sie alle Zeichen in Groß- oder Kleinbuchstaben. Die Groß-/Kleinschreibung basiert auf der Unicode-Standardversion, die von der Character-Klasse angegeben wird.

Die Java-Sprache bietet spezielle Unterstützung für das String-Verkettungssymbol („+“) und für die Konvertierung anderer Objekte in Strings. Die Zeichenfolgenverkettung wird durch die Klasse StringBuilder (oder StringBuffer) und ihre Methode append implementiert. Die String-Konvertierung wird über die Methode toString implementiert, die von der Klasse Object definiert und von allen Klassen in Java geerbt wird. Weitere Informationen zur Zeichenfolgenverkettung und -konvertierung finden Sie in der Java-Sprachspezifikation von Gosling, Joy und Steele.

Sofern nicht anders angegeben, löst die Übergabe eines null-Arguments an einen Konstruktor oder eine Methode in dieser Klasse eine Nullzeigerausnahme aus.

String stellt eine UTF-16-formatierte Zeichenfolge dar, in der zusätzliche Zeichen durch Ersatzzeichenpaare dargestellt werden. Der Indexwert bezieht sich auf die char-Codeeinheit, das Ergänzungszeichen belegt also zwei Positionen innerhalb des String. Die Klasse

String stellt Methoden für die Arbeit mit Unicode-Codepunkten (d. h. Zeichen) und Unicode-Codeeinheiten (d. h. char-Werten) bereit.

2. So erstellen Sie eine Zeichenfolge

1 Zeichenfolge s="abc";

Dies bedeutet, dass zuerst eine Referenz s auf dem Stapel erstellt wird und zunächst zum Konstantenpool gewechselt wird, um zu prüfen, ob die Konstante „abc“ vorhanden ist. Wenn dies der Fall ist, zeigen Sie s auf „abc“ im Konstantenpool.

Wenn nicht, erstellen Sie abc im Konstantenpool,

1 String s=new String("abc"

entspricht String obj="abc"; String s=new String(obj); Nach dieser Operation befinden sich zwei Kopien der Daten im Speicher: eine im Konstantenpool und eine im Haufen. Aufgrund der neuen Operation wird unabhängig davon, ob „abc“ im Konstantenpool vorhanden ist, eine Kopie auf dem Heap erstellt

3. Vergleich der Zeichenfolgen

Beispiel 1: Verwendung des String-Konstantenpools

1 String s0 = "abc"; 
2 String s1 = "abc"; 
3 System.out.println(s0==s1); //true 
4 //s0  和  s1 都指向了常量池中的同一个 "abc"

Beispiel 2: Der Unterschied zwischen == und equal in String

1 String s0 =new String ("abc");   //new 这个操作,将在堆上产生对象,s0指向了堆2 String s1 =new String ("abc"); 
3 System.out.println(s0==s1); //false  s0 和 s1 指向的是堆上不同de的对象System.out.println(s0.equals(s1)); //true 因为String类重写了equals方法,比的是实体的内容

Beispiel 3: Zur Kompilierungszeit bestimmt

1 String s0="helloworld";2 String s1="helloworld";3 String s2="hello" + "world";   //编译的时候,直接就编译成了 helloworld4 System.out.println( s0==s1 );   //true5 System.out.println( s0==s2 );   //true

Beispiel 4: Zur Kompilierungszeit nicht bestimmbar

1 String s0="helloworld";2 String s1=new String("helloworld");3 String s2="hello" + new String("world");4 System.out.println( s0==s1 ); //false  一个指向常量池,一个指向堆System.out.println( s0==s2 ); //false5 System.out.println( s1==s2 ); //false

Beispiel 5: Optimierung zur Kompilierungszeit

 1 String s0 = "a1"; 2 String s1 = "a" + 1; 3 System.out.println((s0 == s1)); //true 4                    5 String s2 = "atrue"; 6 String s3= "a" + "true"; 7 System.out.println((s2 == s3))  //true 8                    9 String s4 = "a3.4";10 String s5 = "a" + 3.4;11 System.out.println((s4 == s5));  //true

Beispiel 6 Kann zur Kompilierungszeit nicht bestimmt werden

1 String s0 = "ab";2 String s1 = "b";3 String s2 = "a" + s1;   //s1不是常量,编译期无法确定4 System.out.println((s0 == s2)); //false

Beispiel 7: Zur Kompilierungszeit bestimmt

1 String s0 = "ab";2 final String s1 = "b";     //加上final 就变成了常量3 String s2 = "a" + s1;  //对于两个常量相加,编译器能确定它的值4 System.out.println((s0 == s2));     //true

四、String对象内存分析

//例一

String a = "abc"; ①　　

String b = "abc"; ②　

分析：

①代码执行后在常量池(constant pool)中创建了一个值为abc的String对象，

②执行时，因为常量池中存在 "abc" 所以就不再创建新的String对象了。

//例二

String   c   =   new   String("xyz");①　　

String   d   =   new   String("xyz");②　　

分析：

①Class被加载时，"xyz"被作为常量读入，在常量池(constant pool)里创建了一个共享的值为"xyz"的String对象；

然后当调用到new String("xyz")的时候，会在堆(heap)里创建这个new   String("xyz")对象;

②由于常量池(constant pool)中存在"xyz"所以不再创建"xyz"，然后创建新的new String("xyz")。

//例三

String   s1   =   new   String("xyz");     //创建二个对象(常量池和堆中)，一个引用 　　

String   s2   =   new   String("xyz");     //创建一个对象(堆中)，并且以后每执行一次创建一个对象，一个引用 　　

String   s3   =   "abc";     //创建一个对象(常量池中)，一个引用   　　

String   s4   =   "abc";     //不创建对象(共享上次常量池中的数据)，只是创建一个新的引用s4)

//例四

 public static void main(String[] args) {    
 //以下两条语句创建了1个对象。"凤山"存储在字符串常量池中     3 String str1 = "凤山";    
 String str2 = "凤山";     
 System.out.println(str1==str2);//true     
 //以下两条语句创建了3个对象。"天峨"，存储在字符串常量池中，两个new String()对象存储在堆内存中      7 String str3 = new String("天峨");     
 String str4 = new String("天峨");     
 System.out.println(str3==str4);//false      
//以下两条语句创建了1个对象。9是存储在栈内存中   //这里所说的一个对象,是指的9 , i 和 j 则是对9的引用  11 int i = 9;     
int j = 9;     
System.out.println(i==j);//true      
//由于没有了装箱，以下两条语句创建了2个对象。两个1对象存储在堆内存中    15 Integer l1 = new Integer(1);    注意这里是没有装箱操作的16 Integer k1 = new Integer(1);    
System.out.println(l1==k1);//false 　18  //以下两条语句创建了1个对象。1对象存储在栈内存中。自动装箱时对于值从127之间的值，使用一个实例。    19 Integer l = 20;//装箱     20 Integer k = 20;//装箱     21 System.out.println(l==k);//true    22 Integer i1 = 256;     //以下两条语句创建了2个对象。i1,i2变量存储在栈内存中，两个256对象存储在堆内存中   23 Integer i2 = 256;     
System.out.println(i1==i2);//false  25 }

五、String 类常见操作

字符串的常见操作，大致有以下几类    获取,判断,转换,替换和切割

1) 获取类操作   

String str="春花秋月何时了,往事知多少?小楼昨夜又东风,故国不堪回首月明中";

1 这个字符串到底有多长

2 第4个字是什么  即根据索引获取字符   

3 第一个逗号是第几个字符 即根据字符取索引（ 取字符(或字符串)的位置）

4 最后一个“月”字的索引

5 是否含有“月明”  这个字符序列

6 是不是以"春花"开头，是否以“月明中”结尾

7 这个串是否为空

8 是否和另一个串相等

String str="春花秋月何时了,往事知多少?小楼昨夜又东风,故国不堪回首月明中";
System.out.println("长度:" + str.length());  //31
System.out.println("第四个字是"+str.charAt(3)); //月
System.out.println("第一个逗号的位置是"+str.indexOf(',')); //7
System.out.println("第一个逗号的位置是"+str.indexOf(",")); //7
System.out.println("第一个往事的位置是"+str.indexOf("往事")); //8
System.out.println("最后一个月字的索引"+str.lastIndexOf("月")); //28
System.out.println("是否含有月明"+str.contains("月明"));  //true
System.out.println("是否以春花开头"+str.startsWith("春花"));  //true
System.out.println("是否以月明中结尾"+str.endsWith("月明中"));  //true
System.out.println("是否为空"+str.isEmpty());  //false
System.out.println(str.equals("另一个字符串")); //false
String s1="abc";
String s2="aBC";
System.out.println(s1.equalsIgnoreCase(s2));  //true  equalsIgnoreCase 比较的时候忽略大小写。

Das obige ist der detaillierte Inhalt vonJava-Basis-String-Klasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!