Java String类的用法详解（附带实例）

字符串是 Java 程序中经常处理的对象，如果字符串运用得不好，将影响到程序运行的效率。

在 Java 中，字符串作为 String 类的实例来处理。以对象的方式处理字符串，将使字符串更加灵活、方便。了解字符串上可用的操作，可以节省程序编写与维护的时间。

Java 程序种，单个字符可以用 char 类型进行保存，多个字符组成的文本就需要保存在 String 对象中。String 通常被称为字符串，一个 String 对象最多可以保存（2^32-1）个字节（占用 4GB 空间大小）的文本内容。

Java String类的基本用法

1) 声明字符串

在 Java 语言中，字符串必须被包含在一对双引号（" "）之内。例如：

"23.23"、"ABCDE"、"你好"

以上这些都是字符串常量，字符串常量可以是系统能够显示的任何文字信息，甚至可以是单个字符。

注意，在 Java 中由双引号""包围的都是字符串，字符串不能作为其他数据类型来使用，如"1+2"的输出结果不可能是 3。

可以通过以下语法格式来声明字符串变量：

String str;

• String：指定该变量为字符串类型；
• str：任意有效的标识符，表示字符串变量的名称。

声明字符串变量 s，代码如下：

String s;

说明，声明的字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”。

2) 创建字符串

在 Java 语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法。

String 类的常用构造方法如下：
① String(char a[]) 方法用一个字符数组 a 创建 String 对象，代码如下：

char a[] = {'g', 'o', 'o', 'd'};
String s = new String(a);
// 等价于
String s = new String("good");

② String(char a[], int offset, int length) 方法提取字符数组 a 中的一部分创建一个字符串对象。参数 offset 表示开始截取字符串的位置，length 表示截取字符串的长度。代码如下：

char a[] = {'s', 't', 'u', 'd', 'e', 'n', 't'};
String s = new String(a, 2, 4); // 从索引2开始，长度为4的子数组
// 等价于
String s = new String("uden");

③ String(char[] value) 构造方法可分配一个新的 String 对象，使其表示字符数组参数中所有元素连接的结果。代码如下：

char a[] = {'s', 't', 'u', 'd', 'e', 'n', 't'};
String s = new String(a); // 创建字符串对象
// 等价于
String s = new String("student");

除通过以上几种使用 String 类的构造方法来创建字符串变量外，还可通过将字符串常量的引用赋值给一个字符串变量来创建字符串。代码如下：

String str1,str2;
str1 = "We are students"
srt2 = "We are students"

此时，str1 与 str2 引用相同的字符串常量，因此具有相同的实体，内存示意图如下图所示。

Java String类的常见操作

1、连接字符串

对于已声明的字符串，可以对其进行相应的操作，连接字符串就是字符操作中较简单的一种。可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接。

1) 连接多个字符串

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个 String 对象并产生一个新的 String 对象。

【实例】在项目中创建 Join 类，在主方法中创建两个 String 型变量，它们的值分别是“春色绿千里”和“马蹄香万家”，使用“+”运算符连接这两个 String 型变量和“\n”，在控制台上输出连接后的字符串。实例代码如下：

public class Join { // 创建类
    public static void main(String args[]) { // 主方法
        String s1 = new String("春色绿千里"); // 声明 String 对象 s1
        String s2 = new String("马蹄香万家"); // 声明 String 对象 s2
        String s = s1 + "\n" + s2; // 将对象 s1、"\n"和对象 s2 进行连接并将结果赋值给 s
        System.out.println(s); // 将 s 进行输出
    }
}

运行结果为：

春色绿千里
马蹄香万家

2) 连接其他数据类型

字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型数据进行连接，则会将其他数据类型的数据直接转换成字符串。

【实例】在项目中创建 Link 类，在主方法中创建数值型变量，实现将字符串与整型、浮点型变量相连的结果进行输出。实例代码如下：

