String的案例_string 案例-CSDN博客

本文链接：https://blog.csdn.net/u011707402/article/details/41692047

1 规范注释及文档生成（Eclipse）

1.1 问题

请看下列代码，其作用如下：

1）类JavadocTest的作用是用于测试生成Javadoc文档；作者为jessica；版本为1.0。

2）方法hello的作用为获取打招呼字符串；该方法的参数name表示指定向谁打招呼；该方法返回打招呼的字符串。

package day01;
public class JavadocTest {
	public String hello(String name) {
		return name + ",你好！";
	}
}

使用文档注释，为上述代码添加注释，并生成Javadoc文档。

1.2 步骤

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

步骤一：为代码添加文档注释

根据问题的描述，使用/** */为代码添加注释。代码如下所示：

	package day01;

/**
* <strong>JavadocTest</strong>类用于测试生成Javadoc文档
* 
* @author jessica
* @version 1.0
*/
public class JavadocTest {
	/**
	 * 获取打招呼字符串
	 * 
	 * @param name
	 *            该参数指定向谁打招呼
	 * @return 返回打招呼的字符串
	 */
	public String hello(String name) {
		return name + ",你好！";
	}
}

步骤二：使用Eclipse生成文档注释

首先，点击Project-->Generate Javadoc,如图-1所示。

图- 1

点击Generate Javadoc以后，进入下一界面，选择你要生成Javadoc的包，或包下的类以及生成的Javadoc所存在的路径，默认生成到当前工程目录下，如图-2所示。

图- 2

点击Finish，即可生成Javadoc。生成的Javadoc文件如图-3所示：

图- 3

点击index.html，查看具体内容，如图-4所示。

图- 4

1.3 完整代码

本案例中，添加注释后的完整代码如下所示：

	package day01;

/**
* <strong>JavadocTest</strong>类用于测试生成Javadoc文档
* 
* @author jessica
* @version 1.0
*/

public class JavadocTest {
	/**
	 * 获取打招呼字符串
	 * 
	 * @param name
	 *            该参数指定向谁打招呼
	 * @return 返回打招呼的字符串
	 */
	public String hello(String name) {
		return name + ",你好！";
	}
}

2 测试String常量池

2.1 问题

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

本案例要求使用JUnit构建测试方法，测试String常量池的特点。即，首先，使用直接量“字符序列”的方式创建两个字符串对象，字符串的内容都为“Hello”；然后，使用“==”比较这两个字符串对象是否相等并输出比较结果；最后，使用new的方式构建第三个字符串对象，字符串的内容也为“Hello”，接着，使用“==”比较第一个字符串对象和第三个字符串对象是否相等并输出比较结果，根据输出结果验证String常量池的特点。

2.2 方案

首先，构建工程，包和类。

其次，在工程中添加JUnit的支持。

第三，在类中新建测试方法。

第四，首先，使用直接量“字符序列”的方式创建两个字符串对象，字符串的内容为“Hello”，然后，使用“==”比较两个字符串对象是否相等并输出比较结果。两个对象使用“==”进行比较，如果返回值为true，说明两个对象的引用所指向的内存区域相同，即，指向了同一个对象。在此，可以说明，第一个字符串和第二个字符串是同一字符串且来自String常量池。因此，对于重复出现的字符串直接量，JVM会首先在缓存池中查找，如果存在即返回该对象。

第五，使用new的方式构建第三个字符串对象，字符串的内容为“Hello”，使用“==”比较第一个字符串对象和第三个字符串对象是否相等并输出比较结果。两个对象使用“==”进行比较，如果返回值为false，说明两个对象的引用所指向的内存区域不同，同时也说明，使用new方式构建的第三个字符串不会存储在String常量池中。

2.3 步骤

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

步骤一：构建工程，包和类

首先，新建名为JavaSE的工程，然后，在工程的src下新建名为day01的包，在包下新建名为TestString的类，工程结构图如图-5所示。TestString代码如下所示：

package day01;

public class TestString {

}

图- 5

步骤二：添加JUnit的支持

给JavaSE工程添加JUnit支持。首先，选中工程，右键-->Build Path-->Add Libraries...，如图-6所示。

图- 6

点击“Add Libraries...”后进入界面如图-7所示。

图- 7

接着，选择JUnit，如图-8所示，点击Next,进入如图-9所示界面。

图- 8

图- 9

最后，选择JUnit4，点击“Finish”后，工程结构图如图-10所示。

图- 10

从图-10中可以看到JUnit4的支持已经添加成功。

步骤三：新建测试方法

在类TestString中，新建方法testConstantPool并在该方法前使用注解@Test，表明该方法为JUnit4要进行测试的单元测试方法。代码如下所示：

package day01;

