学习目标：掌握字符串数据类型String类的使用。

String类

字符串是有限个字符的有序集合，前面讲的char类型用于表示和存储单个字符，字符串相当于几个或多个char类型的有序集合，用于表示和存储多个有序的字符序列。字符串必须包含在一对“”（双引号）之内。例如：“I want to learn Java programming”、“我要学Java编程”、“3+5=8”、“abc”等等。

Java语言的字符串类型同前面介绍的Java基础类型不太一样，Java没有给字符串类型定义一个关键字，用于声明字符串类型，而是通过类的方式提供对字符串的操作和存储。在Java语言中，字符串类型被定义为类，类名为“String”,该类提供了多个构造方法和字符串操作方法，用于满足对字符串不同的处理要求。

String类的创建和初始化

String类可用字符串常量对其初始化。例如：

String   szWelcome = “欢迎加入Java编程小组”;

String   szExpression = “3+5-3”;

String   szTemp = “abc”;

也可以调用其构造方法来进行，String类提供了多个构造方法对其初始化，下面列举了几个主要的构造方法：

（1）   方法名称：String()

方法说明：构造一个空串（不包含任何字符）

方法示例：String   szWelcome = new String();

（2）   方法名称：String(String original)

方法说明：用original内容初始化新创建的字符串

方法示例：

String   szWelcome = new String(szTemp);

（3）   方法名称：String(byte[] bytes))

方法说明：用字符数组（后面会讲解数组结构）始化新创建的字符串

方法示例：

char   chTemp[] ={‘欢’,’迎’ ,’加’,’入’,’编’,’程’,’小’,’组’};

String  szWelcome = new String(chTemp);

案例1：用不同方式创建和初始化String类。

在Punit4项目unit包下创建Case1类。代码如下：

package unit;
 
/**
 * @date： 2021/6/5
 * @author：xinch
 */
 
public class Case1 {
    public static void main(String[] args) {
   // 声明字符串变量，并用字符常量初始化
    String szWelcome = "欢迎加入编程小组";
    System.out.println(szWelcome);
 
    // 声明字符串变量，并用已声明的字符串初始化
    String szTemp = new String(szWelcome);
    System.out.println(szTemp);
    // 声明字符类型数组
    char chTemp[] = { '欢', '迎', '加', '入', '编', '程', '小', '组' };
    // 声明字符串变量，并用字符数组始化
    String szTest = new String(chTemp);
    System.out.println(szTest);
 
  }
}

程序使用了String类提供的三种不同的初始化方法。第一种方法是通过字符常量赋值初始化；第二种方法是通过new运算符（后面会讲解）实例化String类，并以传入的已声明的字符串初始化；第三种方法是通过new运算符实例化String类，并以传入的字符型数组初始化。

创建和被初始化的String类称为String对象，也可以称为字符串对象，所有字符串操作都以String对象为基础。

在实际编程中，Java的String类是使用频率非常高的类，需要深入理解和掌握，弄清楚String提供的各种操作方法和技巧。

字符串的连接

可以把多个字符串连接成一个字符串，也可以把已创建的字符串与其它数据类型进行连接，不论用什么方式连接字符串，最后都会产生一个新的String对象。

使用“+”运算符连接

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

例如：

String szTempA = "小明" + "正在学习Java编程。";
String szTempB = "他对编程很感兴趣";
System.out.println( szTempA + szTempB );

在上面的例句中，String对象szTempA使用“+”运算符连接两个字符串常量进行初始化。println方法输出szTempA和szTempB连接后的String对象。

使用“+=”运算符连接

可以使用“+=”运算符对已声明的字符串对象，进行字符串的多次连接赋值操作。

例如：

String szTempA = "小明";
szTempA += "正在学习Java编程。";
System.out.println( szTempA );

在上面的例句中，创建了String对象szTempA，szTempA的值为“小明”，然后使用“+=”运算符连接字符串“正在学习Java编程。”，此时Java编译器会重新创建一个String对象，该对象的值为szTempA的值和字符串常量“正在学习Java编程。”连接后的内容。

连接其它数据类型

对已创建的字符串对象，使用“+”或“+=”运算符不仅可以连接字符串类型，也可以连接其它数据类型。

案例2：创建一个String对象，实现String对象连接int和double型变量，并输出连接后String对象。

在Punit4项目unit包下创建Case2类。代码如下：

package unit;
public class Case2 {
    public static void main(String[] args) {
            // 创建一个String对象
        String  szTemp = "小明身高";
        int height = 170;
        double weight = 71.5;
        // 连接整型变量
        szTemp += height;
        szTemp += "厘米；";
        szTemp += "小明体重";
        // 连接double型变量
        szTemp += weight;
        szTemp += "kg。";
        System.out.println(szTemp);
 
    }
}

代码通过“+=”运算符，对已创建的String对象szTemp分别连接int和double类型变量。

获取字符串的长度或字符信息

字符串作为一个String对象，可以通过String类提供的方法来获取字符串的长度、指定索引位置或范围的字符或子串信息。