public class Link { // 创建类
    public static void main(String args[]) { // 主方法
        int booktime = 4; // 声明的 int 型变量 booktime
        float practice = 2.5f; // 声明的 float 型变量 practice
        // 将字符串与整型、浮点型变量进行相连，并输出结果
        System.out.println("我每天花费" + booktime + "小时看书； " + practice + "小时上机练习");
    }
}

运行结果为：

我每天花费4小时看书；2.5小时上机练习

本实例实现的是将字符串常量与整型变量 booktime 和浮点型变量 practice 相连后的结果进行输出。在这里 booktime 和 practice 都不是字符串，当它们与字符串相连时会自动调用 toString() 方法并被转换成字符串形式，然后参与字符串的连接。

注意，只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应谨慎地将其他数据类型的数据与字符串相连，以免出现意想不到的结果。

如果将上面实例中的输出语句修改为：

System.out.println("我每天花费" + booktime + "小时看书；" + (practice + booktime) + "小时上机练习");

修改后的运行结果为：

我每天花费4小时看书；6.5小时上机练习

为什么会这样呢？这是由于运算符是有优先级的，圆括号的优先级最高，因此先被执行，然后将结果与字符串进行相连。

2、获取字符串长度

使用 String 类的 length() 方法来获取声明的字符串对象的长度。语法如下：

str.length();

其中，str 为字符串对象。

获取字符串长度，代码如下：

String str = "We are students";
int size = str.length();

上段代码是将字符串 str 的长度赋值给 int 型变量 size，此时变量 size 的值为 15，这表示 length() 方法返回的是字符串的长度（包括字符串中的空格）。

3、查找字符串

String 类提供了两种查找字符串的方法，即 indexOf() 与 lastIndexOf() 方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串：

• indexOf() 方法返回的是搜索的字符或字符串首次出现的位置；
• lastIndexOf() 方法返回的是搜索的字符或字符串最后一次出现的位置。

indexOf(String s) 方法用于返回参数字符串 s 在指定字符串中首次出现的索引位置。当调用 String 类的 indexOf() 方法时，会从当前字符串的开始位置处搜索 s 的位置。indexOf() 方法如果没有检索到字符串 s，则返回 -1。

indexOf() 方法的语法如下：

str.indexOf(substr)

• str：任意字符串对象；
• substr：要搜索的字符串。

查找字符 a 在字符串 str 中的索引位置，代码如下：

String str = "We are students";
int size = str.indexOf("a"); // 变量 size 的值是 3

要理解字符串的索引位置，则需要对字符串的下标有所了解。在 Java 语言中，String 对象是用数组表示的。字符串的下标是 0~length()-1。因此，字符串“We are students”的下标如图所示。


lastIndexOf(String str) 方法用于返回指定字符串最后一次出现的索引位置。当调用 String类的 lastIndexOf() 方法时，会从当前字符串的开始位置处检索参数字符串 str，并将最后一次出现 str 的索引位置进行返回。lastIndexOf( )方法如果没有检索到字符串 str，则返回 -1。

lastIndexOf() 方法的语法如下：

str.lastIndexOf(substr)

• str：任意字符串对象。
• substr：要搜索的字符串。

如果 lastIndexOf() 方法中的参数是空字符串 ""（注意没有空格），则该方法返回的结果与调用 length() 方法的返回结果相同。

【实例】用两种方式判断字符串的长度。在项目中创建 Text 类，在主方法中创建 String 对象，先使用 lastIndexOf() 方法查看字符串 str 中空字符串的位置，再输出这个字符串的长度，然后查看这两个结果是否相同。

public class Text { // 创建类
    public static void main(String args[]) { // 主方法
        String str = "We are students"; // 定义字符串 str
        // 将空字符串在 str 中的索引位置赋值给变量 size
        int size = str.lastIndexOf("");
        System.out.println("空字符串在字符串 str 中的索引位置是：" + size); // 输出变量 size
        System.out.println("字符串 str 的长度是：" + str.length()); // 输出字符串 str 的长度
    }
}

运行结果为：

空字符串在字符串 str 中的索引位置是：15
字符串 str 的长度是：15

4、获取指定索引位置的字符