#cold_boldimport org.junit.Test;

public class TestString {
	/**
	 * 测试String常量池
	 */
#cold_bold	@Test
#cold_bold	public void testConstantPool() {
#cold_bold	}
}

注意导入包：org.junit.Test。

步骤四：比较直接量“字符序列”的方式创建两个字符串对象

首先，使用直接量“字符序列”的方式创建两个字符串对象str1和str2，两个符串的内容都为“Hello”，然后，使用“==”比较str1和str2是否相等并输出比较结果。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 测试String常量池
	 */
	@Test
	public void testConstantPool() {
#cold_bold		String str1 = "Hello";
#cold_bold		// 不会创建新的String对象，而是使用常量池中已有的"Hello".
#cold_bold		String str2 = "Hello";
#cold_bold		System.out.println(str1 == str2);
	}
}

步骤五：运行

首先，点开TestString类的目录结构，如图-11所示。

图- 11

在图-11中，可以看到我们刚刚加入的方法testConstantPool方法，选中该方法，右键-->Run As -->JUnit Test,就可以运行该方法，如图-12所示。

图- 12

上述运行方式，只运行当前选中方法。也可以选中方法所在的类，右键-->Run As -->JUnit Test运行，但是，如果该类中有很多测试（@Test注解）方法，那么，所有方法都将运行。

运行testConstantPool方法后，会打开JUnit视图，如图-13所示，在该视图中，可以看到绿色的进度条，说明方法运行正确，否则，进度条为红色。

图- 13

点击Console打开控制台视图，可以看到控制台输出结果为：

true

从输出结果可以看出，str1和str2使用“==”比较的结果为true。两个对象使用“==”进行比较，如果返回值为true，说明两个对象的引用所指向的内存区域相同，即，指向了同一个对象。在此，可以说明，str1和str2指向同一个对象，该对象来自String常量池，即，字符串直接量对象缓存在常量池中；对于重复出现的字符串直接量，JVM会首先在缓存池中查找，如果存在即返回该对象。

步骤六：使用new的方式构建str3，比较str1和str3是否相等

使用new的方式构建字符串str3，字符串的内容也为“Hello”，使用“==”比较str1和str3是否相等并输出比较结果。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 测试String常量池
	 */
	@Test
	public void testConstantPool() {
		String str1 = "Hello";
		// 不会创建新的String对象，而是使用常量池中已有的"Hello".
		String str2 = "Hello";
		System.out.println(str1 == str2);
#cold_bold		// 使用new关键字会创建新的String对象.
#cold_bold		String str3 = new String("Hello");
#cold_bold		System.out.println(str1 == str3);
	}
}

步骤七：运行

再次运行testConstantPool方法，控制台输出结果如下：

true
#cold_boldfalse

可以看出str1和str3使用“==”比较的结果为false。两个对象使用“==”进行比较，如果返回值为false，说明两个对象的引用所指向的内存区域不同，在此说明，str3不是来自常量池，即，使用new方式创建的字符串对象，不会缓存在String常量池中。

2.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 测试String常量池
	 */
	@Test
	public void testConstantPool() {
		String str1 = "Hello";
		// 不会创建新的String对象，而是使用常量池中已有的"Hello".
		String str2 = "Hello";
		System.out.println(str1 == str2);
		// 使用new关键字会创建新的String对象.
		String str3 = new String("Hello");
		System.out.println(str1 == str3);
	}
}

3 获取String对象的长度

3.1 问题

在上一案例的基础上，使用String类的length方法获取字符串“Hello”以及字符串“你好，String”的长度，并总结length方法的特点。

3.2 方案

首先，在类TestString中添加单元测试方法testLength，然后，定义字符串对象str1和str2,分别初始化为“Hello”和“你好，String”，最后，调用String类的length方法分别计算对象str1和str2的长度。length方法的声明如下：

int length()

以上方法返回字符串字符序列的长度。

3.3 步骤

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

步骤一：创建testLength方法

在类TestString中添加单元测试方法testLength。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
#cold_bold	/**
#cold_bold	 * 获取String对象的长度
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testLength() {
#cold_bold	}
}

步骤二：使用length方法，获取字符串对象的长度

首先，定义字符串对象str1和str2,分别初始化为“Hello”和“你好，String”，最后，调用String类的length方法分别计算对象str1和str2的长度，代码如下所示：

</pre><p class="number"></p><pre class="java" name="code">package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 获取String对象的长度
	 */
	@Test
	public void testLength() {
#cold_bold		String str1 = "Hello";
#cold_bold		System.out.println(str1.length());
#cold_bold
#cold_bold		// 在内存中采用Unicode编码，每个字符占用两个字节.
#cold_bold		// 任何一个字符(无论中文还是英文)都算1个字符长度.
#cold_bold		String str2 = "你好，String";
#cold_bold		System.out.println(str2.length());
	}
}

