API 字符串的操作

1 下列说法正确的是：

A．在Java语言中，使用new关键字创建的字符串缓存在常量池中。

B．在Java语言中，可以使用直接量“字符序列”的方式创建字符串。

C．在Java语言中，对于使用new关键字创建的字符串序列，如果重复出现，JVM会首先在常量池中查找，如果存在即返回该对象。

D．下列代码的输出结果为false

1. String str1 = "WhatisJava";
2. String str2 = "WhatisJava";
3. System.out.println(str1 == str2);

参考答案

本题正确答案为B。

Java语言中可以使用直接量“字符序列”的方式创建字符串，代码如下所示：

1. String str = “WhatisJava”

出于性能的考虑，JVM会将字符串直接量对象缓存在常量池中；对于重复出现的字符串直接量，JVM会首先在常量池中查找，如果存在即返回该对象。请看下列代码：

 

1. String str1 = "WhatisJava";
2. String str2 = "WhatisJava";
3. System.out.println(str1 == str2);

以上代码的输出结果为true，第二次定义的“WhatisJava”不会重复创建String对象，而是使用str1所指向的对象。如果是使用new关键字创建的字符串，则不会缓存在常量池中，代码如下所示：

 

1. String str1 = "WhatisJava";
2. String str3 = new String("WhatisJava");
3. System.out.println(str1 == str3);

以上代码的输出结果为false，使用new关键字将会创建新的String对象。

2 下面关于字符串长度说法正确的是:

A．使用Java中的String类的length方法计算字符串的长度，如果是英文算1个长度，如果是中文算2个长度。

B．使用Java中的String类的length方法计算字符串的长度，由于Java采用Unicode编码任何一个字符在内存中算2个长度 ，因此，length方法中也是一个字符2个长度，不区分中文还是英文。

C．使用Java中的String类的length方法计算字符串的长度，无论中文还是英文都算1个长度。

D．使用Java中的String类的length方法计算字符串"你好String"的长度为10。

参考答案

本题正确答案为C。

使用Java中的String类的length方法计算字符串的长度，无论中文还是英文都算1个长度。另外，在Java中，字符在内存里采用的是Unicode编码，每个字符占用两个字节，请注意区别。

3 获取一个字符串中最后一个"/"后的字符序列

获取一个字符串中最后一个"/"后的字符序列，即，现有字符串“someapp/manager/emplist.action”，截取该字符串最后一个“/”后的所有字符，截取后的结果为字符串“emplist.action”。

在课上案例“将其他类型转换为字符串类型”的基础上完成当前案例。

参考答案

首先，使用String类的lastIndexOf方法获取字符串“someapp/manager/emplist.action”中最后一个“/”的索引位置；然后在该索引位置的基础上加1，形成新的索引位置；最后，使用String类的substring方法，从新的索引位置开始截取到字符串的末尾，即为字符串“emplist.action”。

实现此案例需要按照如下步骤进行。

步骤一：重构TestString类，添加getPath方法

在课上案例“将其他类型转换为字符串类型”的基础上，在TestString类中添加getPath方法，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestString {
6.     //...（之前案例的代码，略）
8.     /**
9.      * 获取一个字符串中最后一个"/"后的字符序列
10.      */
11.     @Test
12.     public void getPath() {
13.     }
14. }

步骤二：使用String类的lastIndexOf方法和substring方法

首先，使用String类的lastIndexOf方法获取字符串“someapp/manager/emplist.action”中最后一个“/”的索引位置；然后在该索引位置的基础上加1，形成新的索引位置；最后，使用String类的substring方法，从新的索引位置开始截取到字符串的末尾，即为字符串“emplist.action”，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestString {
6.     //...（之前案例的代码，略）
8.     /**
9.      * 获取一个字符串中最后一个"/"后的字符序列
10.      */
11.     @Test
12.     public void getPath() {
13.         String uri = "someapp/manager/emplist.action";
14.         String path = uri.substring(uri.lastIndexOf("/") + 1);
15.         System.out.println(path); // emplist.action
16.     }
17. }

步骤三：运行

运行getPath方法，控制台输出结果如下所示：

