转载

《Java从小白到大牛》之第9章字符串

《Java从小白到大牛》纸质版已经上架了！！！

由字符组成的一串字符序列，称为“字符串”，在前面的章节中也多次用到了字符串，本章将重点介绍。

Java中的字符串

Java中的字符串是由双引号括起来的多个字符，下面示例都是表示字符串常量：

"Hello World"                                                           ①
"/u0048/u0065/u006c/u006c/u006f/u0020/u0057/u006f/u0072/u006c/u0064"        ②
"世界你好"                                                              ③
"A"                                                                 ④
""                                                                  ⑤

Java中的字符采用Unicode编码，所以Java字符串可以包含中文等亚洲字符，见代码第③行的"世界你好"字符串。代码第②行的字符串是用Unicode编码表示的字符串，事实上它表示的也是"Hello World"字符串，可通过System.out.print方法将Unicode编码表示的字符串输出到控制台，则会看到Hello World字符串。

另外，单个字符如果用双引号括起来，那它表示的是字符串，而不是字符了，见代码第④行的"A"是表示字符串A，而不是字符A。

注意字符串还有一个极端情况，就代码第⑤行的""表示空字符串，双引号中没有任何内容，空字符串不是null，空字符串是分配内存空间，而null是没有分配内存空间。

Java SE提供了三个字符串类：String、StringBuffer和StringBuilder。String是不可变字符串，StringBuffer和StringBuilder是可变字符串。

使用API文档

Java中很多类，每一个类又有很多方法和变量，通过查看Java API文档能够知道这些类、方法和变量如何使用。Java官方为Java SE提供了基于HTML的API文档。作为Java程序员应该熟悉如何使用API文档。

本节介绍一下如何使用Java SE的API文档。Java官方提供了Java 8在线API文档，网址是 http://docs.oracle.com/javase/8/docs/api/ ，页面如图9-1所示。

《Java从小白到大牛》之第9章字符串

提示很多读者希望能够有离线的中文Java API文档，但Java官方只提供了Java 6的中文API文档，该文件下载地址是 http://download.oracle.com/technetwork/java/javase/6/docs/zh/api.zip ，下载完成后解压api.zip文件，找到其中的index.html文件，双击就会在浏览器中打开API文档了。

下面介绍一下如何使用API文档，熟悉一下API文档页面中的各个部分含义，如图9-2所示，类和接口中，斜文字体显示是接口，正常字体才是类。

《Java从小白到大牛》之第9章字符串

在类窗口还有很多内容，向下拖曳滚动条会看到如图9-3所示页面，其中“字段摘要”描述了类中的实例变量和静态变量；“构造方法摘要”描述了类中所有构造方法；“方法摘要”描述了类中所有方法。这些“摘要”只是一个概要说明，单击链接可以进入到该主题更加详细的描述，如图9-4所示单击了compareTo方法看到的详细信息。

《Java从小白到大牛》之第9章字符串

查询API的一般流程是：找包→找类或接口→查看类或接口→找方法或变量。读者可以尝试查找一下String、StringBuffer和StringBuilder这些字符串类的API文档，熟悉一下这些类的用法。

不可变字符串

很多计算机语言都提供了两种字符串，即不可变字符串和可变字符串，它们区别在于当字符串进行拼接等修改操作时，不可变字符串会创建新的字符串对象，而可变字符串不会创建新对象。

String

Java中不可变字符串类是String，属于java.lang包，它也是Java非常重要的类。

提示 java.lang包中提供了很多Java基础类，包括Object、Class、String和Math等基本类。在使用java.lang包中的类时不需要引入（import）该包，因为它是由解释器自动引入的。当然引入java.lang包程序也不会有编译错误。

创建String对象可以通过构造方法实现，常用的构造方法：

String()：使用空字符串创建并初始化一个新的String对象。
String(String original)：使用另外一个字符串创建并初始化一个新的 String 对象。
String(StringBuffer buffer)：使用可变字符串对象（StringBuffer）创建并初始化一个新的 String 对象。
String(StringBuilder builder)：使用可变字符串对象（StringBuilder）创建并初始化一个新的 String 对象。
String(byte[] bytes)：使用平台的默认字符集解码指定的byte数组，通过byte数组创建并初始化一个新的 String 对象。
String(char[] value)：通过字符数组创建并初始化一个新的 String 对象。
String(char[] value, int offset, int count)：通过字符数组的子数组创建并初始化一个新的 String 对象；offset参数是子数组第一个字符的索引，count参数指定子数组的长度。