在字符串中，字符串长度是字符串包含的字符个数，索引是字符串序列中每个字符的位置序号，字符的位置序号从0开始，依次是1、2、3、……。

例如：

String  szTemp = “Hello World”

szTemp的字符串长度为11，空格也算一个字符。字符‘H’的索引是0，字符‘e’的索引是1、字符‘l’的索引是2、……、字符‘d’的索引是10。因为字符串的索引是从0开始，因此szTemp的最大索引值是字符串的长度减1。

获取字符串的长度

使用String类的length()方法可以获取字符串的长度，语法如下：

str.length();

其中str是已创建的String对象。

获取指定索引位置的单个字符

String类提供了charAt()方法用于获取字符串内的单个字符。语法如下：

str.charAt(int index);

其中，str是已创建的String对象。index是待获取字符在字符串的位置索引。该方法返回单个字符，返回类型是char。

案例3：创建字符串对象，输出字符串对象索引为0、2和字符串最后位置的字符。

在Punit4项目unit包下创建Case3类。代码如下：

package unit;
public class Case3 {
    public static void main(String[] args) {
        // 创建String对象
        String szWelcome = "欢迎加入编程小组";
        // 获取索引为0的字符
        char chTemp1 = szWelcome.charAt(0);
        // 获取索引为2的字符
        char chTemp2 = szWelcome.charAt(2);
        // 获取字符串的最后一个字符
        char chTemp3 = szWelcome.charAt(szWelcome.length()-1);
        System.out.println("szWelcome的第1个字符为：" + chTemp1);
        System.out.println("szWelcome的第2个字符为：" + chTemp2);
        System.out.println("szWelcome的最后一个字符为：" + chTemp3);
 
    }
}

获取字符串的子串

串中任意个连续的字符组成的子序列称为该串的子串。

对于一个字符串对象“abcdefg”，它的子串就是像“bcd”这样可以找到的连续的字符串。字符串对象“abcdefg”最长的子串就是它本身。

String类提供了substring()方法来截取子串信息，substring()有两种类的重载方法（关于类方法的重载，后面课程会详细讲述）。

第1种方法语法如下：

str.substring(int beginIndex)

其中，str是已创建的String对象，beginIndex是要截取子串开始的索引位置。该方法从指定的索引位置开始截取直到该字符串结尾的子串。

第2种方法语法如下：

str.substring(int beginIndex, int endIndex)

其中，str是已创建的String对象，beginIndex是要截取子串开始的索引位置，endIndex是要截取子串结束位置的索引。该方法从指定的索引位置beginIndex开始截取至endIndex索引位置结束的子串。

案例4：创建字符串对象，分别使用substring()两种方法截取子串。

在Punit4项目unit包下创建Case4类。代码如下：

package unit;
public class Case4 {
    public static void main(String[] args) {
        // 创建String对象
        String szWelcome = "欢迎加入编程小组";
        // 从索引位置2开始截取至字符串末尾
        String szSubStr1 = szWelcome.substring(2);
        // 从索引位置2开始截取至索引位置6
        String szSubStr2 = szWelcome.substring(2,6);
        System.out.println("szSubStr1为：" + szSubStr1);
        System.out.println("szSubStr2为：" + szSubStr2);
    }
 
}

字符串查找

在一个字符串中查找字符或子串是经常使用的操作。String类提供了两种查找字符串的方法，分别是indexOf()和lastIndexOf()，这两种方法都返回待查找字符或子串在字符串的起始索引位置。

int  indexOf(String s)

该方法用于在字符串中查找与s字符串匹配的子串，若发现匹配的子串，则返回子串的起始位置索引，如果没有找到与s匹配的子串，返回-1。

调用语法如下：

str.indexOf(s)

其中，str是已创建的字符串对象，s待查找的字符串。

案例5：创建一个字符串对象，使用indexOf()方法查找子串，如查找到子串输出子串内容，否则输出查找子串失败信息。

在Punit4项目unit包下创建Case5类。代码如下：

package unit;
 
public class Case5 {
    public static void main(String[] args) {
        // 创建String对象
        String szTemp = "小明正在学习Java编程";
        String szSearch = "编程";
        // 使用indexOf查找子串"编程"
        int nIndex = szTemp.indexOf(szSearch);
        // 若nIndex不等于-1,说明已查找到子串
        if( nIndex != -1 )
        {
            // 从szTemp截取已查找到的子串
            String szSub = szTemp.substring(nIndex,nIndex+szSearch.length());
            // 输出子串
            System.out.println(szSub);
        }
        else
        {
            System.out.printf("没有查找到子串：%s",szSearch);
        }
    }
}

代码创建了两个String对象，一个String对象是szTemp，字符串查找操作在该字符串对象进行，一个String对象是szSearch，该字符串是待查找字符串。

使用String类的indexOf()方法在szTemp中查找szSearch，若szTemp内容包含szSearch，则查找成功。indexOf()方法返回szSearch在szTemp中的起始索引，然后使用String类的substring方法截取子串。

int  lastIndexOf(String s)

