String 类
1、 String 对象的初始化
由于 String 对象特别常用，所以在对 String 对象进行初始化时，Java 提供了
一种简化的特殊语法，格式如下：
String s = “abc”;
s = “Java 语言”;
其实按照面向对象的标准语法，其格式应该为：
String s = new String(“abc”);
s = new String(“Java 语言”);
只是按照面向对象的标准语法，在内存使用上存在比较大的浪费。例如 String s
= new String(“abc”);实际上创建了两个 String 对象，一个是”abc”对象，
存储在常量空间中，一个是使用 new 关键字为对象 s 申请的空间。
其它的构造方法的参数，可以参看 String 类的 API 文档。
2、字符串的常见操作
a、 charAt 方法
该方法的作用是按照索引值(规定字符串中第一个字符的索引值是 0，第二个字
符的索引值是 1，依次类推)，获得字符串中的指定字符。例如：
String s = “abc”;
char c = s.chatAt(1);
则变量 c 的值是’b’。
b、 compareTo 方法
该方法的作用是比较两个字符串的大小，比较的原理是依次比较每个字符的字符
编码。首先比较两个字符串的第一个字符，如果第一个字符串的字符编码大于第
二个的字符串的字符编码，则返回大于 0 的值，如果小于则返回小于 0 的值，如
果相等则比较后续的字符，如果两个字符串中的字符编码完全相同则返回 0。
例如：
String s = “abc”;
String s1 = “abd”;
int value = s.compareTo(s1);
则 value 的值是小于 0 的值，即-1。
在 String 类中还存在一个类似的方法
compareToIgnoreCase，这个方法是忽略字符的大小写进行比较，比较的规则和
compareTo 一样。例如：
String s = “aBc”;
String s1 = “ABC”;
int value = s. compareToIgnoreCase (s1);
则 value 的值是 0，即两个字符串相等。
c、 concat 方法
该方法的作用是进行字符串的连接，将两个字符串连接以后形成一个新的字符
串。例如：
String s = “abc”;
String s1 = “def”;
String s2 = s.concat(s1);
则连接以后生成的新字符串 s2 的值是”abcdef”，而字符串 s 和 s1 的值不发生
改变。如果需要连接多个字符串，可以使用如下方法：
String s = “abc”;
String s1 = “def”;
String s2 = “1234”;
String s3 = s.concat(s1).concat(s2);
则生成的新字符串 s3 的值为”abcdef1234”。
其实在实际使用时，语法上提供了一种更简单的形式，就是使用“+”进行字符
串的连接。例如：
String s = “abc” + “1234”;
则字符串 s 的值是”abc1234”，这样书写更加简单直观。
而且使用“+”进行连接，不仅可以连接字符串，也可以连接其他类型。但是要
求进行连接时至少有一个参与连接的内容是字符串类型。而且“+”匹配的顺序
是从左向右，如果两边连接的内容都是基本数字类型则按照加法运算，如果参与
连接的内容有一个是字符串才按照字符串进行连接。
例如：
int a = 10;
String s = “123” + a + 5;
则连接以后字符串 s 的值是“123105”，计算的过程为首先连接字符串”123”和
变量 a 的值，生成字符串”12310”，然后使用该字符串再和数字 5 进行连接生成
最终的结果。
而如下代码：
int a = 10;
String s = a + 5 + “123”;
则连接以后字符串 s 的值是”15123”，计算的过程为首先计算 a 和数字 5，由于
都是数字型则进行加法运算或者数字值 15，然后再使用数字值 15和字符串”123”
进行连接获得最终的结果。
而下面的连接代码是错误的：
int a = 12;
String s = a + 5 + ‘s’;
因为参与连接的没有一个字符串，则计算出来的结果是数字值，在赋值时无法将
一个数字值赋值给字符串 s。
d、 endsWith 方法
该方法的作用是判断字符串是否以某个字符串结尾，如果以对应的字符串结尾，
则返回 true。
例如：
String s = “student.doc”;
boolean b = s.endsWith(“doc”);
则变量 b 的值是 true。
e、 equals 方法
该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，
否则返回 false。例如：
String s = “abc”;
String s1 = new String(“abc”);
boolean b = s.equals(s1);
而使用“==”比较的是两个对象在内存中存储的地址是否一样。例如上面的代码
中，如果判断：
boolean b = (s == s1);
则变量 b 的值是 false，因为 s 对象对应的地址是”abc”的地址，而 s1 使用 new
关键字申请新的内存，所以内存地址和 s 的”abc”的地址不一样，所以获得的
值是 false。
在 String 类中存在一个类似的方法 equalsIgnoreCase，该方法的作用是忽略大
小写比较两个字符串的内容是否相同。例如：
String s = “abc”;
String s1 =”ABC”;
boolean b = s. equalsIgnoreCase (s1);
则变量 b 的值是 true。
f、 getBytes 方法
该方法的作用是将字符串转换为对应的 byte数组，从而便于数据的存储和传输。
例如：
String s = “计算机”;
byte[] b = s.getBytes(); //使用本机默认的字符串转换为 byte 数组
byte[] b = s.getBytes(“gb2312”); //使用 gb2312 字符集转换为 byte
数组
在实际转换时，一定要注意字符集的问题，否则
中文在转换时将会出现问题。
g、 indexOf 方法
该方法的作用是查找特定字符或字符串在当前字符串中的起始位置，如果不存在
则返回-1。例如：
String s = “abcded”;
int index = s.indexOf(‘d’);
int index1 = s.indexOf(‘h’);
则返回字符 d 在字符串 s 中第一次出现的位置，数值为 3。由于字符 h 在字符串
s 中不存在，则 index1 的值是-1。
当然，也可以从特定位置以后查找对应的字符，例如：
int index = s.indexOf(‘d’,4);
则查找字符串 s 中从索引值 4(包括 4)以后的字符中第一个出现的字符 d，则
index 的值是 5。
由于 indexOf 是重载的，也可以查找特定字符串在当前字符串中出现的起始位
置，使用方式和查找字符的方式一样。
另外一个类似的方法是 lastIndexOf 方法，其作用是从字符串的末尾开始向前查
找第一次出现的规定的字符或字符串，例如：
String s = “abcded”;
int index = s. lastIndexOf(‘d’);
则 index 的值是 5。
h、 length 方法
该方法的作用是返回字符串的长度，也就是返回字符串中字符的个数。中文字符
也是一个字符。例如：
String s = “abc”;
String s1 = “Java 语言”;
int len = s.length();
int len1 = s1.length();
则变量 len 的值是 3，变量 len1 的值是 6。
i、 replace 方法
该方法的作用是替换字符串中所有指定的字符，然后生成一个新的字符串。经过
该方法调用以后，原来的字符串不发生改变。例如：
String s = “abcat”;
String s1 = s.replace(‘a’,’1’);
该代码的作用是将字符串 s 中所有的字符 a 替换成字符 1，生成的新字符串 s1
的值是”1bc1t”，而字符串 s 的内容不发生改变。
如果需要将字符串中某个指定的字符串替换为其它字符串，则可以使用
replaceAll 方法，例如：
String s = “abatbac”;
String s1 = s.replaceAll(“ba”,”12”);
该代码的作用是将字符串 s 中所有的字符串”ab”替换为”12”，生成新的字符
串”a12t12c”，而字符串 s 的内容也不发生改变。
如果只需要替换第一个出现的指定字符串时，可以使用 replaceFirst 方法，例
如：
String s = “abatbac”;
String s1 = s. replaceFirst (“ba”,”12”);
该代码的作用是只将字符串 s 中第一次出现的字符串”ab”替换为字符串”12”，
则字符串 s1 的值是”a12tbac”，字符串 s 的内容也不发生改变。
j、 split 方法
该方法的作用是以特定的字符串作为间隔，拆分当前字符串的内容，一般拆分以
后会获得一个字符串数组。例如：
String s = “ab,12,df”;
String s1[] = s.split(“,”);
该代码的作用是以字符串”,”作为间隔，拆分字符串 s，从而得到拆分以后的
字符串数字 s1，其内容为：{“ab”,”12”,”df”}。
该方法是解析字符串的基础方法。
如果字符串中在内部存在和间隔字符串相同的内容时将拆除空字符串，尾部的空
字符串会被忽略掉。例如：
String s = “abbcbtbb”;
String s1[] = s.split(“b”);
则拆分出的结果字符串数组 s1 的内容为：{“a”,””,”c”,”t”}。拆分出的
中间的空字符串的数量等于中间间隔字符串的数量减一个。例如：
String s = “abbbcbtbbb”;
String s1[] = s.split(“b”);
则拆分出的结果是：{“a”,””,””,”c”,”t”}。最后的空字符串不论有多
少个，都会被忽略。
如果需要限定拆分以后的字符串数量，则可以使用另外一个 split 方法，例如：
String s = “abcbtb1”;
String s1[] = s.split(“b”,2);
该代码的作用是将字符串 s最多拆分成包含 2个字符串数组。则结果为：{“a”,”
cbtb1”}。
如果第二个参数为负数，则拆分出尽可能多的字符串，包括尾部的空
字符串也将被保留。
k、 startsWith 方法
该方法的作用和 endsWith 方法类似，只是该方法是判断字符串是否以某个字符
串作为开始。例如：
String s = “TestGame”;
boolean b = s.startsWith(“Test”);
则变量 b 的值是 true。
l、 substring 方法
该方法的作用是取字符串中的“子串”，所谓“子串”即字符串中的一部分。例
如“23”是字符串“123”的子串。
字符串“123”的子串一共有 6 个：”1”、”2”、”3”、”12”、”23”、”123”。而”32”
不是字符串”123”的子串。
例如：
String s = “Test”;
String s1 = s.substring(2);
则该代码的作用是取字符串 s 中索引值为 2(包括)以后的所有字符作为子串，则
字符串 s1 的值是”st”。
如果数字的值和字符串的长度相同，则返回空字符串。例如：
String s = “Test”;
String s1 = s.substring(4);
则字符串 s1 的值是””。
如果需要取字符串内部的一部分，则可以使用带 2 个参数的 substring 方法，例
如：
String s = “TestString”;
String s1 = s.substring(2,5);
则该代码的作用是取字符串 s 中从索引值 2(包括)开始，到索引值 5(不包括)的
部分作为子串，则字符串 s1 的值是”stS”。
下面是一个简单的应用代码，该代码的作用是输出任意一个字符串的所有子串。
代码如下：
String s = “子串示例”;
int len = s.length(); //获得字符串长度
for(int begin = 0;begin < len – 1;begin++){ //起始索引值
for(int end = begin + 1;end <= len;end++){ //结束索引值
System.out.println(s.substring(begin,end));
}
}
在该代码中，循环变量 begin 代表需要获得的子串的起始索引值，其变化的区间
从第一个字符的索引值 0 到倒数第二个字符串的索引值 len -2，而 end 代表需
要获得的子串的结束索引值，其变化的区间从起始索引值的后续一个到字符串长
度。通过循环的嵌套，可以遍历字符串中的所有子串。
m、 toCharArray 方法
该方法的作用和 getBytes方法类似，即将字符串转换为对应的 char数组。例如：
String s = “abc”;
char[] c = s.toCharArray();
则字符数组 c 的值为：{‘a’,’b’,’c’}。
n、 toLowerCase 方法
该方法的作用是将字符串中所有大写字符都转换为小写。例如：
String s = “AbC123”;
String s1 = s.toLowerCase();
则字符串 s1 的值是”abc123”，而字符串 s 的值不变。
类似的方法是 toUpperCase，该方法的作用是将字符串中的小写字符转换为对应
的大写字符。例如：
String s = “AbC123”;
String s1 = s. toUpperCase ();
则字符串 s1 的值是”ABC123”，而字符串 s 的值也不变。
o、 trim 方法
该方法的作用是去掉字符串开始和结尾的所有空格，然后形成一个新的字符串。
该方法不去掉字符串中间的空格。例如：
String s = “ abc abc 123 “;
String s1 = s.trim();
则字符串 s1 的值为：” abc abc 123”。字符串 s 的值不变。
p、 valueOf 方法
该方法的作用是将其它类型的数据转换为字符串类型。需要注意的是，基本数据
和字符串对象之间不能使用以前的强制类型转换的语法进行转换。
另外，由于该方法是 static 方法，所以不用创建 String 类型的对象即可。例如：
int n = 10;
String s = String.valueOf(n);
则字符串 s 的值是”10”。虽然对于程序员来说，没有发生什么变化，但是对于
程序来说，数据的类型却发生了变化。
介绍一个简单的应用，判断一个自然数是几位数字的逻辑代码如下：
int n = 12345;
String s = String.valueOf(n);
int len = s.length();
则这里字符串的长度 len，就代表该自然数的位数。这种判断比数学判断方法在
逻辑上要简单一些。
关于 String 类的使用就介绍这么多，其它的方法以及这里到的方法的详细声明
可以参看对应的 API 文档。
StringBuffer 类和 System 类
StringBuffer 类
StringBuffer 类和 String 一样，也用来代表字符串，只是由于
StringBuffer 的内部实现方式和 String 不同，所以 StringBuffer 在进行字符
串处理时，不生成新的对象，在内存使用上要优于 String 类。
所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、
删除等操作，使用 StringBuffer 要更加适合一些。
在 StringBuffer 类中存在很多和 String 类一样的方法，这些方法在
功能上和 String 类中的功能是完全一样的。
但是有一个最显著的区别在于，对于 StringBuffer 对象的每次修改都会改变对
象自身，这点是和 String 类最大的区别。
另外由于 StringBuffer 是线程安全的，关于线程的概念后续有专门的
章节进行介绍，所以在多线程程序中也可以很方便的进行使用，但是程序的执行
效率相对来说就要稍微慢一些。
1、 StringBuffer 对象的初始化
StringBuffer 对象的初始化不像 String 类的初始化一样，Java 提供的有特殊的
语法，而通常情况下一般使用构造方法进行初始化。
例如：
StringBuffer s = new StringBuffer();
这样初始化出的 StringBuffer 对象是一个空的对象。
如果需要创建带有内容的 StringBuffer 对象，则可以使用：
StringBuffer s = new StringBuffer(“abc”);
这样初始化出的 StringBuffer 对象的内容就是字符串”abc”。
需要注意的是，StringBuffer 和 String 属于不同的类型，也不能直接进行强制
类型转换，下面的代码都是错误的：
StringBuffer s = “abc”; //赋值类型不匹配
StringBuffer s = (StringBuffer)”abc”; //不存在继承关系，无法进
行强转
StringBuffer 对象和 String 对象之间的互转的代码如下：
String s = “abc”;
StringBuffer sb1 = new StringBuffer(“123”);
StringBuffer sb2 = new StringBuffer(s); //String 转 换 为
StringBuffer
String s1 = sb1.toString(); //StringBuffer 转换为
String
2、 StringBuffer 的常用方法
StringBuffer 类中的方法主要偏重于对于字符串的变化，例如追加、插入和删
除等，这个也是 StringBuffer 和 String 类的主要区别。
a、 append 方法
public StringBuffer append(boolean b)
该方法的作用是追加内容到当前 StringBuffer 对象的末尾，类似于字符串的连
接。调用该方法以后，StringBuffer 对象的内容也发生改变，例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
则对象 sb 的值将变成”abctrue”。
使用该方法进行字符串的连接，将比 String 更加节约内容，例如应用于数据库
SQL 语句的连接，例如：
StringBuffer sb = new StringBuffer();
String user = “test”;
String pwd = “123”;
sb.append(“select * from userInfo where username=“).append(user).append(
“ and pwd=”).append(pwd);
这样对象 sb 的值就是字符串“select * from userInfo where
username=test and pwd=123”。
b、 deleteCharAt 方法
public StringBuffer deleteCharAt(int index)
该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“Test”);
sb. deleteCharAt(1);
该代码的作用删除字符串对象 sb中索引值为 1的字符，也就是删除第二个字符，
剩余的内容组成一个新的字符串。所以对象 sb 的值变为”Tst”。
还存在一个功能类似的 delete 方法：
public StringBuffer delete(int start,int end)
该方法的作用是删除指定区间以内的所有字符，包含 start，不包含 end 索引值
的区间。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb. delete (1,4);
该代码的作用是删除索引值 1(包括)到索引值 4(不包括)之间的所有字符，剩余
的字符形成新的字符串。则对象 sb 的值是”TString”。
c、 insert 方法
public StringBuffer insert(int offset, boolean b)
该方法的作用是在 StringBuffer 对象中插入内容，然后形成新的字
符串。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false);