创建字符串对象示例代码如下：

// 创建字符串对象

String s1 = new String();

String s2 = new String("Hello World");

String s3 = new String("/u0048/u0065/u006c/u006c/u006f/u0020/u0057/u006f/u0072/u006c/u0064");

System.out.println("s2 = " + s2);

System.out.println("s3 = " + s3);

char chars[] = {  a ,  b ,  c ,  d ,  e  };

// 通过字符数组创建字符串对象

String s4 = new String(chars);

// 通过子字符数组创建字符串对象

String s5 = new String(chars, 1, 4);

System.out.println("s4 = " + s4);

System.out.println("s5 = " + s5);

byte bytes[] = { 97, 98, 99 };

// 通过byte数组创建字符串对象

String s6 = new String(bytes);

System.out.println("s6 = " + s6);

System.out.println("s6字符串长度 = " + s6.length());

输出结果：

s2 = Hello World

s3 = Hello World

s4 = abcde

s5 = bcde

s6 = abc

s6字符串长度 = 3

上述代码中s2和s3都是表示Hello World字符串，获得字符串长度方法是length()，其他代码比较简单，这里不再赘述。

字符串池

在前面的学习过程中细心的读者可能会发现，前面的示例代码中获得字符串对象时都是直接使用字符串常量，但Java中对象是使用new关键字创建，字符串对象也可以使用new关键字创建，代码如下：

String s9 = "Hello"; //字符串常量

String s7 = new String("Hello"); //使用new关键字创建

使用new关键字与字符串常量都能获得字符串对象，但它们之间有一些区别。先看下面代码运行结果：

String s7 = new String("Hello"); ①

String s8 = new String("Hello"); ②

String s9 = "Hello"; ③

String s10 = "Hello"; ④

System.out.printf("s7 == s8 : %b%n", s7 == s8);

System.out.printf("s9 == s10: %b%n", s9 == s10);

System.out.printf("s7 == s9 : %b%n", s7 == s9);

System.out.printf("s8 == s9 : %b%n", s8 == s9);

输出结果：

s7 == s8 : false

s9 == s10: true

s7 == s9 : false

s8 == s9 : false

==运算符比较的是两个引用是否指向相同的对象，从上面的运行结果可见，s7和s8指的是不同对象，s9和s10指向的是相同对象。

这是为什么？Java中的不可变字符串String常量，采用字符串池（String Pool）管理技术，字符串池是一种字符串驻留技术。采用字符串常量赋值时（见代码第③行），如图9-5所示，会字符串池中查找"Hello"字符串常量，如果已经存在把引用赋值给s9，否则创建"Hello"字符串对象，并放到池中。根据此原理，可以推定s10与s9是相同的引用，指向同一个对象。但此原理并不适用于new所创建的字符串对象，代码运行到第①行后，会创建"Hello"字符串对象，而它并没有放到字符串池中。代码第②行又创建了一个新的"Hello"字符串对象，s7和s8是不同的引用，指向不同的对象。

《Java从小白到大牛》之第9章字符串

字符串拼接

String字符串虽然是不可变字符串，但也可以进行拼接只是会产生一个新的对象。String字符串拼接可以使用+运算符或String的concat(String str)方法。+运算符优势是可以连接任何类型数据拼接成为字符串，而concat方法只能拼接String类型字符串。

字符串拼接示例如下：

String s1 = "Hello";

// 使用+运算符连接

String s2 = s1 + " "; ①

String s3 = s2 + "World"; ②

System.out.println(s3);

String s4 = "Hello";

// 使用+运算符连接，支持+=赋值运算符

s4 += " "; ③

s4 += "World"; ④

System.out.println(s4);

String s5 = "Hello";

// 使用concat方法连接

s5 = s5.concat(" ").concat("World"); ⑤

System.out.println(s5);

int age = 18;

String s6= "她的年龄是" + age + "岁。"; ⑥

System.out.println(s6);

char score =  A ;

String s7= "她的英语成绩是" + score; ⑦

System.out.println(s7);