该方法在当前字符串中查找子串s，若s多次出现在当前字符串中，该方法会返回s在当前字符串最后一次出现的索引位置。如果没有找到s，则返回-1。

例如：

在字符串“小明正在学习Java编程，Java编程是他很喜欢的课程”中，查找子串“Java”，lastIndexOf()方法会返回最后出现“Java”的索引位置，即返回索引13。

判断字符串是否相等

判断字符串相等有两种方式：一种方式是用“==”运算符来判断，主要是判断两个字符串的内存地址是否相等；一种方式是用String类的equals()方法来判断，主要是判断两个字符串的内容是否相等。

使用运算符“==”判断两个字符串是否相等时，它会判断两个字符串的内存地址是否相同，如果相同返回true，否则返回false。

使用equals()方法判断字符串相等时，它会判断两个字符串的内容是否相等，因此要判断两个字符串对象的内容是否相等，不应该使用“==”运算符，而要使用String类的equals()方法。equals()方法声明如下：

str.equals(String s);

其中str和s是要判断的两个字符串对象。

String类的equals()方法判断两个字符串对象的内容是否相同时，是区分大小写的。如要忽略字符串内字符的大小写，可以使用String类的equalsIgoreCase()方法来判断，使用方法和equals()方法相同。

案例6：使用equals()方法和equalsIgoreCase()方法来判断字符串是否相等。

在Punit4项目unit包下创建Case6类。代码如下：

package unit;
public class Case6 {
    public static void main(String[] args) {
        // 创建字符串对象
        String szTempA = "hello World";
        String szTempB = "Hello World";
        String szTempC = new String("Hello World");
        String szTempD = new String("Hello World");
        // szTempA和szTempB区分大小写判断
        if( szTempA.equals(szTempB) )
        {
            System.out.println("szTempA等于szTempB（区分大小写）");
        }
        // szTempA和szTempB不区分大小写判断
        if( szTempA.equalsIgnoreCase(szTempB) )
        {
            System.out.println("szTempA等于szTempB（不区分大小写）");
        }
        // szTempC和szTempD判断
        if( szTempC.equals(szTempD) )
        {
            System.out.println("szTempC等于szTempD（区分大小写）");
        }
 
    }
}
程序

创建了四个字符串对象，szTempA和szTempB用字符串常量赋值，szTempA和szTempB的内容有字符大小写的区别，用于实验eauals()方法和equalsIgnoreCase()方法。szTempC和szTempD使用new运算符创建，这两个字符串的内容相同，但内存地址不同，用于验证eauals()方法。

字符串比较和大小写转换

字符串比较

两个字符串对象除了判断相等外，还可以比较字符串。String类提供了compareTo()方法比较字符串的大小，compareTo()方法按照字典顺序比较两个字符串。

比较大小有三种结果：如果两个字符串相等，返回0；如果当前字符串按照字典顺序位于待比较的字符串之前返回一个负整数；如果当前字符串按照字典顺序位于待比较的字符串之前返回一个正整数。

调用compareTo()方法的语法如下：

str. compareTo(Sring s);

其中，str是当前字符串，s是待比较的字符串。

大小写转换

String类提供了toLowerCase()方法和toUpperCase()方法，toLowerCase()方法将字符串的大写字母转换为小写字母，toUpperCase()方法将字符串的小写字母转换为大写字母。

7、空格处理与内容替换

字符串的空格处理

在编写程序时，有时需要去除字符串前置和尾部的空格。String类提供了trim()方法可以去除字符串前置和尾部的空格。

调用trim()方法的语法如下：

str.trim();

其中，str是已创建的字符串。该方法将去除str前置和尾部的所有空格。

字符串的内容替换

在编写程序时，有时需要替换字符串的内容。String类提供了replace()方法用于替换字符串内的字符或子串内容。String类的replace()方法也是重载方法，可以替换字符串中的字符和子串。

replace()方法的调用语法如下：

str.replace(char oldChar,char newChar);
str.replace(
CharSequence target, 
CharSequence replacement);

其中，str是已创建的字符串对象，该字符串对象的内容将被替换。oldChar是srt原来包含的字符，newChar是要替换的字符，方法执行后srt原来包含的oldChar字符将被替换为newChar。target是CharSequence类型的接口（关于接口，后面课程内容会详细介绍），String类实现了该接口，因此可以传入String对象，target是要被替换的字符串，replacement是要替换的字符串。

案例7：创建两个String对象，分别调用replace的两个重载方法进行内容替换。

在Punit4项目unit包下创建Case7类。代码如下：

package unit;
public class Case7 {
    public static void main(String[] args) {
        // 创建字符串对象
        String  szTempA = "Sometimes things";
        String  szTempB = "小明正在学习Java编程";
        // 将szTempA的大写S替换为小写s
        System.out.println("替换前：" + szTempA);
        System.out.println("替换后：" + szTempA.replace('S','s'));
        // 将szTempB的Java替换为Python
        System.out.println("替换前：" +  szTempB);
        System.out.println("替换后：" + szTempB.replace("Java","Python"));
    }
}