Java.lang包——字符串类(String, StringBuffer)

Java.lang

包——字符串类

(String, StringBuffer)


作者：
zccst

先提及一下数组，
与
C++
不同的是，
Java
中
所有的数组都是动态分配存储空间。一但分配了存储空间，就不能在程序中改变数组长度，但可以用
new
重新分配空间。在
Java
中，数组是一种类，有自己的属性和方法。比较常用的是
length
方法，用于返回数组的长度。

回忆一下严蔚敏
C
语言描述的《数据结构》（第二版），都有哪几种数据结构？

常见的是：

1.

线性表（包括顺序表和链表）

2.

堆栈和队列

3.

串

4.

数组和广义表

5.

树和二叉树

6.

图

既然数组在
Java
中封装成类，不难发现，其实这些数据结构在
java
中全部封装成了类。串也不例外，所以也封装成了类。

字符串类——

String

类和

StringBuffer

类


程序中用到的字符串可以分为两类：

1.

String
类：创建之后不能再修改和变动的字符串常量。

String
被
java
的开发者构造得非常接近基本数据类型，换句话说，在很多时候可以象使用基本数据类型一样来使用
String
类，例如：

//
声明了一个空字符串
s

String s
；

String ss
= ”
创建了一个字符串
”;

//
声明了一个空字符串
s

String s
= new String();

String ss
= new String(”
创建了一个字符串
”);

String
[]sa = new String[]{”
创建了一个字符串
”, “
数组
”};

常用的方法有：

int length()
//
返回字符串长度

boolean equals(Object anObject)
//
比较字符串相等

String substring(int beginIndex)
//
返回从
beginindex
开始的子串。

String substring(int beginIndex,int
endIndex) //
返回从
beginIndex
到
endIndex
的子串

char charAt(int index)
//
返回
index
指定位置的字符

int indexOf(String str)
//
返回
str
在字符串第一次出现的位置

String replace(char oldChar,char
newChar)
//
替换字符串中所有的
oldChar
子串

更多方法请查阅本文《附录
1
：
String
类的常用方法》

2.

StringBuffer
类：创建之后可以修改和变动的字符串变量。即能插入字符，也能追加字符到串尾。
StringBuffer
类对象的长度是可变的（即
StringBuff
是可变长的字符串对象
）。

常用方法有：

int length();
//
获取当前对象的长度

int capacity();
//
获取当前对象的容量。

StringBuff append(
……
);
//
将对象，字符串等添加到
StringBuff
对象中去。

StringBuff insert(int offset,
……
);
//
将对象，字符串等插入到指定的位置。

其中主要的方法是
append
和
insert
，可以重载和接收任何类型的数据。

String
类和
StringBuffer
类都在
java
的
lang
包中，并被定义为最终类，不能再派生子类。

如果你只是了解一下，可以到此为止。如果你想深入理解字符串类，请继续下去。

本文框架（本文由以下内容构成）：

String
类（构造方法，常用方法，实例）

StringBuffer
类（构造方法，常用方法，实例）

字符串类总结（特点比较）

附录
1
：
String
类的常用方法（表格形式，方便查询）

附录
2
：
StringTokenizer
类（扩展知识）

String

类


一、
String
类——常用构造方法

String()

用来创建一个空的字符串常量

String(String
str)

利用一个已经存在的字符串常量，来创建一个新的
String
对象

String(StringBuffer
buf)

利用一个已经存在的
StringBuffer
对象，来创建新的
String
对象

String(char
c[])

利用已经存在的字符数组的内容，来创建新的
String
对象

其原型是：

1.

用扩在双引号
(“”)
里面的一串字符串做参数构造字符串

Public String(String
value);

2.

用字符作为构造函数

Public String(char
value[]);

Public String(char value,
int offset, int count);

3.

用指定的缓冲字符串对象
buffer
构造字符串对象

Public
String(StringBuffer buffer);

4.

用字节数组作为参数构造字符串

Public String(byte[]
bytes);

Public String(byte[]
bytes, String enc);

Public String(byte[]
bytes, int offset, int length);

Public String(byte[]
bytes, int offset, int length, String enc);

举例

String
str = new String(“I like Java”);