java.util.Date now = new java.util.Date(); ⑧

//对象拼接自动调用toString()方法

String s8= "今天是：" + now; ⑨

System.out.println(s8);

输出结果：

Hello World

Hello World

Hello World

她的年龄是18岁。

她的英语成绩是A

今天是：Thu May 25 16:25:40 CST 2017

上述代码第①~②行使用+运算符进行字符串的拼接，其中产生了三个对象。代码第③~④行业是使用+=赋值运算符，本质上也是+运算符进行拼接。

代码第⑤行采用concat方法进行拼接，该方法的完整定义如下：

public String concat(String str)

它的参数和返回值都是String，因此代码第⑤行可以连续调用该方法进行多个字符串的拼接。

代码第⑥和第⑦行是使用+运算符，将字符串与其他类型数据进行的拼接。代码第⑨行是与对象可以进行拼接，Java中所有对象都有一个toString()方法，该方法可以将对象转换为字符串，拼接过程会调用该对象的toString()方法，将该对象转换为字符串后再进行拼接。代码第⑧行的java.util.Date类是Java SE提供的日期类。

字符串查找

在给定的字符串中查找字符或字符串是比较常见的操作。在String类中提供了indexOf和lastIndexOf方法用于查找字符或字符串，返回值是查找的字符或字符串所在的位置，-1表示没有找到。这两个方法有多个重载版本：

int indexOf(int ch)：从前往后搜索字符ch，返回第一次找到字符ch所在处的索引。
int indexOf(int ch, int fromIndex)：从指定的索引开始从前往后搜索字符ch，返回第一次找到字符ch所在处的索引。
int indexOf(String str)：从前往后搜索字符串str，返回第一次找到字符串所在处的索引。
int indexOf(String str, int fromIndex)：从指定的索引开始从前往后搜字符串str，返回第一次找到字符串所在处的索引。
int lastIndexOf(int ch)：从后往前搜索字符ch，返回第一次找到字符ch所在处的索引。
int lastIndexOf(int ch, int fromIndex)：从指定的索引开始从后往前搜索字符ch，返回第一次找到字符ch所在处的索引。
int lastIndexOf(String str)：从后往前搜索字符串str，返回第一次找到字符串所在处的索引。
int lastIndexOf(String str, int fromIndex)：从指定的索引开始从后往前搜索字符串str，返回第一次找到字符串所在处的索引。

[图片上传中…(10-6.jpg-790da8-1530662260524-0)]

提示字符串本质上是字符数组，因此它也有索引，索引从零开始。String的charAt(int index)方法可以返回索引index所在位置的字符。

字符串查找示例代码如下：

String sourceStr = "There is a string accessing example.";

//获得字符串长度

int len = sourceStr.length();

//获得索引位置16的字符

char ch = sourceStr.charAt(16);

//查找字符和子字符串

int firstChar1 = sourceStr.indexOf( r );

int lastChar1 = sourceStr.lastIndexOf( r );

int firstStr1 = sourceStr.indexOf("ing");

int lastStr1 = sourceStr.lastIndexOf("ing");

int firstChar2 = sourceStr.indexOf( e , 15);

int lastChar2 = sourceStr.lastIndexOf( e , 15);

int firstStr2 = sourceStr.indexOf("ing", 5);

int lastStr2 = sourceStr.lastIndexOf("ing", 5);

System.out.println("原始字符串:" + sourceStr);

System.out.println("字符串长度:" + len);

System.out.println("索引16的字符:" + ch);

System.out.println("从前往后搜索r字符，第一次找到它所在索引:" + firstChar1);

System.out.println("从后往前搜索r字符，第一次找到它所在的索引:" + lastChar1);

System.out.println("从前往后搜索ing字符串，第一次找到它所在索引:" + firstStr1);

System.out.println("从后往前搜索ing字符串，第一次找到它所在索引:" + lastStr1);

System.out.println("从索引为15位置开始，从前往后搜索e字符，第一次找到它所在索引:" + firstChar2);

System.out.println("从索引为15位置开始，从后往前搜索e字符，第一次找到它所在索引:" + lastChar2);

System.out.println("从索引为5位置开始，从前往后搜索ing字符串，第一次找到它所在索引:" + firstStr2);