使用 charAt() 方法可将指定索引处的字符进行返回。语法如下：

str.charAt(int index)

• str：任意字符串；
• index：整型值，用于指定要返回字符的下标。

【实例】查看指定索引位置上的字符。在项目中创建 Ref 类，在主方法中创建 String 对象，使用 charAt() 方法查看字符串 str 中索引位置是 6 的字符。

public class Ref { // 创建类
    public static void main(String args[]) { // 主方法
        String str = "hello world"; // 定义字符串 str
        char mychar = str.charAt(6); // 将字符串 str 中索引位置是 6 的字符进行返回
        System.out.println("字符串 str 中索引位置是 6 的字符为：" + mychar); // 输出信息
    }
}

运行结果为：

字符串 str 中索引位置是 6 的字符为：w

5、获取子字符串

通过 String 类的 substring() 方法可对字符串进行截取。substring() 方法被两种不同的形式重载，以满足不同的需要。这些形式的共同点是，它们都利用字符串的下标进行截取，并且字符串下标是从 0 开始的。

substring(int beginIndex) 方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下：

str.substring(int beginIndex)

其中，beginIndex 指定从某一索引处开始截取字符串。

截取字符串，代码如下：

String str = "Hello World";  //定义字符串str
String substr = str.substring(3);  //获取字符串，此时substr值为lo World

使用 substring(beginIndex) 截取字符串的过程如下图所示：

注意，在字符串中空格占用一个索引位置。

substring(int beginIndex, int endIndex) 方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下：

str.substring(int beginIndex, int endIndex)

• beginIndex：开始截取子字符串的索引位置；
• endIndex：子字符串在整个字符串中的结束位置。

【实例】《将进酒》的作者是哪位诗人？在项目中创建 Subs 类，在主方法中创建 String 对象，实现使用 substring() 方法对字符串进行截取，并将截取后形成的新字符串进行输出。

public class Subs { // 创建类
    public static void main(String args[]) { // 主方法
        String str = "《将进酒》：李白（唐）"; // 定义的字符串
        String substr = str.substring(6, 8); // 对字符串进行截取
        System.out.println("《将进酒》的作者是" + substr); // 输出截取后的字符串
    }
}

运行结果为：

《将进酒》的作者是李白

6、去除空格

trim() 方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：

str.trim()

其中，str 为任意字符串对象。

【实例】去掉字符串首、尾的空格。在项目中创建 Blak 类，在主方法中创建 String 对象，在控制台上输出字符串原来的长度和去掉首、尾空格后的长度。

public class Blak { // 创建类
    public static void main(String args[]) { // 主方法
        String str = "   Java  class  "; // 定义字符串 str
        System.out.println("字符串原来的长度：" + str.length()); // 将 str 原来的长度进行输出
        // 将 str 去掉前导和尾部的空格后的长度进行输出
        System.out.println("去掉空格后的长度：" + str.trim().length());
    }
}

运行结果为：

字符串原来的长度：16
去掉空格后的长度：11

7、替换字符串

replace() 方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：

str.replace(CharSequence target, CharSequence replacement)

• target：要替换的字符或字符串；
• replacement：用于替换原来字符串的内容。

replace() 方法返回的结果是一个新的字符串。如果字符或字符串 oldChar 没有出现在该对象表达式的字符串序列中，则将原字符串进行返回。

【实例】将单词中的字母 a 替换为字母 A。在项目中创建 NewStr 类，在主方法中创建 String 型变量，将该变量中的字母 a 替换成 A，并将替换后的字符串进行输出。

public class NewStr { // 创建类
    public static void main(String args[]) { // 主方法
        String str = "address"; // 定义字符串 str
        // 将 str 中 “a” 替换成 “A” 并返回新字符串 newstr
        String newstr = str.replace("a", "A");
        System.out.println(newstr); // 将字符串 newstr 进行输出
    }
}

运行结果为：

Address

如果要替换的字符 oldChar 在字符串中重复出现多次，那么 replace() 方法会将所有 oldChar 字符全部替换成 newChar。例如：