步骤三：测试

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

5
9

观察输出结果，5为str1字符串对象的长度，9为str2字符串对象的长度。对象str1的内容为“Hello”，由5个字母组成，其计算出来长度为5，即，一个英文字母是1个长度。接着，查看对象str2的长度情况，对象str2的内容为“你好，String”，去除“你好”，str2剩余的长度为7，如果一个中文按照2个长度计算，那么对象str2的长度应为11，但是，输出结果却为9，说明一个中文没有按照2个长度计算，而是按照1个长度。

另外，在Java中，字符在内存里采用的是Unicode编码，每个字符占用两个字节，请注意区别。

3.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
 //...（之前案例的代码，略）

	/**
	 * 获取String对象的长度
	 */
	@Test
	public void testLength() {
		String str1 = "Hello";
		System.out.println(str1.length());

		// 在内存中采用Unicode编码，每个字符占用两个字节.
		// 任何一个字符(无论中文还是英文)都算1个字符长度.
		String str2 = "你好，String";
		System.out.println(str2.length());
	}
}

4 在一个字符串中检索另外一个字符串

4.1 问题

在上一案例的基础上，检索一个字符串在另一个字符中的索引位置。即，现有字符串"I can because i think i can"，检索字符串“can”在此字符串中出现的索引位置。详细要求如下：

1），检索字符串“can”在此字符串中第一次出现的索引位置。

2），检索字符串“can”在此字符串中最后一次出现的索引位置。

3），从索引位置为6开始，检索字符串“can”在此字符串第一次出现的索引位置。

4），检索字符串“Can”在此字符串中第一次出现的索引位置。注意字符串“Can”中的字母C为大写。

4.2 方案

1）定义字符串对象str，初始化为“I can because i think i can”，接着，

调用indexOf方法，检索字符串“can”在此字符串中第一次出现的索引位置。该方法声明如下：

int indexOf(String str)

以上indexOf方法表示在字符串中检索str，返回其第一出现的索引位置，如果找不到则返回-1。

2）调用lastIndexOf的方法，检索字符串“can”在此字符串中最后一次出现的索引位置。该方法声明如下：

int lastIndexOf   (String str)

lastIndexOf方法和indexOf方法类似，只是当str在字符串中多次出现时，将返回最后一个出现的索引位置，如果找不到则返回-1。

3）调用重载的indexOf方法，从索引位置为6开始，检索字符串“can”在此字符串中第一次出现的索引位置。该方法声明如下：

int indexOf(String str, int fromIndex)

以上方法类似indexOf(String)，但是是从字符串的fromIndex位置开始检索。

4）调用indexOf（String str）检索字符串“Can”在此字符串中第一次出现的索引位置，如果找不到则返回-1。

4.3 步骤

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

步骤一：使用indexOf（String str）

首先，在类TestString中，添加测试方法testIndexOf。在该方法中，首先定义字符串对象str，初始化为“I can because i think i can”，接着，调用indexOf方法，检索字符串“can”在字符串str中第一次出现的索引位置。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中检索另外一个字符串
	 */
	@Test
	public void testIndexOf() {
#cold_bold		String str = "I can because i think i can";
#cold_bold		int index = str.indexOf("can");
#cold_bold		System.out.println(index); // 2
	}
}

运行testIndexOf方法，控制台输出结果如下：

从输出结果可以看出，字符串“can”在字符串中第一次出现的索引位置为2。

步骤二：使用lastIndexOf方法

调用lastIndexOf的方法，检索字符串“can”在字符串str中最后一次出现的索引位置。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中检索另外一个字符串
	 */
	@Test
	public void testIndexOf() {
		String str = "I can because i think i can";
		int index = str.indexOf("can");
		System.out.println(index); // 2

#cold_bold		index = str.lastIndexOf("can");
#cold_bold		System.out.println(index); // 24
	}
}

运行testIndexOf方法，控制台输出结果如下：

2
#cold_bold24

从输出结果可以看出，字符串“can”在str中最后一次出现的索引位置为24。

步骤三：使用indexOf(String str, int fromIndex)

调用重载的indexOf方法，从索引位置为6开始，检索字符串“can”在字符串str中第一次出现的索引位置。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中检索另外一个字符串
	 */
	@Test
	public void testIndexOf() {
		String str = "I can because i think i can";
		int index = str.indexOf("can");
		System.out.println(index); // 2

		index = str.lastIndexOf("can");
		System.out.println(index); // 24

#cold_bold		index = str.indexOf("can", 6);
#cold_bold		System.out.println(index); // 24
	}
}

运行testIndexOf方法，控制台输出结果如下：