System.out.println("从索引为5位置开始，从后往前搜索ing字符串，第一次找到它所在索引:" + lastStr2);

输出结果：

原始字符串:There is a string accessing example.

字符串长度:36

索引16的字符:g

从前往后搜索r字符，第一次找到它所在索引:3

从后往前搜索r字符，第一次找到它所在的索引:13

从前往后搜索ing字符串，第一次找到它所在索引:14

从后往前搜索ing字符串，第一次找到它所在索引:24

从索引为15位置开始，从前往后搜索e字符，第一次找到它所在索引:21

从索引为15位置开始，从后往前搜索e字符，第一次找到它所在索引:4

从索引为5位置开始，从前往后搜索ing字符串，第一次找到它所在索引:14

从索引为5位置开始，从后往前搜索ing字符串，第一次找到它所在索引:-1

sourceStr字符串索引如图9-6所示。上述字符串查找方法比较类似，这里重点解释一下sourceStr.indexOf("ing", 5)和sourceStr.lastIndexOf("ing", 5)表达式。从图9-6可见ing字符串出现过两次，索引分别是14和24。sourceStr.indexOf("ing", 5)表达式从索引为5的字符（" "）开始从前往后搜索，结果是找到第一个ing（索引为14），返回值为14。sourceStr.lastIndexOf("ing", 5)表达式从索引为5的字符（" "）开始从后往前搜索，没有找到，返回值为-1。

《Java从小白到大牛》之第9章字符串

字符串比较

字符串比较是常见的操作，包括比较相等、比较大小、比较前缀和后缀串等。

比较相等

String提供的比较字符串相等的方法：

boolean equals(Object anObject)：比较两个字符串中内容是否相等。
boolean equalsIgnoreCase(String anotherString)：类似equals方法，只是忽略大小写。
1. 比较大小

有时不仅需要知道是否相等，还要知道大小，String提供的比较大小的方法：

int compareTo(String anotherString)：按字典顺序比较两个字符串。如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于 0 的值；如果此字符串大于字符串参数，则返回一个大于 0 的值。
int compareToIgnoreCase(String str)：类似compareTo，只是忽略大小写。
1. 比较前缀和后缀
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束。
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。

字符串比较示例代码如下：

String s1 = new String("Hello");

String s2 = new String("Hello");

// 比较字符串是否是相同的引用

System.out.println("s1 == s2 : " + (s1 == s2));

// 比较字符串内容是否相等

System.out.println("s1.equals(s2) : " + (s1.equals(s2)));

String s3 = "HELlo";

// 忽略大小写比较字符串内容是否相等

System.out.println("s1.equalsIgnoreCase(s3) : " + (s1.equalsIgnoreCase(s3)));

// 比较大小

String s4 = "java";

String s5 = "Swift";

// 比较字符串大小 s4 > s5

System.out.println("s4.compareTo(s5) : " + (s4.compareTo(s5))); ①

// 忽略大小写比较字符串大小 s4 < s5

System.out.println("s4.compareToIgnoreCase(s5) : " + (s4.compareToIgnoreCase(s5))); ②

// 判断文件夹中文件名

String[] docFolder = { "java.docx", " JavaBean.docx", "Objecitve-C.xlsx", "Swift.docx " };

int wordDocCount = 0;

// 查找文件夹中Word文档个数

for (String doc : docFolder) {

// 去的前后空格

doc = doc.trim(); ③

// 比较后缀是否有.docx字符串

if (doc.endsWith(".docx")) {

wordDocCount++;

}

}

System.out.println("文件夹中Word文档个数是： " + wordDocCount);

int javaDocCount = 0;

// 查找文件夹中Java相关文档个数

for (String doc : docFolder) {

// 去的前后空格

doc = doc.trim();

// 全部字符转成小写

doc = doc.toLowerCase(); ④

// 比较前缀是否有java字符串

if (doc.startsWith("java")) {

javaDocCount++;

}

}

System.out.println("文件夹中Java相关文档个数是：" + javaDocCount);

输出结果：

s1 == s2 : false

s1.equals(s2) : true

s1.equalsIgnoreCase(s3) : true

s4.compareTo(s5) : 23

s4.compareToIgnoreCase(s5) : -9

文件夹中Word文档个数是： 3

文件夹中Java相关文档个数是：2

