java字串String&StringBuffer

 

7.1 String
類
7.2
StringBuffer
類

7.1 String
類
String類（字串類）的對象是一經建立便不能變動內容的
字串常量，在前面的程式中我們已經多次使用了字串常
量，例如輸出語句中的參數之一"Input a Integer data/n"就是字元
串常量，只是當時並未明確提出這個概念。在學習String類的知
識之前，我們先強調一點，那就是請讀者把本章學習字串常
量與我們在第二章學習過的字元常量加以區分。字元常量是用
單引號括起的單個字元，例如，'A'，'/n'等。而字串常量是用
雙引號括起的字元序列，例如，"A"，"/n"，"Java Now"等。在
Java語言中，字串常量通常是作為String類的對象而存在的，
有專門的資料成員來表明它的長度。本節主要討論String類對象
的建立、使用和操作。

7.1.1
建立String
對象
Java語言規定字串常量必須用雙引號括起，一個串可以
包含字母、數字和各種特殊字元，如+、-、*、/、$等。在我們
前面的程式範例中已多次使用過字串常量，例如下面的語句：
System.out.println("OK！");
中的"OK！"就是字串常量。Java的任何字串常量都是String
類的對象，只不過在沒有明確命名時，Java自動為其建立一個匿
名String類的對象，所以，它們也被稱為匿名String類的對象。我
們可以用下面的方法建立String類的對象。例如：
String c1="Java"；

語句建立String類的對象c1，並通過賦值號將匿名String類
的對象"Java"賦值給c1引用。String類的對象一經建立，便有一
個專門的資料成員來記錄它的長度。

7.1.2 String
類的構造方法
表7.1 String
類的構造方法
構 造 方 法說 明
public String( ) 建立一個Null 字元串對象
public String(String value) 用串對象value建立一個新的字串對象，value可
以是字串或String類的對象。
public String(char value[ ]) 用字元數組value[ ]來建立字串對象。
public String(char value[ ],int offset,int
count)
從字元數組value中下標為offset的字元開始，創
建有count個字元的串對象。
public String(byte ascii[ ]) 用byte型字串數組ascii，按預設的字元編碼方
案建立串對象。
public String(byte ascii[ ] ， int offset int
count))
從位元組型數組ascii中下標為offset的字元開始，按
預設的字元編碼方案建立count個字元的串對象。
public String(StringBuffer Buffer) 構造一個新的字串，其值為字串的當前內容。

【樣本程式c7_1.java】 String類的7種構造方法的使用。
import java.io.*;
public class c7_1
{
public static void main(String[ ] args)
{//字元數組型的字串
char charArray[ ]={'b','i','r','t','h',' ','d','a','y'};
//位元組數組型的字串，其中每個位元組的值代表漢字的國際機內碼
//漢字的國際機內碼（GB2312碼），兩個位元組的編碼構成一個漢字。
//數組構成“物件導向”4個漢字。-61與-26組合成漢字“面”，其餘類推

byte byteArray[ ]={-61, -26, -49, -14, -74, -44, -49, -13};
StringBuffer buffer;
String s,s1,s2,s3,s4,s5,s6,s7,ss;
s=new String("hello"); //用字串建立一個新的字串對象s
ss="ABC";//用字串賦給String類型的對象引用
//用StringBuffer建立一個字串對象buffer
buffer=new StringBuffer("Welcom to java programming! ");
s1=new String( ); //建立一個Null 字元串對象

s2=new String(s); //用串對象s建立一個新的字串對象s2
s3=new String(charArray); //用字元數組建立字串對象s3
//用字串數組中下標為6開始的3個字元建立字串對象s4
s4=new String(charArray,6,3);
//用字串數組byteArray按預設的字元編碼方案建立串對象s5
s5=new String(byteArray);
//從前面建立的位元組型數組byteArray下標為2的位元組開始，取連續的4個字
節建立串對象
// s6，即取{-49, -14, -74, -44}
s6=new String(byteArray,2,4);

//構造一個新的字串對象s7，其值為字串buffer的當前內容
s7=new String(buffer);
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
System.out.println("s4="+s4);
System.out.println("s5="+s5);
System.out.println("s6="+s6);
System.out.println("s7="+s7);
System.out.println("ss="+ss);
System.out.println("buffer="+buffer);
}
}

運行結果如下：
s1=
s2=hello
s3=birth day
s4=day
s5=物件導向
s6=向對
s7=Welcom to java programming!
ss=ABC
buffer=Welcom to java programming!