2
24
#cold_bold24

从输出结果可以看出，从索引位置6开始，字符串“can”在str中第一次出现的索引位置为24。

步骤四：使用indexOf(String str)，要检索的字符串不存在的情况

调用indexOf（String str）检索字符串“Can”在此字符串中第一次出现的索引位置，如果找不到则返回-1。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中检索另外一个字符串
	 */
	@Test
	public void testIndexOf() {
		String str = "I can because i think i can";
		int index = str.indexOf("can");
		System.out.println(index); // 2

		index = str.lastIndexOf("can");
		System.out.println(index); // 24

		index = str.indexOf("can", 6);
		System.out.println(index); // 24

		index = str.indexOf("Can");
		System.out.println(index); // -1
	}
}

运行testIndexOf方法，控制台输出结果如下：

2
24
24
#cold_bold-1

从输出结果可以看出，控制台的输出结果为-1，说明字符串“Can”在str中不存在。

4.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 在一个字符串中检索另外一个字符串
	 */
	@Test
	public void testIndexOf() {
		String str = "I can because i think i can";
		int index = str.indexOf("can");
		System.out.println(index); // 2

		index = str.lastIndexOf("can");
		System.out.println(index); // 24

		index = str.indexOf("can", 6);
		System.out.println(index); // 24

		index = str.indexOf("Can");
		System.out.println(index); // -1
	}
}

5 在一个字符串中截取指定字符串

5.1 问题

在一个字符串中截取指定的字符串，即，现有字符串"http://www.oracle.com"，截取此字符串中的部分字符串形成新字符串。详细要求如下：

1）截取此字符串中的字符串“oracle”。

2）从索引位置7（包括）开始，截取到此字符串的结尾。

5.2 方案

1）首先，定义字符串对象str，初始化为“http://www.oracle.com”。接着，使用重载的substring方法，截取字符串str中的字符串“oracle”，该substring方法的声明如下：

String substring(int beginIndex，int endIndex)

以上substring方法，返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串。

2）用重载的substring方法，从索引位置7（包括）开始，截取到此字符串的结尾，该substring方法声明如下：

String substring(int beginIndex)

以上substring方法，返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串。

5.3 步骤

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

步骤一：使用substring(int beginIndex，int endIndex)方法

首先，在TestString类中添加测试方法testSubstring；然后，在该方法中，定义字符串对象str，初始化为“http://www.oracle.com”；接着，使用重载的substring(int beginIndex，int endIndex)方法，截取字符串str中的字符串“oracle”，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中截取指定的字符串
	 */
#cold_bold	@Test
#cold_bold	public void testSubstring() {
#cold_bold		String str = "http://www.oracle.com";
#cold_bold		String subStr = str.substring(11, 17);
#cold_bold		System.out.println(subStr); // oracle
#cold_bold	}
}

运行testSubstring方法，控制台输出结果如下：

oracle

从输出结果可以看出，取到了子字符串“oracle”。

观察输出结果，并对比代码，不难发现，在使用substring(int beginIndex，int endIndex)方法时，其参数索引位置的特点为“前包括后不包括”，这样设计的目的是使得后一个参数减去前一个参数的值正好是截取子字符串的长度。

步骤二：substring(int beginIndex)方法

用重载的substring(int beginIndex)方法，从索引位置7（包括）开始，截取到此字符串的结尾，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 在一个字符串中截取指定的字符串
	 */
	@Test
	public void testSubstring() {
		String str = "http://www.oracle.com";
		String subStr = str.substring(11, 17);
		System.out.println(subStr); // oracle

#cold_bold		subStr = str.substring(7);
#cold_bold		System.out.println(subStr); // www.oracle.com
	}
}

运行testSubstring方法，运行结果如下所示：

oracle
#cold_boldwww.oracle.com

从输出结果可以看出，从索引位置7开始后的字符串为“www.oracle.com”。

5.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 在一个字符串中截取指定的字符串
	 */
	@Test
	public void testSubstring() {
		String str = "http://www.oracle.com";
		String subStr = str.substring(11, 17);
		System.out.println(subStr); // oracle

		subStr = str.substring(7);
		System.out.println(subStr); // www.oracle.com
	}
}

6 去掉一个字符串的前导和后继空字符

6.1 问题

在上一案例的基础上，去掉一个字符串的前导和后继空白，即，现有字符串" good man "，该字符串的good前面有两个空格，man后面有两个空格，本案例要求去掉该字符串前后的空格，得到去除空格后的字符串，在此过程中对比去除空格前后字符串的长度。

6.2 方案

首先，定义字符串对象userName，并初始化为" good man "，然后，使用length方法获取字符串userName的长度并输出；接着，调用trim方法，去除字符串userName的前导和后继空白；最后，再次使用length方法获取字符串userName的长度并输出长度和该字符串。trim方法的声明如下：