上述代码第①行的compareTo方法按字典顺序比较两个字符串，s4.compareTo(s5)表达式返回结果大于0，说明s4大于s5，字符在字典中顺序事实上就它的Unicode编码，先比较两个字符串的第一个字符j和S，j的Unicode编码是106，S的Unicode编码是83，所以可以得出结论s4 > s5。代码第②行是忽略大小写时，要么全部当成小写字母进行比较，要么当前成全部大写字母进行比较，无论哪种比较结果都是一样的s4 < s5。

代码第③行trim()方法可以去除字符串前后空白。代码第④行toLowerCase()方法可以将此字符串全部转化为小写字符串，类似的方法还有toLowerCase()方法，可将字符串全部转化为小写字符串。

字符串截取

Java中字符串String截取方法主要的方法如下：

String substring(int beginIndex)：从指定索引beginIndex开始截取一直到字符串结束的子字符串。
String substring(int beginIndex, int endIndex)：从指定索引beginIndex开始截取直到索引endIndex - 1处的字符，注意包括索引为beginIndex处的字符，但不包括索引为endIndex处的字符。

字符串截取方法示例代码如下：

String sourceStr = "There is a string accessing example.";

// 截取example.子字符串

String subStr1 = sourceStr.substring(28); ①

// 截取string子字符串

String subStr2 = sourceStr.substring(11, 17); ②

System.out.printf("subStr1 = %s%n", subStr1);

System.out.printf("subStr2 = %s%n",subStr2);

// 使用split方法分割字符串

System.out.println("-----使用split方法-----");

String[] array = sourceStr.split(" "); ③

for (String str : array) {

System.out.println(str);

}

输出结果：

subStr1 = example.

subStr2 = string

-----使用split方法-----

There

is

a

string

accessing

example.

上述sourceStr字符串索引参考图9-6所示。代码第①行是截取example.子字符串，从图9-6可见e字符索引是28, 从索引28字符截取直到sourceStr结尾。代码第②行是截取string子字符串，从图9-6可见，s字符索引是11，g字符索引是16，endIndex参数应该17。

另外，String还提供了字符串分割方法，见代码第③行split(" ")方法，参数是分割字符串，返回值String[]。

可变字符串

可变字符串在追加、删除、修改、插入和拼接等操作不会产生新的对象。

StringBuffer和StringBuilder

Java提供了两个可变字符串类StringBuffer和StringBuilder，中文翻译为“字符串缓冲区”。

StringBuffer是线程安全的，它的方法是支持线程同步，线程同步会操作串行顺序执行，在单线程环境下会影响效率。StringBuilder是StringBuffer单线程版本，Java 5之后发布的，它不是线程安全的，但它的执行效率很高。

StringBuffer和StringBuilder具有完全相同的API，即构造方法和方法等内容一样。StringBuilder的中构造方法有4个：

StringBuilder()：创建字符串内容是空的StringBuilder对象，初始容量默认为16个字符。
StringBuilder(CharSequence seq)：指定CharSequence字符串创建StringBuilder对象。CharSequence接口类型，它的实现类有：String、StringBuffer和StringBuilder等，所以参数seq可以是String、StringBuffer和StringBuilder等类型。
StringBuilder(int capacity)：创建字符串内容是空的StringBuilder对象，初始容量由参数capacity指定的。
StringBuilder(String str)：指定String字符串创建StringBuilder对象。

上述构造方法同样适合于StringBuffer类，这里不再赘述。

提示字符串长度和字符串缓冲区容量区别。字符串长度是指在字符串缓冲区中目前所包含字符串长度，通过length()获得；字符串缓冲区容量是缓冲区中所能容纳的最大字符数，通过capacity()获得。当所容纳的字符超过这长度时，字符串缓冲区自动扩充容量，但这是以牺牲新能为代价的扩容。

字符串长度和字符串缓冲区容量示例代码如下：

// 字符串长度length和字符串缓冲区容量capacity

StringBuilder sbuilder1 = new StringBuilder();

System.out.println("包含的字符串长度：" + sbuilder1.length());

System.out.println("字符串缓冲区容量：" + sbuilder1.capacity());

StringBuilder sbuilder2 = new StringBuilder("Hello");

System.out.println("包含的字符串长度：" + sbuilder2.length());