1. emplist.action

从输出结果可以看出，与预期结果相符。

本案例中，TestString类的完整代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestString {
6.     //...（之前案例的代码，略）
8.     /**
9.      * 获取一个字符串中最后一个"/"后的字符序列
10.      */
11.     @Test
12.     public void getPath() {
13.         String uri = "someapp/manager/emplist.action";
14.         String path = uri.substring(uri.lastIndexOf("/") + 1);
15.         System.out.println(path); // emplist.action
16.     }
17. }

4 说出trim方法一般用在何处

参考答案

trim方法一般用于去除用户输入信息中的前后空白以及处理文件内容时，去除文件中的空白。

5 检测一个字符串是否为回文

回文字符串是指正着读和反着读该字符串都是相同拼写，比如“radar”、“level“。

本案例要求编写程序判断字符串“able was i ere i saw elba”是否为回文。

在课后案例“获取一个字符串中最后一个"/"后的字符序列”的基础上完成当前案例。

参考答案

首先，使用循环，在循环中，使用String类的charAt方法获取i位置的字符与（str.length() - i – 1）位置的字符是否相等，如果有一对不等的情况，则说明不是回文。循环的代码如下所示：

 

1. for (int i = 0; i < str.length() / 2; i++) {
2.             if (str.charAt(i) != str.charAt(str.length() - i - 1)) {
3.                 flag = false;
4.                 break;
5.             }
6.         }

实现此案例需要按照如下步骤进行。

步骤一：重构TestString类，添加palindrome方法

在课后案例“获取一个字符串中最后一个"/"后的字符序列”的基础上，在TestString类中添加palindrome方法，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestString {
6.     //...（之前案例的代码，略）
8.     /**
9.      * 检测一个字符串是否为回文
10.      */
11.     @Test
12.     public void palindrome() {
13.     }
14. }

步骤二：使用String类的charAt方法

使用循环，在循环中，使用String类的charAt方法获取i位置的字符与（str.length() - i – 1）位置的字符是否相等，如果有一对不等的情况，则说明不是回文，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestString {
6.     //...（之前案例的代码，略）
8.     /**
9.      * 检测一个字符串是否为回文
10.      */
11.     @Test
12.     public void palindrome() {
13.         String str = "able was i ere i saw elba";
15.         boolean flag = true;
16.         for (int i = 0; i < str.length() / 2; i++) {
17.             if (str.charAt(i) != str.charAt(str.length() - i - 1)) {
18.                 flag = false;
19.                 break;
20.             }
21.         }
22.         if (flag) {
23.             System.out.println("是回文");
24.         } else {
25.             System.out.println("不是回文");
26.         }
27.     }
28. }

步骤三：运行

运行palindrome方法，控制台输出结果如下所示：

1. 是回文

从输出结果可以看出，字符串"able was i ere i saw elba"为回文。

本案例中，TestString类的完整代码如下所示：

 

1. package day01;
3. import org.junit.Test;
4. public class TestString {
5.     //...（之前案例的代码，略）
7.     /**
8.      * 检测一个字符串是否为回文
9.      */
10.     @Test
11.     public void palindrome() {
12.         String str = "able was i ere i saw elba";
14.         boolean flag = true;
15.         for (int i = 0; i < str.length() / 2; i++) {
16.             if (str.charAt(i) != str.charAt(str.length() - i - 1)) {
17.                 flag = false;
18.                 break;
19.             }
20.         }
21.         if (flag) {
22.             System.out.println("是回文");
23.         } else {
24.             System.out.println("不是回文");
25.         }
26.     }
27. }

6 生成一个包含所有汉字的字符串

生成一个包含所有汉字的字符串,即，编写程序输出所有汉字，每生成50个汉字进行换行输出。

在课上案例“测试StringBuilder的delete方法“的基础上完成当前案例。

参考答案

在Java中，字符类型事实上是一个16位无符号整数，这个值对应字符的编码, Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如： ‘u4e2d’。所有汉字的Unicode范围是U+4E00～U+9FA5。