String trim()

以上trim方法返回字符串为原始字符串去掉前导和后继的空白。

6.3 步骤

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

步骤一：使用length方法

首先，在TestString类中添加测试方法testTrim，然后，定义字符串对象userName，并初始化为" good man "，最后，使用length方法获取字符串userName的长度并输出。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 去掉一个字符串的前导和后继空字符
	 */
	@Test
	public void testTrim() {
#cold_bold		String userName = "  good man  ";
#cold_bold		System.out.println(userName.length()); // 12
	}
}

运行testTrim方法，控制台输出结果如下：

从输出结果可以看出，此时字符串userName的长度为12。

步骤二：使用trim方法

首先，调用trim方法，去除字符串userName的前导和后继空白；最后，再次使用length方法获取字符串userName的长度并输出该长度和该字符串，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 去掉一个字符串的前导和后继空字符
	 */
	@Test
	public void testTrim() {
		String userName = "  good man  ";
		System.out.println(userName.length()); // 12
#cold_bold		userName = userName.trim();
#cold_bold		System.out.println(userName.length()); // 8
#cold_bold		System.out.println(userName); // good man
	}
}

运行testTrim方法，控制台输出结果如下：

12
8
good man

查看输出结果，可以看出去掉前导和后继空白后的字符串长度为8。

6.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 去掉一个字符串的前导和后继空字符
	 */
	@Test
	public void testTrim() {
		String userName = "  good man  ";
		System.out.println(userName.length()); // 12
		userName = userName.trim();
		System.out.println(userName.length()); // 8
		System.out.println(userName); // good man
	}
}

7 遍历一个字符串中的字符序列

7.1 问题

在上一案例的基础上，遍历一个字符串中的字符序列，即，现有字符串"Whatisjava?"，遍历该字符串中每一个字符并输出。

7.2 方案

首先，定义字符串对象name，并初始化为"Whatisjava?"；然后，使用固定次数的循环，循环的条件为小于字符串name的长度，即，name.length()；最后，在循环中使用charAt方法，获取字符串name各个位置的字符，即，char c = name.charAt(i);，并输出字符c。其中，charAt方法的声明如下所示：

char charAt(int index)

以上charAt方法用于返回字符串指定位置的字符。参数index表示指定的位置。

7.3 步骤

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

步骤一：创建测试方法

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

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 遍历一个字符串中的字符序列
	 */
#cold_bold	@Test
#cold_bold	public void testCharAt() {
#cold_bold		
#cold_bold	}
}

步骤二：遍历字符串中的字符序列

首先，定义字符串对象name，并初始化为"Whatisjava?"；然后，使用固定次数的循环，循环的条件为小于字符串name的长度，即，name.length()；最后，在循环中使用charAt方法，获取字符串name各个位置的字符，即，char c = name.charAt(i);，并输出字符c。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 遍历一个字符串中的字符序列
	 */
	@Test
	public void testCharAt() {
#cold_bold		String name = "Whatisjava?";
#cold_bold		for (int i = 0; i < name.length(); i++) {
#cold_bold			char c = name.charAt(i);
#cold_bold			System.out.print(c + " ");
#cold_bold		}
#cold_bold		// W h a t i s j a v a ?
	}
}

步骤三：运行

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

W h a t i s j a v a ?

从输出结果，再结合代码，可以看出已经遍历到字符串name中的每一个字符。

7.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 遍历一个字符串中的字符序列
	 */
	@Test
	public void testCharAt() {
		String name = "Whatisjava?";
		for (int i = 0; i < name.length(); i++) {
			char c = name.charAt(i);
			System.out.print(c + " ");
		}
		// W h a t i s j a v a ?
	}
}

8 检测一个字符串是否以指定字符串开头或结尾

8.1 问题

在上一案例的基础上，检测一个字符串是否以指定字符串开头或结尾，即，现有字符串

"Thinking in Java"，检索该字符串是否以字符串“Java”作为结尾；是否以字符串“T”作为开头；是否以“thinking”作为开头。

8.2 方案

首先，定义字符串对象str，并初始化为"Thinking in Java"；

然后，调用endsWith方法，判断字符串str是否以字符串“Java”作为结尾。endsWith方法的声明如下所示：

boolean endsWith(String suffix)

以上endsWith方法用于判断字符串是否以参数字符串结尾，如果是则返回true，否则返回false。

第三，调用startsWith方法，判断字符串str是以已字符串“T”或者“thinking”作为开头。startsWith方法的声明如下所示：

boolean startsWith(String prefix)

以上startsWith方法用于判断字符串是否以参数字符串开头，如果是则返回true，否则则返回false。

