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
{ // 使用 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
{ // 利用循环分别输出 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
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
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+"/" ");
}
}
}