String str = "java project";
String newstr = str.replace("j","J");

此时，newstr 的值为 Java proJect。

需要注意的是，要替换的字符 oldChar 的大小写要与原字符串中字符的大小写保持一致，否则它不能被成功地替换。例如，如果将上面的实例写成如下语句，则 oldChar 字符不能被成功地替换：

String str = "java project";
String newstr = str.replace("P","t");

8、判断字符串的开始与结尾

startsWith() 方法与 endsWith() 方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为 boolean 类型。

startsWith()方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：

str.startsWith(String prefix)

其中，prefix 是指作为前缀的字符串。

endsWith() 方法用于判断当前字符串是否为以给定的子字符串结束。语法如下：

str.endsWith(String suffix)

其中，suffix 是指作为后缀的字符串。

【实例】判断字符串是否以指定的内容开始或结束。在项目中创建 StartOrEnd 类，在主方法中创建两个 String 型变量，它们的值分别为“22045612”和“21304578”，先判断“22045612”是否是以“22”开始的，再判断“21304578”是否是以“78”结束的。

public class StartOrEnd { // 创建类
    public static void main(String args[]) { // 主方法
        String num1 = "22045612"; // 定义字符串 num1
        String num2 = "21304578"; // 定义字符串 num2
        boolean b = num1.startsWith("222"); // 判断字符串 num1 是否以'22'开头
        boolean b2 = num2.endsWith("78"); // 判断字符串 num2 是否以'78'结束
        System.out.println("字符串 num1 是以'22'开始的吗？ " + b); // 输出信息
        System.out.println("字符串 num2 是以'78'结束的吗？ " + b2); // 输出信息
    }
}

运行结果为：

字符串 num1 是以'22'开始的吗？true
字符串 num2 是以'78'结束的吗？true

9、判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回 false。

使用比较运算符比较两个字符串，代码如下：

String tom = new String("I am a student");
String jerry = new String("I am a student");
boolean b = (tom == jerry);

此时，布尔型变量 b 的值为 false，因为字符串是对象，tom、jerry 是引用，内存示意图如下图所示。


因此，要比较两个字符串内容是否相等，应使用 equals() 方法和 equalsIgnoreCase() 方法。

如果两个字符串具有相同的字符和长度，则使用 equals() 方法进行比较时，返回 true；否则，返回 false。语法如下：

str.equals(String otherstr)

其中，str、otherstr 是要比较的两个字符串对象。

使用 equals() 方法对字符串进行比较时是区分大小写的，而使用 equalsIgnoreCase() 方法是在忽略了大小写的情况下比较两个字符串是否相等的，返回结果仍为 boolean 类型。语法如下：

str.equalsIgnoreCase(String otherstr)

其中，str、otherstr 是要比较的两个字符串对象。

【实例】判断“abc”与“ABC”是否相等。在项目中创建 Opinion 类，在主方法中创建两个 String 型变量，它们的值分别为“abc”和“ABC”，判断这两个字符串是否相等。实例代码如下：

public class Opinion { // 创建类
    public static void main(String args[]) { // 主方法
        String s1 = new String("abc"); // 创建字符串对象 s1
        String s2 = new String("ABC"); // 创建字符串对象 s2
        boolean b = s1.equals(s2); // 使用 equals()方法比较 s1 与 s2
        boolean b2 = s1.equalsIgnoreCase(s2); // 使用 equalsIgnoreCase()方法比较 s1 与 s2
        System.out.println(s1 + " equals " + s2 + " :" + b); // 输出信息
        System.out.println(s1 + " equalsIgnoreCase " + s2 + " :" + b2);
    }
}

运行结果为：

abc equals ABC :false
abc equalsIgnoreCase ABC :true

10、按字典顺序比较两个字符串

compareTo() 方法是按字典顺序比较两个字符串的，该比较基于字符串中各个字符的 Unicode 值，按字典顺序将 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较：

• 如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数；
• 如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数；
• 如果这两个字符串相等，则结果为 0。

compareTo() 的语法如下：