8.3 步骤

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

步骤一：添加测试方法

首先，在TestString类中添加测试方法testStartsWithAndEndsWith，然后，在该方法中，定义字符串对象str，并初始化为"Thinking in Java"，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
#cold_bold	/**
#cold_bold	 * 检测一个字符串是否以指定字符串开头或结尾
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testStartsWithAndEndsWith() {
#cold_bold		String str = "Thinking in Java";
#cold_bold	}
}

步骤二：使用endsWith方法

调用endsWith方法，判断字符串str是否以字符串“Java”作为结尾。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 检测一个字符串是否以指定字符串开头或结尾
	 */
	@Test
	public void testStartsWithAndEndsWith() {
		String str = "Thinking in Java";
#cold_bold		System.out.println(str.endsWith("Java")); // true
	}
}

运行testStartsWithAndEndsWith方法，控制台的输出结果为：

true

从输出结果可以看出，字符串str确实以“Java”作为结尾。

步骤三：使用startsWith方法

调用startsWith方法，判断字符串str是否以字符串“T”或者字符串“thinking”作为开头，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 检测一个字符串是否以指定字符串开头或结尾
	 */
	@Test
	public void testStartsWithAndEndsWith() {
		String str = "Thinking in Java";
		System.out.println(str.endsWith("Java")); // true
#cold_bold		System.out.println(str.startsWith("T")); // true
#cold_bold		System.out.println(str.startsWith("thinking")); // false
	}
}

运行testStartsWithAndEndsWith方法，控制台输出结果为：

true
#cold_boldtrue
#cold_boldfalse

从输出结果可以看出，字符串str以“T”作为开头，没有以“thinking”作为开头。

8.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 检测一个字符串是否以指定字符串开头或结尾
	 */
	@Test
	public void testStartsWithAndEndsWith() {
		String str = "Thinking in Java";
		System.out.println(str.endsWith("Java")); // true
		System.out.println(str.startsWith("T")); // true
		System.out.println(str.startsWith("thinking")); // false
	}
}

9 转换字符串中英文字母的大小写形式

9.1 问题

在上一案例的基础上，将字符串中的英文字符都转换成小写或者都转换成大写形式，即，现有字符串"我喜欢Java"，将该字符串中的英文Java都转成小写形式或者转成大写形式。

9.2 方案

首先，使用String类的toUpperCase方法将字符串中的所有英文字符转换成大写，该方法声明如下所示：

String toUpperCase()

以上方法用于返回字符串的大写形式。

其次，使用String类的toLowerCase方法将字符串中的所有英文字符转换成小写，该方法声明如下所示：

String toLowerCase()

以上方法用于返回字符串的小写形式。

9.3 步骤

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

步骤一：使用toUpperCase方法

首先，在类TestString中，添加测试方法，然后，在该方法中，首先，定义字符串str，然后初始化为"我喜欢Java"，接着，使用String类的toUpperCase方法将字符串中的所有英文字符转换成大写形式。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
#cold_bold	/**
#cold_bold	 * 转换字符串中英文字母的大小写形式
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testToUpperCaseAndToLowerCase() {
#cold_bold		String str = "我喜欢Java";
#cold_bold
#cold_bold		str = str.toUpperCase();
#cold_bold		System.out.println(str); // 我喜欢JAVA
#cold_bold	}
}

运行testToUpperCaseAndToLowerCase方法，控制台输出结果如下：

我喜欢JAVA

从输出结果可以看出，已经将小写“Java”，转成了大写形式的“JAVA”。

步骤二：使用toLowerCase方法

使用String类的toLowerCase方法将字符串中的所有英文字符转换成小写。代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 转换字符串中英文字母的大小写形式
	 */
	@Test
	public void testToUpperCaseAndToLowerCase() {
		String str = "我喜欢Java";

		str = str.toUpperCase();
		System.out.println(str); // 我喜欢JAVA

#cold_bold		str = str.toLowerCase();
#cold_bold		System.out.println(str); // 我喜欢java
	}
}

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

我喜欢JAVA
#cold_bold我喜欢java

从输出结果可以看出，又将大写的“JAVA”转成了小写“java”的形式。

9.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 转换字符串中英文字母的大小写形式
	 */
	@Test
	public void testToUpperCaseAndToLowerCase() {
		String str = "我喜欢Java";

		str = str.toUpperCase();
		System.out.println(str); // 我喜欢JAVA

		str = str.toLowerCase();
		System.out.println(str); // 我喜欢java
	}
}

10 将其他类型转换为字符串类型

10.1 问题

在上一案例的基础上，将其他类型转换为字符串类型，即，将double类型，int类型，boolean类型以及char数组类型的变量转换为String类型变量。

10.2 方案