7.1.3 String
類的常用方法
表7.2 Java.lang.String
常用成員方法
成 員 方 法功 能 說 明
public int length( ) 返回當前串對象的長度
public char charAt(int index) 返回當前串對象下標int index處的字元
public int indexof(int ch)
返回當前串內第一個與指定字元ch相同的下標，若找不
到，則返回-1
public int indexOf(String str,
int fromIndex)
從當前下標fromIndex處開始搜尋，返回第一個與指定字
符串str相同的第一個字母在當前串中的下標，若找不
到，則返回-1
public String substring(int beginIndex) 返回當前串中從下標beginIndex開始到串尾的子串
public String substring(int beginIndex,
int endIndex)
返回當前串中從下標beginIndex開始到下標endIndex-1的
子串
public boolean equals(Object obj) 若且唯若obj不為null且當前串對象與obj有相同的字串
時，返回true否則返回flase

表7.2 Java.lang.String
常用成員方法
public boolean equalsIgnoreCase(String s) 功能與equals類似，equalsIgnoreCase 在比較字串時忽略大小寫
public int compareTo(String another_s) 比較兩字串的大小。返回一個小於、等於或大於零的整數。返
回的值取決於此字串是否小於、等於或大於another_s
public String concat(String str) 將字串str串連在當前串的尾部，返回新的字串
public String replace(char oldCh,
char newCh) 將字串的字元oldCh替換為字串newCh
public String toLowerCase( ) 將字串中的大寫字元轉換為小寫字元
public String toUpperCase( ) 將字串中的小寫字元轉換為大寫字元
public static String valueOf(type variable) 返回變數variable值的字串形式。type可以是字元數組
public static String valueOf(char [ ] data,
int offset,int count) 返回字元數組data從下標offset開始的count個字元的字串
public static String valueOf(Object obj) 返回對象obj的字串
public String toString ( ) 返回當前字串

7.1.4
訪問字串對象
用於訪問字串對象的資訊常用到的成員方法為：
length( )：返回當前串對象的長度。
charAt（int index）：返回當前串對象下標 index處的字元。
indexOf（int ch）：返回當前串內第一個與指定字元ch相同
的下標，若找不到，則返回-1。例如，“abcd”. IndexOf(“c”); //值
為2。“abcd”. IndexOf(“Z”); //值為-1。

indexOf（String str, int fromIndex）：從當前下標fromIndex
處開始搜尋，返回第一個與指定字串str相同的第一個字母在
當前串中的下標，若找不到，則返回-1。例如，"abcd".
IndexOf("cd",0); //值為2。
substring(int beginIndex)：返回當前串中從下標beginIndex開
始到串尾的子串。例如，String s="abcde".subString(3); //s 值為
"de"。
public String substring(int beginIndex,int endIndex)：返回當
前串中從下標beginIndex開始到下標endIndex-1的子串。例如，
String s="abcdetyu".subString(2,5); //s 值為"cde"。

【樣本程式c7_2.java】
public class c7_2
{
public static void main(String args[ ])
{ String s1="Java Application";
char cc[ ]={'J','a','v','a',' ','A','p','p','l','e','t'};
int len=cc.length;// 返回當前串對象的長度
int len1=s1.length( );
int len2="ABCD".length( );

char c1="12ABG".charAt(3);// 返回當前串對象下標int index處的字元
char c2=s1.charAt(3);
// char c3=cc.charAt(1);錯，不能這樣用
//返回當前串內第一個與指定字元ch相同的下標
int n1="abj".indexOf(97);
int n2=s1.indexOf('J');
int n3="abj".indexOf("bj",0);
int n4=s1.indexOf("va",1);
//返回當前串中的子串
String s2="abcdefg".substring(4);

String s3=s1.substring(4,9);
System.out.println("s1="+s1+" len="+len1);
System.out.println("cc="+cc+" len="+len); //不能這樣列印cc數組元素的內容
System.out.println("ABCD=ABCD"+" len="+len2);
System.out.println("c1="+c1+" c2="+c2);
System.out.println("n1="+n1+" n2="+n2);
System.out.println("n3="+n3+" n4="+n4);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
}
}