str.compareTo(String otherstr)

其中，str、otherstr 是要比较的两个字符串对象。

compareTo() 方法只有在 equals(Object) 方法返回 true 时才返回 0。

【实例】判断字母 b 的位置。在项目中创建 Wordbook 类，在主方法中创建 3 个 String 变量，它们的值分别为 a、b 和 c，使用 compareTo() 方法判断字母 b 的位置，即在字母 a 的后面，在字母 c 的前面。实例代码如下：

public class Wordbook { // 创建类
    public static void main(String args[]) { // 主方法
        String str = new String("b"); // 用于比较的 3 个字符串
        String str2 = new String("a");
        String str3 = new String("c");
        System.out.println(str + " compareTo " + str2 + ":" + str.compareTo(str2)); // 输出 str 与 str2 比较的结果
        System.out.println(str + " compareTo " + str3 + ":" + str.compareTo(str3)); // 输出 str 与 str3 比较的结果
    }
}

运行结果为：

b compareTo a:1
b compareTo c:-1

11、字母大小写的转换

String 类的 toLowerCase() 方法可将字符串中的所有大写字母改写为小写字母，而 toUpperCase() 方法可将字符串中的所有小写字母改写为大写字母。

toLowerCase() 方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：

str.toLowerCase()

其中，str 是要进行转换的字符串。

toUpperCase() 方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变。语法如下：

str.toUpperCase()

其中，str 是要进行转换的字符串。

使用 toLowerCase() 方法和 toUpperCase() 方法进行大小写转换时，数字或其他非英文字母类字符不受影响。

【实例】字母大小写的转换。在项目中创建 UpAndLower 类，在主方法中创建一个值为“Oh My God”的String型变量，对这个字符串进行字母大小写转换，然后将转换后的结果输出在控制台上。实例代码如下：

public class UpAndLower { // 创建类
    public static void main(String args[]) { // 主方法
        String str = new String("Oh My God"); // 创建字符串 str
        String newstr = str.toLowerCase(); // 使用 toLowerCase()方法实行小写转换
        String newstr2 = str.toUpperCase(); // 使用 toUpperCase()方法实行大写转换
        System.out.println(newstr); // 输出转换后的结果
        System.out.println(newstr2);
    }
}

运行结果为：

oh my god
OH MY GOD

12、分割字符串

使用 split() 方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存储在字符串数组中。split() 方法提供了以下两种字符串分割形式。

split(String sign) 方法可根据给定的分割符对字符串进行拆分。语法如下：

str.split(String sign)

其中，sign 为分割字符串的分割符，也可以使用正则表达式。

没有统一的对字符进行分割的符号。如果想定义多个分割符，可使用符号“|”。例如，“,|=”表示分割符分别为“,”和“=”。

split(String sign,int limit) 方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。语法如下：

str.split(String sign,int limit)

• sign：分割字符串的分割符，也可以使用正则表达式；
• limit：限制的分割次数。

【实例】按要求分割“192.168.0.1”。在项目中创建 Division 类，在主方法中创建一个值为“192.168.0.1”的 String 型变量，先按照“.”分割字符串，再按照“.”对这个字符串进行两次分割。实例代码如下：

public class Division {
    public static void main(String[] args) {
        String str = "192.168.0.1"; // 创建字符串
        String[] firstArray = str.split("\\."); // 按照 “.” 进行分割，使用转义字符 “\\.”
        String[] secondArray = str.split("\\.", 2); // 按照 “.” 进行两次分割，使用转义字符 “\\.”
        System.out.println("str 的原值为：[" + str + "]");
        System.out.print("全部分割的结果：");
        for (String a : firstArray) {
            System.out.print("[" + a + "]");
        }
        System.out.println(); // 换行
        System.out.print("分割两次的结果：");
        for (String a : secondArray) {
            System.out.print("[" + a + "]");
        }
        System.out.println();
    }
}

运行结果为：

str 的原值为：[192.168.0.1]
全部分割的结果：[192][168][0][1]
分割两次的结果：[192][168.0.1]