Char ch[]
= {‘a’, ‘b’, ‘c’, ‘d’, ‘e’};

String s1
= new String(ch);
// s1
为
”abcde”

String s2
= new String(ch, 2, 3);

// s2
为
”cde”

StringBuffer
buff = new StringBuffer();

Buff.append(“a”);

Buff.append(“5.6”);

String s1
= new String(buff);
// s1
为
”a5.6”

二、
String
类——常用方法

1
，求字符串长度

public int
Length()
//
用于获得当前字符串对象中字符的个数

例：
String s = “
欢迎使用
java
语言
”;

Int len = s.length();

结果：
len = 10

注：
java
采用
Unicode
编码，每个字符为
16
为长，因此汉字和其他符号一样只占用一个字符。

2
，字符串连接

public
String concat(String str)
//
用于将字符串
str
连接在当前字符串的尾部，并返回新的字符串

例：
“to”.concat(“get”).concat(“her”)
的返回值为
”together”
。

例：
String str = “hello”;

str = str + “world” +2;

str
的值为
”hello world 2”;

注：利用
” + ”

，编译器讲自动把非字符串转换为字符串再进行连接。

3
，字符串比较

boolean
equals(Object o)
//
用于将当前字符串与方法参数列表中给出的字符串对象
o
作比较，若相同则返回
true
，否则返回
false
，区分大小写

boolean
equalsIgnoreCase(String str)
//
用于将当前字符串与方法参数列表中给出的字符串对象
str
作比较，若相同则返回
true
，否则返回
false
，不区分大小写

int
compareTo(String str)
//
用于将当前字符串与参数中字符串对象
str
作比较，若完全相同则返回
0
；若按字母顺序大于参数字符串，则返回一个大于
0
的整数；反之，则返回一个小于
0
的整数

int
compareTo(Object object)

int
compareToIgnoreCase(String str)

例：
String str3 = “This”;

String str2 = “That”;

System.out.println(“
结果
1
：
”+str3.equals(“this”)+”,”+str3.equalsIgnoreCase(”this”));

System.out.println(“
结果
2
：
”+str2. compareTo (“that”)+”,”+str2. compareTo
IgnoreCase(”that”));

输出：结果
1
：
false, true;

结果
2
：
-32,0;

注：在前文《
Java.lang
包——
Object
类》中使用关系运算符“
==
”判定两个
object
，作为继承了
object
类的字符串类，同理也可以用“
==
”判定两个字符串是否相等，并且其使用规则也一样。

4
，转化字符串的大小写

Public
String
toLowerCase()
//
将字符串中所有的大写字母转换成小写

Public
String
toUpperCase()
，

//
将字符串中所有的小写字母转换成大写

例如：
StringCaseChange.java

public
class StringCaseChange