運行結果:
s1=Java Application len=16
cc=[C@310d42 len=11
ABCD=ABCD len=4
c1=B c2=a
n1=0 n2=0
n3=1 n4=2
s2=efg
s3= Appl

7.1.5
字串比較
常用的字串比較成員方法有：equals( )、
equalsIgnoreCase( )及compareTo( )。它們的用法及功能如下：
當前串對象.equals(模式串對象)：若且唯若當前串對象與模
式串對象的長度相等且對應位置的字元(包括大小寫)均相同時，
返回true，否則返回flase。例如運算式
"Computer".equals("computer")
的結果為flase，因為第一個字元的大小寫不同。

當前串對象.equalsIgnoreCase(模式串對象)：
equalsIgnoreCase( )與equals( )方法的功能類似，不同之處是不
區分字母的大小寫。例如運算式
"Computer".equalsIgnoreCase ("computer")
的結果為true。
當前串對象.compareTo(模式串對象)：當前串對象與模式
串對象比較大小，返回當前串對象與模式串對象的長度之差或
第一個不同字元的unicode碼值之差。

【樣本程式c7_3.java】 字串比較運算的成員方法的使用。
public class c7_3
{
public static void main(String args[ ])
{ String s1="Java";
String s2="java";
String s3="Welcome";
String s4="Welcome";
String s5="Welcoge";
String s6="student";

boolean b1=s1.equals(s2);//s1為當前串對象，s2為指定對象
boolean b2=s1.equals("abx");
boolean b3=s3.equals(s4);
boolean b4=s1.equalsIgnoreCase(s2);
int n1=s3.compareTo(s4);
int n2=s1.compareTo(s2);
int n3=s4.compareTo(s5);
int d1=s6.compareTo("st");
int d2=s6.compareTo("student");
int d3=s6.compareTo("studentSt1");
int d4=s6.compareTo("stutent");
System.out.println("s1="+s1+"/ts2="+s2);

System.out.println("s3="+s3+"/ts4="+s4);
System.out.println("s5="+s5);
System.out.println("equals: (s1==s2)="+b1+"/t(s1==abx)="+b2);
System.out.println("equals: (s3==s4)="+b3);
System.out.println("equalsIgnoreCase: (s1==s2)="+b4);
System.out.println("(s3==s4)="+n1+"/t(s1<s2)="+n2);
System.out.println("(s4>s5)="+n3);
System.out.println("d1="+d1+"/td2="+d2);
System.out.println("d3="+d3+"/td4="+d4);
}
}

運行結果:
s1=Java s2=java
s3=Welcome s4=Welcome
s5=Welcoge
equals: (s1==s2)=false (s1==abx)=false
equals: (s3==s4)=true
equalsIgnoreCase: (s1==s2)=true
(s3==s4)=0 (s1<s2)=-32
(s4>s5)=6
d1=5 d2=0
d3=-3 d4=-16

7.1.6
字串操作
字串操作是指用已有的字串對象產生新的字串對象。
常用的成員方法有concat( )、replace( )、toLowerCase( )、
toUpperCase( )。
【樣本程式c7_4.java】 字串的串連、替換和字母大小寫轉
換操作。
public class c7_4
{
public static void main(String args[ ])
{ String s1="Java";
String s2="java";
String s3="Welcome";

String s4="Welcome";
String s5="Welcoge";
String sc1=s3.concat(s1);// sc1值為"Welcome Java "
String sc2=s1.concat("abx");
String sr1=s3.replace('e','r');//s3中的字元'e'換成'r'
String w1=s5.toLowerCase( );//s5中的大寫換小寫
String u2=s2.toUpperCase( );//s2中的小寫換大寫
System.out.println("s1="+s1+"/ts2="+s2);
System.out.println("s3="+s3+"/ts4="+s4);

System.out.println("s5="+s5);
System.out.println("s3+s1="+sc1);
System.out.println("s1+abx="+sc2);
System.out.println("s3.replace('e','r')="+sr1);
System.out.println("s5.toLower="+w1);
System.out.println("s2.toUpper="+u2);
}
}

運行結果：
s1=Java s2=java
s3=Welcome s4=Welcome
s5=Welcoge
s3+s1=WelcomeJava
s1+abx=Javaabx
s3.replace('e','r')=Wrlcomr
s5.toLower=welcoge
s2.toUpper=JAVA

7.1.7
其他類型的資料轉換成字串
String類中的valueOf(參數)成員方法可以將參數類型的資料
轉換成字串，這些參數的類型可以是：boolean，char，int，
long，float，double和對象。
【樣本程式c7_5.java】 將其他類型資料轉換成字串。
public class c7_5
{
public static void main(String args[ ])
{ double m1=3.456;
String s1=String.valueOf(m1); 將double型值轉換成字串
char[ ] cc={'a','b','c'};

String s2=String.valueOf(cc);//將字元數群組轉換成字串
boolean f=true;
String s3=String.valueOf(f); //將布爾值轉換成字串
char[ ] cs={'J','a','v','a'};
String s4=String.valueOf(cs,2,2);
System.out.println("m1="+m1+"/ts1="+s1);
System.out.println("s2="+s2);
System.out.println("f="+f+"/ts3="+s3);
System.out.println("s4="+s4);
}
}

運行結果:
m1=3.456 s1=3.456
s2=abc
f=true s3=true
s4=va

【樣本程式c7_6.java】 valueOf(對象)成員方法與toString( )
成員方法聯用，返回對象的字元表示。
class A1
{ int x,y;
A1(int x,int y){this.x=x;this.y=y;}
public String toString( ){return ("/tx="+x+"/t,y="+y);}
}
public class c7_6
{
public static void main(String args[ ])

{ A1 p=new A1(2,6);//調用構造方法初始化
// String.valueOf(p)返回p對象的字元表示。valueOf(p)引用
//toString( )成員方法，p對象可用toString( )成員方法轉換成字串
String str=String.valueOf(p);
System.out.println("str="+str);
}
}
運行結果：
str= x=2 , y=6

7.1.8 main
方法中的參數
在Java應用程式中我們必須寫public static void main(String[ ]
args)主方法。main方法中有一個參數是字串數組args，這個數
組的元素args[0],args[1]……args[n]的值都是字串。args就是命
令行的參數。在Java解譯器解釋使用者的位元組碼檔案時，可以包括
需要傳給main方法的參數。一般形式為：
java 類檔案名稱 字串1 字串2 …… 字串n
其中，類檔案名稱和各字串間用空格分隔。

【樣本程式c7_7.java】 運行時需要輸入參數的main方法。
public class c7_7
{
public static void main(String[ ] args)
{
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}
}

運行時輸入“java c7_7 Hello World Let's Java!”命令，則有
如下的結果：
Hello
World
Let's
Java!

7.2
StringBuffer
類
StringBuffer類（字串緩衝器類）也是java.lang.Object的子
類。與String類不同，StringBuffer類是一個在操作中可以更改其
內容的字串類，即一旦建立StringBuffer類的對象，在操作中可
以更改和變動字串的內容。也就是說對於StringBuffer類的對象
不僅能進行尋找和比較等操作，也可以做添加、插入、修改之類
的操作。

7.2.1
建立StringBuffer
對象
表7.3
StringBuffer
構造方法
構 造 方 法功 能 說 明
public StringBuffer ( ) 建立一個Null 字元串緩衝區，預設初始長度為16個字元
public StringBuffer(int length) 用length指定的初始長度建立一個Null 字元串緩衝區
public StringBuffer(String str) 用指定的字串str建立一個字串緩衝區，其長度為str的長度再加16
個字元

7.2.2
StringBuffer
類的常用方法
表7.4
Java.lang.StringBuffer
常用成員方法
成 員 方 法功 能 說 明
public int length( ) 返回當前緩衝區中字串的長度
public char charAt(int index) 返回當前緩衝區中字串下標 index處的字
符
public void setcharAt(int index,char ch) 將當前緩衝區中字串下標 index處的字元
改變成字元ch的值
public int capacity( ) 返回當前緩衝區長度
public StringBuffer append(Object obj) 將obj.toString( )返回的字串添加到當前
字串的未尾
public StringBuffer append(type variable) 將變數值轉換成字串再添加到當前字元
串的未尾，type可以是字元數組、串和各
種基本類型

表7.4
Java.lang.StringBuffer
常用成員方法
public StringBuffer append (char[ ]str,int
offset,int len)
將數組從下標offset開始的len個字元
依次添加到當前字串的未尾
public StringBuffer insert(int offset,Object
obj)
將obj.toString( )返回的字串插入當
前字元下標offset處
public StringBuffer insert(int offset, type
variable)
將變數值轉換成字串，插入到當前
字元數組下標為offset的位置處
public String toString( ) 將可變字串轉化為不可變字串

7.2.3
StringBuffer
類的測試緩衝區長度的方法
StringBuffer類提供了length( )、charAt( )和capacity( )等成員
方法來測試緩衝區長度。
【樣本程式c7_8.java】 測試緩衝區長度。
public class c7_8
{
public static void main(String[ ] args)
{
StringBuffer buf1=new StringBuffer( );//建立一個Null 字元串緩衝區
// 指定初始長度為16建立一個Null 字元串緩衝區
StringBuffer buf2=new StringBuffer(10);

//用指定的"hello"串建立一個字串緩衝區
StringBuffer buf3=new StringBuffer("hello");
//返回當前字串長度
int len1=buf1.length( );
int len2=buf2.length( );
int len3=buf3.length( );
//返回當前緩衝區長度
int le1=buf1.capacity( );
int le2=buf2.capacity( );
int le3=buf3.capacity( );

//從buf3字串中取下標為3的字元
char ch=buf3.charAt(3);
//使用StringBuffer的toString方法將三個StringBuffer
//對象轉換成String對象輸出
System.out.println("buf1="+buf1.toString( ));
System.out.println("buf2="+buf2.toString( ));
System.out.println("buf3="+buf3.toString( ));
System.out.println("len1="+len1+"/tlen2="+len2+"/tlen3="+len3);
System.out.println("le1="+le1+"/tle2="+le2+"/tle3="+le3);
System.out.println("ch="+ch);
}
}

運行結果:
buf1=
buf2=
buf3=hello
len1=0 len2=0 len3=5
le1=16 le2=10 le3=21
ch=l

7.2.4
StringBuffer
類的append( )
方法
StringBuffer類提供了append(Object obj)、append(type
variable)和append (char[ ]str, int offset, int len)成員方法。讀者可根
據參數選用其中一種方法，將參數轉換為字串添加到當前字元
串後面。
【樣本程式c7_9.java】 將給定字串添加到當前字串後面。
public class c7_9
{
public static void main(String[ ] args)
{

Object x="hello";
String s="good bye";
char cc[ ]={'a','b','c','d','e','f'};
boolean b=false;
char c='Z';
long k=12345678;
int i=7;
float f=2.5f;
double d=33.777;
StringBuffer buf=new StringBuffer( );

buf.append(x); buf.append(' '); buf.append(s);
buf.append(' '); buf.append(cc); buf.append(' ');
buf.append(cc,0,3); buf.append(' ');buf.append(b);
buf.append(' '); buf.append(c); buf.append(' ');
buf.append(i); buf.append(' '); buf.append(k);
buf.append(' '); buf.append(f); buf.append(' ');
buf.append(d);
System.out.println("buf="+buf);
}
}
運行結果:
buf=hello good bye abcdef abc false Z 7 12345678 2.5 33.777

7.2.5
StringBuffer
類的insert( )
方法
StringBuffer類提供了insert(int offset, Object obj)和insert(int
offset, type variable) 成員方法用於插入字串到當前字串中，
其中的參數offset指出插入的位置。
【樣本程式c7_10.java】 將各種資料轉換成字串插入到當
前字串的第0個位置。
public class c7_10
{
public static void main(String[ ] args)
{
Object y="hello";
String s="good bye";

char cc[ ]={'a','b','c','d','e','f'};
boolean b=false;
char c='Z';
long k=12345678;
int i=7;
float f=2.5f;
double d=33.777;
StringBuffer buf=new StringBuffer( );
buf.insert(0,y); buf.insert(0,' '); buf.insert(0,s);
buf.insert(0, ' '); buf.insert(0,cc); buf.insert(0,' ');
buf.insert(0,b); buf.insert(0,' '); buf.insert(0,c);

buf.insert(0, ' '); buf.insert(0,i); buf.insert(0,' ');
buf.insert(0,k); buf.insert(0,' '); buf.insert(0,f);
buf.insert(0,' '); buf.insert(0,d);
System.out.println("buf="+buf);
}
}
運行結果如下：
buf=33.777 2.5 12345678 7 Z false abcdef good bye hello

7.2.6
StringBuffer
類的setcharAt
( )
方法
setcharAt(int index,char ch)方法是將當前字串下標 index處
的字元改變成字元ch的值。
【樣本程式c7_11.java】
public class c7_11
{
public static void main(String[ ] args)
{ StringBuffer buf=new StringBuffer("hello there");
System.out.println("buf="+buf.toString( ));
System.out.println("char at 0: "+buf.charAt(0));

buf.setCharAt(0,'H'); //將buf串下標為0的字元改寫為'H'
buf.setCharAt(6,'T'); //將下標為6的字元改寫為'T'
System.out.println("buf="+buf.toString( ));
}
}
運行結果如下：
buf=hello there
char at 0: h
buf=Hello There