使用String 类的valueOf重载的方法，可以将double类型，int类型，boolean类型以及char数组类型等变量转换为String类变量。在图-14展示了Java API提供的valueOf重载的方法。

图- 14

10.3 步骤

步骤一：构建测试方法

首先，在TestString类中，添加testValueOf方法，然后，分别定义double类型，int类型，boolean类型以及char数组类型的变量，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 将其他类型转换为字符串类型
	 */
#cold_bold	@Test
#cold_bold	public void testValueOf() {
#cold_bold		double pi = 3.1415926;
#cold_bold		int value = 123;
#cold_bold		boolean flag = true;
#cold_bold		char[] charArr = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
#cold_bold	}
}

步骤二：使用valueOf方法

使用valueOf重载的方法，将double类型，int类型，boolean类型以及char数组类型等变量转换为String类变量，代码如下所示：

package day01;

import org.junit.Test;

public class TestString {
	/**
	 * 将其他类型转换为字符串类型
	 */
	@Test
	public void testValueOf() {
		double pi = 3.1415926;
		int value = 123;
		boolean flag = true;
		char[] charArr = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };

		String str = String.valueOf(pi);
#cold_bold		System.out.println(str);
#cold_bold
#cold_bold		str = String.valueOf(value);
#cold_bold		System.out.println(str);
#cold_bold
#cold_bold		str = String.valueOf(flag);
#cold_bold		System.out.println(str);
#cold_bold
#cold_bold		str = String.valueOf(charArr);
#cold_bold		System.out.println(str);
	}
}

步骤三：运行

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

3.1415926
123
true
abcdefg

从输出结果可以看出，已经将double类型数据、int类型数据、boolean类型数据以及字符数组类型数据转成类String类型数据。

10.4 完整代码

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

package day01;

import org.junit.Test;

public class TestString {
//...（之前案例的代码，略）

	/**
	 * 将其他类型转换为字符串类型
	 */
	@Test
	public void testValueOf() {
		double pi = 3.1415926;
		int value = 123;
		boolean flag = true;
		char[] charArr = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };

		String str = String.valueOf(pi);
		System.out.println(str);

		str = String.valueOf(value);
		System.out.println(str);

		str = String.valueOf(flag);
		System.out.println(str);

		str = String.valueOf(charArr);
		System.out.println(str);
	}
}

11 测试StringBuilder的append方法

11.1 问题

StringBuilder类提供将各种数据类型变量的字符串形式追加到当前序列中的append方法，在Java API中提供的append重载方法如图-15所示：

图- 15

本案例要求将字符串“java”、“cpp”、“php”、“c#”以及“objective-c”追加到字符序列"Programming Language:"的后面。

11.2 方案

首先，实例化StringBuilder类的对象，并且初始化该对象内容为"Programming Language:"字符串；然后调用append方法，再为该对象追加字符串“java”、“cpp”、“php”、“c#”以及“objective-c”；最后，调用StringBuilder类的toString方法，将该对象转换为String类型变量并输出。

另外，StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。可见，这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基于这样的设计的目的在于可以按照如下简洁的方式书写代码：

sb.append("java").append("cpp").append("php").append("c#")
				.append("objective-c");

11.3 步骤

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

步骤一：创建类TestStringBuilder，并在其中添加测试方法

在工程JavaSE的day01包下，新建名为TestStringBuilder类,并在该类中添加测试方法testAppend，工程结构如图-16所示，代码如下所示：

package day01;

import org.junit.Test;

public class TestStringBuilder {

	/**
	 * 测试StringBuilder的append方法
	 */
	@Test
	public void testAppend() {
		
	}
}

图- 16

步骤二：使用append方法

首先，实例化StringBuilder类的对象，并且初始化该对象内容为"Programming Language:"字符串；然后调用append方法，再为该对象追加字符串“java”、“cpp”、“php”、“c#”以及“objective-c”。代码如下所示：

package day01;

import org.junit.Test;

public class TestStringBuilder {

	/**
	 * 测试StringBuilder的append方法
	 */
	@Test
	public void testAppend() {
#cold_bold		StringBuilder sb = new StringBuilder("Programming Language:");
#cold_bold		sb.append("java").append("cpp").append("php").append("c#")
#cold_bold				.append("objective-c");
	}
}

步骤三：使用toString方法

调用StringBuilder类的toString方法，将该对象转换为String类型变量并输出,代码如下所示：

package day01;

import org.junit.Test;

public class TestStringBuilder {

	/**
	 * 测试StringBuilder的append方法
	 */
	@Test
	public void testAppend() {
		StringBuilder sb = new StringBuilder("Programming Language:");
		sb.append("java").append("cpp").append("php").append("c#")
				.append("objective-c");
#cold_bold		System.out.println(sb.toString());
	}
}

