java[7]String 处理方法

字符串----不可变字符串

Java 中的字符串

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

"HelloWorld" ①

"\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 8 在线 API 文档，网址是 http://docs.oracle.com/javase/8/docs/api/，

Java6中文离线文档：http://download.oracle.com/technetwork/java/javase/6/docs/zh/api.zip，

 

 

不可变字符串

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

    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 参数指定子数组的长度。

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

//创建字符串对象

Strings1 = new String();

Strings2 = new String("Hello World");

Strings3 = newString("\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064");

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

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

charchars[] = { 'a', 'b', 'c', 'd', 'e' };

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

Strings4 = new String(chars);

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

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

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

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

bytebytes[] = { 97, 98, 99 };

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

Strings6 = 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 都是表示 HelloWorld 字符串， 获得字符串长度方法是 length()，

其他代码比较简单，这里不再赘述。    

 

 

字符串池

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

Strings9 = "Hello"; //字符串常量

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

使用 new 关键字与字符串常量都能获得字符串对象，但它们之间有一些区别。先看

下面代码运行结果：

Strings7 = new String("Hello"); ①

Strings8 = new String("Hello"); ②

Strings9 = "Hello"; ③

Strings10 = "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 是不同的引用，指向不同的对象。

字符串的拼接

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

字符串拼接示例如下：

输出结果：

Strings1 = "Hello";

//使用+运算符连接

Strings2 = s1 + " "; ①

Strings3 = s2 + "World"; ②

System.out.println(s3);

Strings4 = "Hello";

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

s4+= " "; ③

s4+= "World"; ④

System.out.println(s4);

Strings5 = "Hello";

//使用concat方法连接

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

System.out.println(s5);

intage = 18;

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

System.out.println(s6);

charscore = 'A';

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

System.out.println(s7);

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

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

Strings8= "今天是： " + now; ⑨

System.out.println(s8);

HelloWorld

HelloWorld

HelloWorld

她的年龄是18岁。

她的英语成绩是A

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

上述代码第①~②行使用+运算符进行字符串的拼接，其中产生了三个对象。代码第③~④行业是使用+=赋值运算符，本质上也是+运算符进行拼接。代码第⑤行采用 concat 方法进行拼接，该方法的完整定义如下：

publicString 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, intfromIndex)：从指定的索引开始从前往后搜字符串 str，返回第一次找到字符串所在处的索引。

 int lastIndexOf(int ch)：从后往前搜索字符 ch，返回第一次找到字符 ch 所在处的索引。

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

 int lastIndexOf(String str)：从后往前搜索字符串 str，返回第一次找到字符串所在处的索引。

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

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

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

String sourceStr = "There is astring 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字符串，第一次找到它所在索引:14112 / 237从索引为5位置开始，从后往前搜索ing字符串，第一次找到它所在索引:-1sourceStr 字符串索引如图 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。

 

字符串比较

字符串比较是常见的操作，包括比较相等、比较大小、 比较前缀和后缀串等。
1. 比较相等
String 提供的比较字符串相等的方法：
boolean equals(Object anObject)：比较两个字符串中内容是否相等。
boolean equalsIgnoreCase(String anotherString)：类似 equals方法，只是忽略大小写。
2. 比较大小
有时不仅需要知道是否相等，还要知道大小， String 提供的比较大小的方法：
int compareTo(String anotherString)：按字典顺序比较两个字符串。 如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于0 的值；如果此字符串大于字符串参数，则返回一个大于0 的值。
int compareToIgnoreCase(String str)：类似 compareTo，只是忽略大小写。
3. 比较前缀和后缀
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)));

//比较大小

Strings4 = "java";

Strings5 = "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);

intjavaDocCount = 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, intendIndex)：从指定索引 beginIndex 开始截取直到索引 endIndex - 1 处的字符，注意包括索引为 beginIndex 处的字符，但不包括索引为 endIndex 处的字符。

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

String sourceStr = "There is a stringaccessing 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[]。