本案例中，首先，使用循环，以Unicode汉字编码U+4E00作为循环的开始，以汉字编码U+9FA5作为循环的结束；然后，在循环中，使用StringBuilder的append方法进行字符串累加，并且计算生成的汉字个数，进行换行，代码如下所示：

 

1. for (char c = 'u4e00', i = 1; c <= 'u9fa5'; c++, i++) {
2.             sb.append(c);
3.             if (i % 50 == 0) {
4.                 sb.append(" ");
5.             }
6.         }

实现此案例需要按照如下步骤进行。

步骤一：在类中添加测试方法

在TestStringBuilder类中添加测试方法chineseCharacters，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestStringBuilder {
6.     /**
7.      * 生成一个包含所有汉字的字符串
8.      */
9.     @Test
10.     public void chineseCharacters() {
11.         
12.     }
13. }

步骤二：使用StringBuilder的append方法

首先，使用循环，以Unicode汉字编码U+4E00作为循环的开始，以汉字编码U+9FA5作为循环的结束；然后，在循环中，使用StringBuilder的append方法进行字符串累加，并且计算生成的汉字个数，进行换行，代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestStringBuilder {
6.     /**
7.      * 生成一个包含所有汉字的字符串
8.      */
9.     @Test
10.     public void chineseCharacters() {
11.         StringBuilder sb = new StringBuilder();
12.         // “U+4E00..U+9FA5
13.         for (char c = 'u4e00', i = 1; c <= 'u9fa5'; c++, i++) {
14.             sb.append(c);
15.             if (i % 50 == 0) {
16.                 sb.append(" ");
17.             }
18.         }
19.         System.out.println(sb.length());
20.         System.out.println(sb.toString());
21.     }
22. }

步骤三：运行

运行chineseCharacters方法，控制台为输出结果的部分内容如图-1所示。

图- 1

本案例中，TestStringBuilder的完整代码如下所示：

 

1. package day01;
3. import org.junit.Test;
5. public class TestStringBuilder {
6.     //...（之前案例的代码，略）
7.     
8.     /**
9.      * 生成一个包含所有汉字的字符串
10.      */
11.     @Test
12.     public void chineseCharacters() {
13.         StringBuilder sb = new StringBuilder();
14.         // “U+4E00..U+9FA5
15.         for (char c = 'u4e00', i = 1; c <= 'u9fa5'; c++, i++) {
16.             sb.append(c);
17.             if (i % 50 == 0) {
18.                 sb.append(" ");
19.             }
20.         }
21.         System.out.println(sb.length());
22.         System.out.println(sb.toString());
23.     }
24. }

7 阅读Apache Commons-lang.jar中StringUtils文档，掌握leftPad、rightPad、repeat、abbreviate、join等方法(提高题，选做)

参考答案

commons-lang是Apache Commons 项目中的一个组件，commons-lang针对JDK官方的java.lang包中的类提供了一些实用的补充，在实践中应用很广。

StringUtils是commons-lang包中提供的，针对字符串操作的工具类，该类提供了一系列静态实用方法，如表－1所示：

表－1 StringUtil类中方法介绍

下面给出以上几个方法的测试代码，请自行进行测试，代码如下所示：

 

1. package day01;
3. import org.apache.commons.lang3.StringUtils;
4. import org.junit.Test;
6. public class TestStringUtils {
8.     @Test
9.     public void testLeftPadAndRightPad() {
10.         String name = StringUtils.leftPad("goodman", 10, "*");
11.         System.out.println(name);
13.         name = StringUtils.rightPad("goodman", 10, "*");
14.         System.out.println(name);
15.     }
17.     @Test
18.     public void testRepeat() {
19.         String str = "Java";
20.         str = StringUtils.repeat(str, 10);
21.         System.out.println(str);
22.     }
24.     @Test
25.     public void testAbbreviate() {
26.         String line = "How long no see you";
27.         line = StringUtils.abbreviate(line, 15);
28.         System.out.println(line);
29.     }
31.     @Test
32.     public void testJoin() {
33.         String[] strArr = { "Java", "C++", "C#", "PHP", "Objective-C" };
34.         String str = StringUtils.join(strArr, " ");
35.         System.out.println(str);
36.     }
37. }