步骤四：运行

运行TestStringBuilder类中的testAppend方法，控制台输出结果如下所示：

Programming Language:javacppphpc#objective-c

从运行结果可以看出，将字符串“java”、“cpp”、“php”、“c#”以及“objective-c”追加在“Programming Language: ”的后边。

11.4 完整代码

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

package day01;

import org.junit.Test;

public class TestStringBuilder {

	/**
	 * 测试StringBuilder的append方法
	 */
	@Test
	public void testAppend() {
		StringBuilder sb = new StringBuilder("Programming Language:");
		sb.append("java").append("cpp").append("php").append("c#")
				.append("objective-c");
		System.out.println(sb.toString());
	}
}

12 测试StringBuilder的insert方法

12.1 问题

StringBuilder类提供将各种数据类型变量的字符串形式插入到当前序列中的insert方法，在Java API中提供的insert重载方法如图-17所示：

图- 17

本案例要求在字符序列"javacppc#objective-c"中的“#”后插入字符串“php”。

12.2 方案

使用StringBuilder类的insert方法将字符串“php”插入到字符序列"javacppc#objective-c"的#”后面，即，插入到索引位置为9的位置，原本该索引位置及其后面的字符向后顺延。

12.3 步骤

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

步骤一：添加测试方法

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

package day01;

import org.junit.Test;

public class TestStringBuilder {
#cold_bold	/**
#cold_bold	 * 测试StringBuilder的insert方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testInsert() {
#cold_bold		
#cold_bold	}
}

步骤二：使用insert方法

使用StringBuilder类的insert方法将字符串“php”插入到字符序列"javacppc#objective-c"的“#”后面，即，插入到索引位置为9的位置，原本该索引位置及其后面的字符向后顺延。代码如下所示：

package day01;

import org.junit.Test;

public class TestStringBuilder {
	/**
	 * 测试StringBuilder的insert方法
	 */
	@Test
	public void testInsert() {
#cold_bold		StringBuilder sb = new StringBuilder("javacppc#objective-c");
#cold_bold		sb.insert(9, "php");
#cold_bold		System.out.println(sb);
	}
}

以上代码输出字符序列信息时，没有调用toString方法，但输出sb和sb.toString效果是一样的。

步骤三：测试

运行testInsert方法，控制台输出结果如下：

javacppc#phpobjective-c

观察以上输出结果可以看到字符串“php”已经插入到“#”后面。

12.4 完整代码

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

package day01;

import org.junit.Test;

public class TestStringBuilder {
//...（之前案例的代码，略）

	/**
	 * 测试StringBuilder的insert方法
	 */
	@Test
	public void testInsert() {
		StringBuilder sb = new StringBuilder("javacppc#objective-c");
		sb.insert(9, "php");
		System.out.println(sb);
	}
}

13 测试StringBuilder的delete方法

13.1 问题

测试StringBuilder的delete方法，即，现有字符序列"javaoraclecppc#php",删除该字符序列中的“oracle”。

13.2 方案

使用StringBuilder的delete方法，可以实现将字符序列"javaoraclecppc#php"中的“oracle”删除，代码如下所示：

sb.delete(4, 4 + 6);

以上代码表示从索引4到索引10之间的字符，删除时，包含索引位置4的字符，但是不包含索引位置为10的字符，即，“前包括后不包括”。

13.3 步骤

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

步骤一：添加测试方法

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

package day01;

import org.junit.Test;

public class TestStringBuilder {
#cold_bold	/**
#cold_bold	 * 测试StringBuilder的delete方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testDelete() {
#cold_bold
#cold_bold	}
}

步骤二：使用delete方法

使用StringBuilder的delete方法，可以实现将字符序列"javaoraclecppc#php"中的“oracle”删除，代码如下所示：

package day01;

import org.junit.Test;

public class TestStringBuilder {
	/**
	 * 测试StringBuilder的delete方法
	 */
	@Test
	public void testDelete() {
#cold_bold		StringBuilder sb = new StringBuilder("javaoraclecppc#php");
#cold_bold		sb.delete(4, 4 + 6);
#cold_bold		System.out.println(sb);
	}
}

步骤三：测试

运行testDelete方法，控制台输出结果如下：

javacppc#php

观察以上输出结果可以看到字符串“oracle”被删除。

13.4 完整代码

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

package day01;

import org.junit.Test;

public class TestStringBuilder {
//...（之前案例的代码，略）

	/**
	 * 测试StringBuilder的delete方法
	 */
	@Test
	public void testDelete() {
		StringBuilder sb = new StringBuilder("javaoraclecppc#php");
		sb.delete(4, 4 + 6);
		System.out.println(sb);
	}
}