System.out.println("字符串缓冲区容量：" + sbuilder2.capacity());

// 字符串缓冲区初始容量是16，超过之后会扩容

StringBuilder sbuilder3 = new StringBuilder();

for (int i = 0; i < 17; i++) {

sbuilder3.append(8);

}

System.out.println("包含的字符串长度：" + sbuilder3.length());

System.out.println("字符串缓冲区容量：" + sbuilder3.capacity());

输出结果：

包含的字符串长度：0

字符串缓冲区容量：16

包含的字符串长度：5

字符串缓冲区容量：21

包含的字符串长度：17

字符串缓冲区容量：34

### 字符串追加 {#-0}

StringBuilder在提供了很多修改字符串缓冲区的方法，追加、插入、删除和替换等，这一节先介绍字符串追加方法。字符串追加方法是append，append有很多重载方法，可以追加任何类型数据，它的返回值还是StringBuilder。StringBuffer的追加法与StringBuffer完全一样，这里不再赘述。

字符串追加示例代码如下：

//添加字符串、字符

StringBuilder sbuilder1 = new StringBuilder("Hello"); ①

sbuilder1.append(" ").append("World"); ②

sbuilder1.append( . ); ③

System.out.println(sbuilder1);

StringBuilder sbuilder2 = new StringBuilder();

Object obj = null;

//添加布尔值、转义符和空对象

sbuilder2.append(false).append( /t ).append(obj); ④

System.out.println(sbuilder2);

//添加数值

StringBuilder sbuilder3 = new StringBuilder();

for (int i = 0; i < 10; i++) {

sbuilder3.append(i);

}

System.out.println(sbuilder3);

运行结果：

Hello World.

false null

0123456789

上述代码第①行是创建一个包含Hello字符串StringBuilder对象。代码第②行是两次连续调用append方法，由于所有的append方法都返回StringBuilder对象，所有可以连续调用该方法，这种写法比较简洁。如果连续调用append方法不行喜欢，可以append方法占一行，见代码第③行。

代码第④行连续追加了布尔值、转义符和空对象，需要注意的是布尔值false转换为false字符串，空对象null也转换为"null"字符串。

字符串插入、删除和替换

StringBuilder中实现插入、删除和替换等操作的常用方法说明如下：

StringBuilder insert(int offset, String str)：在字符串缓冲区中索引为offset的字符位置之前插入str，insert有很多重载方法，可以插入任何类型数据。
StringBuffer delete(int start, int end)：在字符串缓冲区中删除子字符串，要删除的子字符串从指定索引start开始直到索引end - 1处的字符。start和end两个参数与substring(int beginIndex, int endIndex)方法中的两个参数含义一样。
StringBuffer replace(int start, int end, String str)字符串缓冲区中用str替换子字符串，子字符串从指定索引start开始直到索引end - 1处的字符。start和end同delete(int start, int end)方法。

以上介绍的方法虽然是StringBuilder方法，但StringBuffer也完全一样，这里不再赘述。

示例代码如下：

// 原始不可变字符串

String str1 = "Java C";

// 从不可变的字符创建可变字符串对象

StringBuilder mstr = new StringBuilder(str1);

// 插入字符串

mstr.insert(4, " C++"); ①

System.out.println(mstr);

// 具有追加效果的插入字符串

mstr.insert(mstr.length(), " Objective-C"); ②

System.out.println(mstr);

// 追加字符串

mstr.append(" and Swift");

System.out.println(mstr);

// 删除字符串

mstr.delete(11, 23); ③

System.out.println(mstr);

运行输出结果：

Java C++ C

Java C++ C Objective-C

Java C++ C Objective-C and Swift

Java C++ C and Swift

上述代码第①行mstr.insert(4, " C++")是在索引4，插入字符串，原始字符串索引如同9-7所示，索引4位置是一个空格，在它之前插入字符串。代码第②行mstr.insert(mstr.length(), " Objective-C")是按照字符串的长的插入，也就是在尾部追加字符串。在执行代码第③行删除字符串之前的字符串如图9-8所示，mstr.delete(11, 23)语句是要删除"Objective-C "子字符串，第一个参数是子字符串开始索引11；第二个参数是23，结束字符的索引是22（end - 1），所以参数end是23。

《Java从小白到大牛》之第9章字符串