{

public static void main(String[] args)

{

String str = "Hello world.This
is a Java code.";

//
声明并初始化字符串

System.out.println("The str is
:");

System.out.println(str);

System.out.println("to
UpperCase:");

System.out.println(str.toUpperCase());

//
字符串对象
str
调用
toUpperCase()
方法，并输出返回值

System.out.println(str.toLowerCase());

//
字符串对象
str
调用
toLowerCase()
方法，并输出返回值

System.out.println(str);

//
输出原字符串
str

}

}

5
，字符串截取

public
char charAt(int index)
//
返回
index
指定位置的字符

public
String subString(int start)

//
返回从
start
开始的子串。

public
String subString(int start, int end)

//
返回从
start
到
end
的子串

例：

String str = “hello world”;

char charValue = str.charAt(2);

String s1 = str.subString(2);

String s2 = str.subString(6, 11);

结果：
charValue = ‘1’;

s1 = “llo world”;

s2 = “world”;

注：
start
和
end
的位置需特别小心。

6
，判断一个字符的前缀和后缀

public boolean
startsWith(String prefix)

//
用于判断当前字符串的前缀，是否是指定的字符串对象
str
，若是则返回
true
，否则返回
false

public
boolean endsWith(String suffix)
//
用于判断当前字符串的后缀，是否是指定的字符串对象
str
，若是则返回
true
，否则返回
false

public boolean
startsWith(String prefix, int offset)

注：偏移量从
0
开始计数。

综合例子
1
：
String
类对象的创建及使用
StringDemo.java

public
class StringDemo

{

String str1 = "Hello world!This is
Java code."; //
声明并初始化字符串
str1

String str2;

//
声明字符串
str2

String str3 = new String("This is
Java code."); //
声明并初始化字符串
str3

public StringDemo()

{

str2 = new String("This is Java
code.");

//
创建字符串对象
str2
并初始化

System.out.println("str1 is:
"+str1);

System.out.println("str2 is:
"+str2);

System.out.println("str3 is:
"+str3+"/n");

System.out.println("Each item
of str1 is:");

for(int i=0;i<str1.length();i++)

{

//
使用
charAt()
方法得到
String
字符串中指定位置的字符，并利用循环分别输出

char c = str1.charAt(i);

System.out.print("/""+c+"/",");

if((i+1)%10==0)
System.out.println();

}

System.out.println();

byte b[] = str1.getBytes();

//
使用
String
类的
getBytes()
方法，得到
str1
中所有字符对应的
Unicode
编码，并存入
byte
型数组
b
中

System.out.println("Change each
item of str1 to unicode is:");

for(int i=0;i<b.length;i++)

{

//
利用循环分别输出
str1
中，所有元素对应的字符的
Unicode
编码

System.out.print(b[i]+",");

if((i+1)%10==0)
System.out.println();

}

System.out.println();

System.out.print("The result
of comparing str2 and str3 is:");

System.out.println(str2.equals(str3));

//
将字符串对象
str2
与
str3
进行比较，并将返回值输出

System.out.println("/nReplace
all charcters /"a/" to /"e/" in str2");

System.out.println("The result
of str2.replace() is:"+str2.replace('a','e'));

//
将字符串
str2
调用
replace()
方法的结果输出

System.out.println("str2 is:
"+str2+"/n");

System.out.print("The result
of whether str1 is beginning with /"Hello/":");

System.out.println(str1.startsWith("Hello"));

System.out.print("The result
of whether str3 is end with /"code./":");

System.out.println(str3.startsWith("code."));

}

public static void main(String[] args)

{

StringDemo stringDemo = new
StringDemo();

}

}

综合例子
2
：
String
类部分方法测试
StringMethodDemo.java

public
class StringMethodDemo

{

public static void main(String[] args)

{

String str1 = "abc";

String str2 = "aab";

String str3 = "abd";

String str4 = "abc";

String str5 = "ABC";

String str6 =
"abcdefgabcde";

//
以上完成字符串的声明及初始化

int i = str1.compareTo(str2);

int j = str1.compareTo(str3);

int k = str1.compareTo(str4);

//
以上调用
String
的
compareTo()
方法来比较字符串

System.out.println("str1
is:"+str1);

System.out.println("str2
is:"+str2);

System.out.println("str3
is:"+str3);

System.out.println("str4
is:"+str4);

System.out.println("str5
is:"+str5);

System.out.println("str6
is:"+str6);

System.out.print("The result
of str1 compareTo str2 is:");

System.out.println(i);

System.out.print("The result
of str1 compareTo str3 is:");

System.out.println(j);

System.out.print("The result
of str1 compareTo str4 is:");

System.out.println(k);

System.out.print("The result
of str1 equals str5 is:");

System.out.println(str1.equals(str5));

//
调用
String
的
equals()
方法来比较字符串

System.out.print("The result
of str1 equalsIgnoreCase str5 is:");

System.out.println(str1.equalsIgnoreCase(str5));

//
调用
String
的
equalsIgnoreCase()
方法来比较字符串

int m = str6.indexOf((int)'d');

//
调用
String
的
indexOf()
方法，返回字符
'd'
第一次出现的位置

System.out.println("The char
/"d/" first appear position is :"+m);

int n = str6.indexOf((int)'d',4);

//
调用
String
的
indexOf()
方法，返回字符
'd'
从第四位后，首次出现的位置

System.out.println("After 4th
position The char/"d/"appear position is:"+n);

}

}

三、
String
类——查找指定字符、字符串和替换

由于检索对字符串特别重要，为突出其重要性，故单独列出。

1
，查找字符

int
indexOf(char a)
//
用于查找并返回当前字符串中，某个特定字符
a
第一次出现的位置

int
indexOf(char a,int b)
//
用于从当前字符串中，自
b
位个字符之后向后查找并返回某个特定字符
a
第一次出现的位置

int
lastIndexOf(char a)
//
用于查找并返回当前字符串中，某个特定字符
a
最后一次出现的位置

int lastIndexOf(char
a, int b)
//
用于从当前字符串中，自
b
位个字符之后向后查找并返回某个特定字符
a
最后一次出现的位置

2
，查找字符串

int
indexOf(String str)
//
用于查找并返回当前字符串中，某个特定字符串
str
第一次出现的位置

int
indexOf(String str,int a)
//
用于从当前字符串中，自
a
位个字符之后向后查找并返回某个特定字符串
str
第一次出现的位置

int
lastIndexOf(String str)
//
用于查找并返回当前字符串中，某个特定字符串
str
最后一次出现的位置

int
lastIndexOf(String str int a)
//
用于从当前字符串中，自
a
位个字符之后向后查找并返回某个特定字符串
str
，最后一次出现位置

例如：
StringSearchDemo.java

public
class StringSearchDemo

{

public static void main(String[] args)

{

String str1 = "Hello
world.This is a Java code.we will program Java code.";

String searchStr = "Java
code";

//
以上声明创建了字符串对象

int i = str1.indexOf(searchStr);

//
在字符串
str1
中，查找并返回字符串对象
searchStr
的位置

int j =
str1.indexOf(searchStr,str1.indexOf("we"));

//
在字符串
str1
中，从字符串
"we"
开始，查找并返回字符串对象
searchStr
的位置

int m =
str1.lastIndexOf(searchStr);

//
在字符串
str1
中，查找并返回字符串对象
searchStr
最后一次出现的位置

System.out.println("str1 is:"+str1);

System.out.println("searchStr
is:"+searchStr);

System.out.println("i =
str1.indexOf(searchStr):"+i);

System.out.println("j=str1.indexOf(searchStr,str1.indexOf(/"we/")):"+j);

System.out.println("m =
str1.lastIndexOf(searchStr):"+m);

}

}

3
，替换字符（包括字符串）

String
replace(char c1,char c2)
//
用于将当前字符串中的所有
c1
指定的字符替换为
c2
指定的字符，并返回新的字符串

四、
String
类——字符串转换为字节数组或字符数组

1
，字节数组

byte []
getBytes();

byte []
getBytes(String enc);
//enc
是字符集编码

2
，字符数组

char [] toCharArray();

char []
toCharArray(int srcBegin, int srcEnd, char[] dst, int dstBegin);

例：
byte byteArr[];

char charArr[];

String
str = "This is s test string";

byteArr
= str.getBytes();

charArr
= str.toCharArray();

源码：
StringToArray.java

public
class StringToArray{

public static void main(String[] args){

String s="ABCDE";

byte b[]=s.getBytes();

System.out.println("/t"+s);

for(int
i=0;i<b.length;i++)

System.out.print("/t"+b[i]);

System.out.println();

char ch0[]=s.toCharArray();

myPrint(ch0);

char ch1[]=new char[3];

s.getChars(1,4,ch1,0);

myPrint(ch1);

}

static void myPrint(char[] obj){

for(int
i=0;i<obj.length;i++)

System.out.print("/t"+obj[i]);

System.out.println();

}

}

StringBuffer

类


StringBuffer
类是可变字符串类，创建
StringBuffer
类的对象后，可以随意修改、变更字符串的内容。每个
StringBuffer
类
的对象，都能够存储指定容量的字符串，如果字符串的长度超过了
StringBuffer
类对象的容量，则该对象的容量会自动的扩大。

一、

StringBuffer
类——构造方法

StringBuffer()
//
用于创建一个空的
StringBuffer
对象

StringBuffer(int
length)
//
用于创建一个长度为
length
的
StringBuffer
对象

StringBuffer(String
str)

//
返回一个字符串，初始化为
s
，长度为
s.length()+16
个字节

例：
StringBuffer sb = new StringBuffer();

StringBuffer sb = new StringBuffer(32);

StringBuffer sb = new StringBuffer(“I like
this”);

注：系统为
String
类对象分配内存是，按照对象中所含字符的实际个数等量分配。而
StringBuffer
类对象分配内存时，出去字符所占空间外，再另加
16
个字符大小的缓冲区。

二、StringBuffer
类——主要方法（全为
public
）

1
，获得长度、容量和设置长度

int
capacity()
//
用于获取可变字符串的当前容量，值为字符串长度
+16

void
setLength(int a)
//
用于设置当前可变字符串的长度

int
length()
//
用于获取可变字符串的长度，值为字符串长度

例：
StringBuffer buf = new StringBuffer(“0123”);

buf.length() = 4;

buf.capacity() = 4 + 16 = 20;

一般
StringBuffer
的长度
(length)
是指存储在其中的字符个数，容量
(capacity)
是指缓冲区所能容纳的最大字符数。

2
，
append
、
replace
、
reverse

StringBuffer
append(Object obj) //
将对象参数以字符串的方式，加入到当前可变字符串中

StringBuffer
append(String str)
//
将给定的字符串，追加到当前可变字符串中

StringBuffer
append(StringBuffer sb)
//
将给定的可变字符串，追加到当前可变字符串中

StringBuffer
replace(int a,int b,String str)//
使用新的字符串
str
，替换当前可变字符串中，起始位置为
a
，结束位置为
b
之间的内容

StringBuffer
reverse(int start, int end, String str)

注：
append
共有
11
个方法，上面仅列出常见的
3
个。

3
，
insert
、
delete

StringBuffer
insert(int offset,Object obj) //
将对象参数以字符串的方式，插入到当前可变字符串中指定位置

StringBuffer
insert(int offset,String str)

//
将给定字符串，插入到当前可变字符串中指定位置

StringBuffer
delete(int a,int b)

//
用于删除掉当前可变字符串中，起始位置为
a
，结束位置为
b
之间的内容

StringBuffer
deleteCharAt(int a)

//
用于删除指定索引位置处的字符

void
setCharAt(int a,char ch)
//
将给定字符
ch
，插入到当前可变字符串中指定索引位置处

4
，其他

String
toString()

//
获得一个字符串常量来代表当前可变字符串

String
substring(int start)

String
substring(int start , int end);

注：
insert
共有
10
个方法，上面仅列出常见的
2
个。

三、实例

1，

StringBuffer
类的创建和使用

例如：
StringBuffer
类对象的创建及使用
StringBufferDemo.java

public class StringBufferDemo

{

StringBuffer strBuf1 = new StringBuffer("Hello world!");

//
声明、创建并初始化
StringBuffer
类的对象
strBuf1

StringBuffer strBuf2;

//
声明
StringBuffer
类的对象
strBuf2

StringBuffer strBuf3 = new StringBuffer(10);

//
声明并创建
StringBuffer
类的对象
strBuf3
，并设定其长度为
10

public StringBufferDemo()

{

strBuf2 = new StringBuffer("This is Java code.");

//
创建并初始化
StringBuffer
类的对象
strBuf2

strBuf3 = new StringBuffer("Hello");

//
创建并初始化
StringBuffer
类的对象
strBuf3

String output =
"strBuf1:"+strBuf1.toString()+"/nlength="+ strBuf1.

length()+"/ncapacity="+strBuf1.capacity();

//
使用
StringBuffer
类的方法
toString()
，将
StringBuffer
类对象转化为
String

型字符串

//
使用
StringBuffer
类的方法
length()
，来获得该可变字符串的长度

//
使用
StringBuffer
类的方法
capacity()
，来获得该可变字符串的最大存储容量

System.out.println(output);

strBuf1.setLength(30);

//
使用
StringBuffer
类的方法
setLength()
，来设置可变字符串的长度

System.out.print("After add strBuf1's length,");

System.out.println("strBuf1's capacity is:"+strBuf1.length());

strBuf1.ensureCapacity(60);

//
使用
StringBuffer
类的方法
ensureCapacity()
，来设置可变字符串的最大存储容量

System.out.print("Set strBuf1's capacity,");

System.out.println("Now strBuf1's capacity
is:"+strBuf1.capacity());

System.out.println();

System.out.println("strBuf2:"+strBuf2.toString());

System.out.println("Char at 0 in strBuf2
is:"+strBuf2.charAt(0));

System.out.println("Char at 9 in strBuf2
is:"+strBuf2.charAt(9));

char ch[] = new char[strBuf2.length()];

strBuf2.getChars(8,12,ch,0);

//
使用
StringBuffer
类的方法
getChars()
，来获取
strBuf2
中第
8
～
12
位的字符

System.out.println("The char from 8 to 12 is:");

for(int i=0;i<4;i++)

{

System.out.print("/""+ch[i]+"/",");

}

System.out.println("/n");

System.out.println("strBuf3:"+strBuf3.toString());

System.out.print("After append string to strBuf3,");

strBuf3.append(" world.StringBufferDemo!");

//
使用
StringBuffer
类的方法
append()
，在
strBuf3
末尾插入字符串

System.out.println("New strBuf3:/n"+strBuf3.toString());

System.out.print("After set the 5th char,");

strBuf3.setCharAt(11,'!');

//
使用
StringBuffer
类的方法
setCharAt()
，来更改
strBuf3
中第
11
位的字符

System.out.println("the new strBuf3:/n"+strBuf3.toString());

}

public static void main(String[] args)

{

StringBufferDemo stringBufferDemo = new StringBufferDemo();

}

}

2
，
StringBuffer
类的插入和删除操作

例如：
StringBuffer
类插入和删除方法的使用
InsertDeleteDemo.java

public
class InsertDeleteDemo

{

public static void main(String[] args)

{

String str = "Hello";

//
声明并初始化字符串对象
str

char ch[] =
{'a','b','c','d','e','f','g'};

//
声明并初始化字符数组
ch

boolean b = true;

//
声明并初始化布尔型变量
b

int a = 10000;

//
声明并初始化整型变量
a

float f = 24.24f;

//
声明并初始化单精度变量
f

double d = 33.3333;

//
声明并初始化双精度变量
d

StringBuffer buffer = new
StringBuffer();

//
声明并初始化可变字符串对象
buffer

buffer.insert(0,d);

//
使用
StringBuffer
类中
insert()
方法，向
buffer
第
0
个位置插入各种类型值

buffer.insert(0," ");

buffer.insert(0,f);

buffer.insert(0," ");

buffer.insert(0,a);

buffer.insert(0," ");

buffer.insert(0,b);

buffer.insert(0," ");

buffer.insert(0,ch);

buffer.insert(0," ");

buffer.insert(0,str);

System.out.println(buffer.toString()+"/n");

buffer.deleteCharAt(6);

//
使用
StringBuffer
类中
deleteCharAt()
方法，删除
buffer
中第
6
个位置的字符

System.out.println(buffer.toString()+"/n");

buffer.delete(5,12);

//
使用
StringBuffer
类中
delete()
方法，删除
buffer
中第
5
个位置至第
11
位置之间的字符

System.out.println(buffer.toString()+"/n");

}

}

字符串类总结


1，

如果创建一个字符串，不打算修改它，用
String
。

2，

如果创建一个字符串，计划修改它，用
StringBuffer
。

3，

String
比
StringBuffer
执行效率高。

4，

StringBuffer
比
String
方便。

附录1
：String
类的常用方法

方法	说明
char charAt(int index)	获取给定的Index 处的字符
int compareTo(String anotherString)	按照字典的方式比较两个字符串
int compareToIgnoreCase(String str)	按照字典的方式比较两个字符串, 忽略大小写
String concat(String str )	将给定的字符串连接到这个字符串的末尾
static String copyValueOf(char[ ] data)	创建一个和给定字符数组相同的String 对象
static String copyValueOf(char[ ]data ,int offset,int count)	使用偏移量，创建一个和给定字符数组相同的String 对象
boolean equals(Object anObject)	将这个String 对象和另一个对象String 进行比较
boolean equalsIgnoreCase(Sting anotherString)	将这个String 对象和另一个对象String 进行比较, 忽略大小写
void getChars(getChars(int strbegin,int strend,char[ ] data,int offset)	将这个字符串的字符拷贝到目的数组
int indexOf(int char)	产生这个字符串中出现给定字符的第一个位置的索引
int indexOf(int ch,int fromIndex)	从给定的索引处开始，产生这个字符串中出现给定字符的第一个位置的索引
int indexOf(String str)	产生这个字符串中出现给定子字符的第一个位置的索引
int indexOf(String str,int fromIndex)	从给定的索引处开始，产生这个字符串中出现给定子字符的第一个位置的索引
int length( )	产生这个字符串的长度
boolean regionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len)	检查两个字符串区域是否相等，允许忽略大小写
String replace(char oldChar,char newChar)	通过将这个字符串中的odChar 字符转换为newChar 字符来创建一个新字符串
boolean starsWith(String prefix)	检查这个字符串是否以给定的前缀开头
boolean starsWith(String prefix,int toffset)	从给定的索引处开头，检查这个字符串是否以给定的前缀开头
String substring(int strbegin)	产生一个新字符串，它是这个字符串的子字符串
String substring(int strbegin,int strend)	产生一个新字符串，它是这个字符串的子字符串，允许指定结尾处的索引
char[ ] toCharArray( )	将这个字符串转换为新的字符数组
String toLowerCase( )	将这个String 对象中的所有字符变为小写
String toString( )	返回这个对象（它已经是一个字符串）
String toUpperCase( )	将这个String 对象中的所有字符变为大写
String trim( )	去掉字符串开头和结尾的空格
static String valueOf(int i)	将int 参数转化为字符串返回。该方法有很多重载方法，用来将基本数据类型转化为字符串。如：static String valueOf(float f) ，static String valueOf(long l) 等

附录
2
：
StringTokenizer
类


Java
语言中，提供了专门用来分析字符串的类
StringTokenizer
（位于
java.util
包中）。该类可以将字符串分解为独立使用的单词，并称之为语言符号。语言符号之间由定界符（
delim
）或者是空格、制表符、换行符等典型的空白字符来分隔。其他的字符也同样可以设定为定界符。

1
，
StringTokenizer
类的构造方法

StringTokenizer(String
str)
//
为字符串
str
构造一个字符串分析器。使用默认的定界符，即空格符（如果有多个连续的空格符，则看作是一个）、换行符、回车符、
Tab
符号等

StringTokenizer(String
str, String delim)
//
为字符串
str
构造一个字符串分析器，并使用字符串
delim
作为定界符

2
，
StringTokenizer
类的主要方法

String
nextToken()
//
用于逐个获取字符串中的语言符号（单词）

boolean
hasMoreTokens()
//
用于判断所要分析的字符串中，是否还有语言符号，如果有则返回
true
，反之返回
false

int
countTokens()
//
用于得到所要分析的字符串中，一共含有多少个语言符号

3
，举例说明
StringTokenizer
类、类中方法的使用。程序分析两个字符串，统计字符串中单词的个数。

例如：
StringTokenizer
类的使用
StringTokenizerDemo.java

import
java.util.*;

public
class StringTokenizerDemo

{

public static void main(String[] args)

{

String str1 = "Hello
world!This is Java code,stringTokenizer Demo.";

//
声明并初始化字符串
str1

String str2 = "How to use
StringTokenizer?StringTokenizer?";

//
声明并初始化字符串
str2

StringTokenizer strT1 = new
StringTokenizer(str1," ,.!");

//
创建
StringTokenizer
类的对象
strT1,
并构造字符串
str1
的分析器

//
以空格符、
","
、
"."
及
"!"
作为定界符

StringTokenizer strT2 = new
StringTokenizer(str2," ?");

//
创建
StringTokenizer
类的对象
strT2,
并构造字符串
str2
的分析器

//
以空格符及
"?"
作为定界符

int num1 = strT1.countTokens();

//
获取字符串
str1
中语言符号的个数

int num2 = strT2.countTokens();

//
获取字符串
str2
中语言符号的个数

System.out.println("str1 has
"+num1+" words.They are:");

while(strT1.hasMoreTokens())

{

//
利用循环来获取字符串
str1
中下一个语言符号
,
并输出

String str =
strT1.nextToken();

System.out.print("/""+str+"/" ");

}

System.out.println("/nstr2 has
"+num2+" words.They are:");

while(strT2.hasMoreTokens())

{

//
利用循环来获取字符串
str2
中下一个语言符号
,
并输出

String str =
strT2.nextToken();

System.out.print("/""+str+"/"
");

}

}

}