大数据开发基础入门与项目实战（一）Java SE之6.String类的概述和使用

╰+攻爆jí腚メ 2022-09-08 11:31 17阅读 0赞

### 文章目录 ###

*  前言
 *  1.String类的概念和构造方法
 *   *  （1）String类和常量池的概念
     *  （2）String类常用构造方法的使用
     *  （3）String类的笔试考点
 *  2.String常用的成员方法及使用
 *   *  （1）String类型和数组之间的转换
     *  （2）String类中字符的获取和使用
     *  （3）String类对象实现回文的判断
     *  （4）String类实现字符串之间大小的比较
     *  （5）String类中使用方法操作字符串
     *  （6）String类实现登录功能的模拟
     *  （7）String类实现字符和字符串的正向查找
     *  （8）String类实现字符和字符串的反向查找
     *  （9）String类中子字符串的获取
 *  3.正则表达式的概念和使用
 *   *  （1）正则表达式的概念和规则
     *  （2）正则表达式的编程使用
     *  （3）正则表达式相关方法的使用
 *  总结

# 前言 #

本文主要介绍了字符串类String的概述和使用，包括String类的概念和构造方法、String常用的成员方法及使用和正则表达式的概念和使用等部分。

# 1.String类的概念和构造方法 #

## （1）String类和常量池的概念 ##

`java.lang.String`类用于描述字符串，Java程序中所有的**字符串字面值** （直接量）都可以使用该类的对象加以描述，如`"abc"`。

该类由final关键字修饰，表示该类**不能被继承** ；

继承自Object类，重写了Object类中的方法，同时实现了`Serializable`、`Comparable<String>`和`CharSequence`接口；

从jdk1.9开始该类的底层不使用`char[]`来存储数据，而是改成 `byte[]`加上编码标记，从而节约了一些空间。

从源码中可以看到，定义字符数组的格式为`private final byte[] value;`，被final关键字修饰，说明数组引用不能改变指向，指向的一维数组的长度不能改变，所以String类描述的字符串内容是**常量** 、不可更改，因此**可以被共享使用** 。

举例如下：

String str1 = "abc";    // 其中"abc"这个字符串是个常量不可改变
    str1 = "123";           // 将"123"字符串的地址赋值给变量str1

其中，`"abc"`是常量、不可改变，保存在方法区；

上面的操作改变了str1的指向到字符串对象`"123"`，但是并没有改变原来指向的内容`"abc"`；

此时没有引用指向`"abc"`，此时会自动触发JVM中的垃圾回收机制、回收释放对应的内存空间。

由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入**常量池** 中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需重复申请内存及创建对象，从而提高了性能。

现在验证常量池如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 10:24 * @description javase-com.stage1.module3 */
    public class StringPoolTest { 
    
        public static void main(String[] args) { 
    
            // 验证String常量池
            String s1 = "abc";
            String s2 = "abc";
            System.out.println(s1 == s2);
        }
    }

输出：

true

可以看到，`s1 == s2`的值为true，说明s1和s2的地址相同，也就说明了它们属于同一个对象，都存在于常量池中。

到目前为止，只有String这个特殊类除了new的方式还可以直接通过字符串赋值来创建对象（包装类除外）。

## （2）String类常用构造方法的使用 ##

String类常用的构造方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String()</td> 
   <td>使用无参方式构造对象得到空字符序列</td> 
  </tr> 
  <tr> 
   <td>String(byte[] bytes, int offset, int length)</td> 
   <td>使用bytes数组中下标从offset位置开始的length个字节来构造对象</td> 
  </tr> 
  <tr> 
   <td>String(byte[] bytes)</td> 
   <td>使用bytes数组中的所有内容构造对象</td> 
  </tr> 
  <tr> 
   <td>String(char[] value, int offset, int count)</td> 
   <td>使用value数组中下标从offset位置开始的count个字符来构造对象</td> 
  </tr> 
  <tr> 
   <td>String(char[] value)</td> 
   <td>使用value数组中的所有内容构造对象</td> 
  </tr> 
  <tr> 
   <td>String(String original)</td> 
   <td>根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本</td> 
  </tr> 
 </tbody> 
</table>

现在使用String类的构造方法创建字符串，如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 12:36 * @description javase-com.stage1.module3 */
    public class StringConstructorTest { 
    
        public static void main(String[] args) { 
    
            // 1.使用无参构造方式构造对象
            String str1 = new String();
            System.out.println("str1 = " + str1);       // ""
    
            System.out.println("-----------------------------------");
            // 2.使用参数指定的byte数组来构造对象
            byte[] bArr = { 65, 66, 67, 97, 98, 99};
            // 使用字节数组中的一部分元素构造字符串对象，这里是使用数组bArr中洗标从1开始的3个字符构造字符串对象
            String str2 = new String(bArr, 1, 3);
            System.out.println("str2 = " + str2);       // BCa
    
            // 使用整个字符数组来构造字符串对象
            String str3 = new String(bArr);
            System.out.println("str3 = " + str3);       // ABCabc
    
            System.out.println("-----------------------------------");
            // 3.使用字符数组构造字符串对象
            char[] cArr = { 'H', 'e', 'l', 'l', 'o'};
            // 使用字符数组中的一部分元素构造对象
            String str4 = new String(cArr, 2, 3);       // llo
            System.out.println("str4 = " + str4);
            // 使用整个字符数组构造字符串对象
            String str5 = new String(cArr);
            System.out.println("str5 = " + str5);                    // Hello
    
            System.out.println("-----------------------------------");
            // 4.使用字符串来构造字符串对象
            String str6 = new String("world");
            System.out.println("str6 = " + str6);                   // world
        }
    }

输出：

str1 = 
    -----------------------------------
    str2 = BCa
    str3 = ABCabc
    -----------------------------------
    str4 = llo
    str5 = Hello
    -----------------------------------
    str6 = world

其中，`String str1 = new String();`的结果是`""`空字符串，即空字符串对象、有对象只是内容为空，而不是null，null表示空、连对象都没有；

`String str2 = new String(bArr, 1, 3);`和`String str3 = new String(bArr);`构造字符串的原理是将对应的每个整数转换成对应的字符，再将所有的字符拼接成字符串；

`String str4 = new String(cArr, 2, 3);`和`String str5 = new String(cArr);`构造字符串的思路是直接将字符拼接起来组成字符串。

## （3）String类的笔试考点 ##

> 1.请问下面的代码会创建几个对象，分别存在什么位置？

如下：

// 1.请问下面的代码会创建几个对象，分别存在什么位置？
    String str1 = "hello";
    String str2 = new String("hello");

其中，`String str1 = "hello";`创建1个对象，存放在常量池中；

`String str2 = new String("hello");`创建2个对象，一个是字符串直接量hello、存放在常量池，一个是String类型的对象、存放在堆区，引用str2指向堆区。

> 2.常量池和堆区对象的比较，分析下面代码的执行结果。

如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 13:10 * @description javase-com.stage1.module3 */
    public class StringExamTest { 
    
        public static void main(String[] args) { 
    
            // 1.请问下面的代码会创建几个对象，分别存在什么位置？
            String str1 = "hello";      // 1个对象，存放在常量池中
            String str2 = new String("hello");      // 2个对象，一个是字符串直接量hello、存放在常量池，一个是String类型的对象、存放在堆区，引用str2指向堆区
    
            // 2.分析下面代码的执行结果
            String str3 = "hello";                      // 常量池
            String str4 = "hello";                      // 常量池
            String str5 = new String("hello");  // 堆区
            String str6 = new String("hello");  // 堆区
            System.out.println(str3 == str4);           // 比较地址，true
            System.out.println(str3.equals(str4));      // 比较内容，true
            System.out.println(str5 == str6);           // 比较地址，false
            System.out.println(str5.equals(str6));      // 比较内容，true
            System.out.println(str3 == str5);           // 比较地址，false
            System.out.println(str3.equals(str5));      // 比较内容，true
        }
    }

输出：

true
    true
    false
    true
    false
    true

其中，`==`比较的是两个字符串的地址，`equals()`方法比较的是连个字符串的内容，分析各个字符之间的地址、内容关系即可得出答案。

> 3.常量优化机制，变量不支持优化机制。

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 13:10 * @description javase-com.stage1.module3 */
    public class StringExamTest { 
    
        public static void main(String[] args) { 
    
            // 1.请问下面的代码会创建几个对象，分别存在什么位置？
            String str1 = "hello";      // 1个对象，存放在常量池中
            String str2 = new String("hello");      // 2个对象，一个是字符串直接量hello、存放在常量池，一个是String类型的对象、存放在堆区，引用str2指向堆区
    
            // 2.分析下面代码的执行结果
            String str3 = "hello";                      // 常量池
            String str4 = "hello";                      // 常量池
            String str5 = new String("hello");  // 堆区
            String str6 = new String("hello");  // 堆区
            System.out.println(str3 == str4);           // 比较地址，true
            System.out.println(str3.equals(str4));      // 比较内容，true
            System.out.println(str5 == str6);           // 比较地址，false
            System.out.println(str5.equals(str4));      // 比较内容，true
            System.out.println(str3 == str5);           // 比较地址，false
            System.out.println(str3.equals(str5));      // 比较内容，true
    
            System.out.println("---------------------------------------");
            // 3.常量有优化机制，变量没有
            String str7 = "abcd";
            String str8 = "ab" + "cd";                  // 常量优化机制
            System.out.println(str7 == str8);           // 比较地址，true
            String str9 = "ab";
            String str10 = str9 + "cd";                 // 没有常量优化机制
            System.out.println(str7 == str10);          // 比较地址，false
        }
    }

输出：

true
    true
    false
    true
    false
    true
    ---------------------------------------
    true
    false

可以看到，存在着常量优化机制，`ab`与`cd`都是常量、拼接成新的常量`abcd`，而`abcd`之前已经使用过、保存在常量池中，可以直接使用，不需要再创建新的字符串对象，所以str7和str8指向的是同一个字符串对象，比较地址的结果是相同的；

Java语言为字符串连接运算符（+）提供特殊支持，并将其他对象转换为字符串，所以`str9 + "cd"`得到的是字符串`abcd`；

str10是通过`str9 + "cd"`得到的，虽然与str7的值是相同的，但是因为str9是变量，变量不存在优化机制，所以与str7不是同一个对象、地址不同，返回false。

# 2.String常用的成员方法及使用 #

String类常用的成员方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String toString()</td> 
   <td>返回字符串本身</td> 
  </tr> 
  <tr> 
   <td>byte[] getBytes()</td> 
   <td>将当前字符串内容转换为byte数组并返回</td> 
  </tr> 
  <tr> 
   <td>char[] toCharArray()</td> 
   <td>用于将当前字符串内容转换为char数组并返回</td> 
  </tr> 
  <tr> 
   <td>char charAt(int index)</td> 
   <td>方法charAt用于返回字符串指定位置的字符</td> 
  </tr> 
  <tr> 
   <td>int length()</td> 
   <td>返回字符串字符序列的长度</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断字符串是否为空</td> 
  </tr> 
  <tr> 
   <td>int compareTo(String anotherString)</td> 
   <td>用于比较调用对象和参数对象的大小关系</td> 
  </tr> 
  <tr> 
   <td>int compareToIgnoreCase(String str)</td> 
   <td>忽略大小写比较调用对象和参数对象的大小关系，例如’a’和’A’视作相等</td> 
  </tr> 
  <tr> 
   <td>String concat(String str)</td> 
   <td>用于实现字符串的拼接</td> 
  </tr> 
  <tr> 
   <td>boolean contains(CharSequence s)</td> 
   <td>用于判断当前字符串是否包含参数指定的内容</td> 
  </tr> 
  <tr> 
   <td>String toLowerCase()</td> 
   <td>返回字符串的小写形式</td> 
  </tr> 
  <tr> 
   <td>String toUpperCase()</td> 
   <td>返回字符串的大写形式</td> 
  </tr> 
  <tr> 
   <td>String trim()</td> 
   <td>返回去掉前导和后继空白的字符串</td> 
  </tr> 
  <tr> 
   <td>boolean startsWith(String prefix)</td> 
   <td>判断字符串是否以参数字符串开头</td> 
  </tr> 
  <tr> 
   <td>boolean startsWith(String prefix, int toffset)</td> 
   <td>从指定位置开始是否以参数字符串开头</td> 
  </tr> 
  <tr> 
   <td>boolean endsWith(String suffix)</td> 
   <td>判断字符串是否以参数字符串结尾</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object anObject)</td> 
   <td>用于比较字符串内容是否相等并返回</td> 
  </tr> 
  <tr> 
   <td>int hashCode()</td> 
   <td>获取调用对象的哈希码值</td> 
  </tr> 
  <tr> 
   <td>boolean equalsIgnoreCase(String anotherString)</td> 
   <td>用于比较字符串内容是否相等并返回，不考虑大小写，如’A’和’a’视作相等</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch)</td> 
   <td>用于返回当前字符串中参数ch指定字符第一次出现的下标</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch, int fromIndex)</td> 
   <td>用于从fromIndex位置开始查找ch指定的字符</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str)</td> 
   <td>在字符串中检索str第一次出现的位置，若找不到返回-1</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str, int fromIndex)</td> 
   <td>表示从字符串的fromIndex位置开始检索str第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch)</td> 
   <td>用于返回参数ch指定的字符最后一次出现的下标</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch, int fromIndex)</td> 
   <td>用于从fromIndex位置开始查找ch指定字符最后一次出现的下标</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str)</td> 
   <td>返回str指定字符串最后一次出现的下标</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str, int fromIndex)</td> 
   <td>用于从fromIndex位置开始反向搜索指定字符串第一次出现的下标</td> 
  </tr> 
  <tr> 
   <td>String substring(int<br>beginIndex, int endIndex)</td> 
   <td>返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex)</td> 
   <td>返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串</td> 
  </tr> 
 </tbody> 
</table>

## （1）String类型和数组之间的转换 ##

String类型与数组之间的转换用到`byte[] getBytes()`和`char[] toCharArray()`方法。

使用如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 18:27 * @description javase-com.stage1.module3 */
    public class StringByteCharTest { 
    
        public static void main(String[] args) { 
    
            // 1.创建String类型的对象
            String str1 = new String("Corley");
            System.out.println("str1 = " + str1);
    
            // 2.String类型转换为byte类型数组
            // 实现思路是先将字符串拆分成字符，再将每个字符转换成byte类型
            byte[] bArr = str1.getBytes();
            for (int i = 0; i < bArr.length; i++) { 
                System.out.println("下标为" + i + "的编码是" + bArr[i]);
            }
    
            // 将byte数组转回String类型
            String str2 = new String(bArr);
            System.out.println("转回字符串为：" + str2);
    
            System.out.println("----------------------------------");
            // 3.String类型转换为char类型数组
            // 实现思路是将字符串拆分成字符并保存到数组中
            char[] cArr = str1.toCharArray();
            for (int i = 0; i < cArr.length; i++) { 
                System.out.println("下标为" + i + "的字符是" + cArr[i]);
            }
    
            // 将char数组转回String类型
            String str3 = new String(cArr);
            System.out.println("转回字符串为：" + str3);
    
        }
    }

输出：

str1 = Corley
    下标为0的编码是67
    下标为1的编码是111
    下标为2的编码是114
    下标为3的编码是108
    下标为4的编码是101
    下标为5的编码是121
    转回字符串为：Corley
    ----------------------------------
    下标为0的字符是C
    下标为1的字符是o
    下标为2的字符是r
    下标为3的字符是l
    下标为4的字符是e
    下标为5的字符是y
    转回字符串为：Corley

其中，`byte[] bArr = str1.getBytes();`的实现思路是先将字符串拆分成字符，再将每个字符转换成byte类型，也就是获取对应字符的ASCII值；

`char[] cArr = str1.toCharArray();`的实现思路是将字符串拆分成字符并保存到数组中。

## （2）String类中字符的获取和使用 ##

现在使用`char charAt(int index)`、`int length()`和`boolean isEmpty()`方法，如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/20 18:44 * @description javase-com.stage1.module3 */
    public class StringCharTest { 
    
        public static void main(String[] args) { 
    
            // 1.获取String类型的对象
            String str1 = new String("Corley");
            System.out.println("str1 = " + str1);
    
            // 2.获取字符串的长度和每个字符
            System.out.println("字符串长度为：" + str1.length());
            System.out.println("下标为0的字符：" + str1.charAt(0));
            System.out.println("下标为1的字符：" + str1.charAt(1));
            System.out.println("下标为2的字符：" + str1.charAt(2));
            System.out.println("下标为3的字符：" + str1.charAt(3));
            System.out.println("下标为4的字符：" + str1.charAt(4));
            System.out.println("下标为5的字符：" + str1.charAt(5));
            // System.out.println("下标为6的字符：" + str1.charAt(6)); // java.lang.StringIndexOutOfBoundsException
    
            System.out.println("----------------------------------");
            // 3.使用for循环获取所有字符
            for (int i = 0; i < str1.length(); i++) { 
                System.out.println("下标为" + i + "的字符：" + str1.charAt(i));
            }
    
            System.out.println("----------------------------------");
            // 4.判断字符串是否为空
            System.out.println(0 == str1.length() ? "字符串为空" : "字符串不为空");
            System.out.println(str1.isEmpty() ? "字符串为空" : "字符串不为空");
    
            System.out.println("----------------------------------");
            // 5.笔试考点
            // 使用两种方式实现字符串“12345”转换为整数12345
            String str2 = new String("12345");
            // 方式一：使用Integer类的parseInt()方法转换
            int ia = Integer.parseInt(str2);
            System.out.println("转换出来的整数是：" + ia);
            // 方式二：利用ASCII来实现类型转换
            int ib = 0;
            for (int i = 0; i < str2.length(); i++) { 
                ib = ib * 10 + (str2.charAt(i) - '0');
            }
            System.out.println("转换出来的整数是：" + ib);
    
            System.out.println("-------------------------------------");
            // 6.实现整数到字符串的转换
            String str3 = String.valueOf(ib);
            System.out.println("str3 = " + str3);
            str3 = "" + ib;
            System.out.println("str3 = " + str3);
        }
    }

输出：

str1 = Corley
    字符串长度为：6
    下标为0的字符：C
    下标为1的字符：o
    下标为2的字符：r
    下标为3的字符：l
    下标为4的字符：e
    下标为5的字符：y
    ----------------------------------
    下标为0的字符：C
    下标为1的字符：o
    下标为2的字符：r
    下标为3的字符：l
    下标为4的字符：e
    下标为5的字符：y
    ----------------------------------
    字符串不为空
    字符串不为空
    ----------------------------------
    转换出来的整数是：12345
    转换出来的整数是：12345
    -------------------------------------
    str3 = 12345
    str3 = 12345

可以看到，如果字符串下标越界，可以通过编译、但是运行会发生异常，例如`str.charAt(6)`就会报错`java.lang.StringIndexOutOfBoundsException: String index out of range`；

`0 == str1.length()`和`str1.isEmpty()`的效果是相同的；

String类中的静态方法`static String valueOf()`通过重载，实现了将各种类型转化为字符串，例如`String.valueOf(ib)`将整型转换为字符串，但是开发中更推荐的是第二种方式`"" + ib`，因为字符串与任何类型数据进行拼接得到的都是字符串，而这里拼接的字符串是空字符串，所以变相实现了将整数转换为字符串。

## （3）String类对象实现回文的判断 ##

> 案例题目：  
> 判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读还是从右向左读都是相同的句子。

代码如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/21 12:50 * @description javase-com.stage1.module3 */
    public class StringPalindromeTest { 
    
        public static void main(String[] args) { 
    
            // 1.创建字符串对象
            String str = new String("上海自来水来自海上");
            System.out.println("str = " + str);
    
            // 2.判断字符串是否为回文字符串
            for (int i = 0; i < str.length()/2; i++) { 
                if (str.charAt(i) != str.charAt(str.length()-1-i)) { 
                    System.out.println(str + "不是回文！");
                    return;     // 用于在得到结果时实现方法的结束
                }
            }
            System.out.println(str + "是回文！");
        }
    }

输出：

str = 上海自来水来自海上
    上海自来水来自海上是回文！

可以看到原字符串是回文串。

## （4）String类实现字符串之间大小的比较 ##

String类实现字符串之间的大小比较使用`int compareTo(String anotherString)`和`int compareToIgnoreCase(String str)`方法。

其中，`int compareTo(String anotherString)`比较的原理是：

按字典顺序比较两个字符串，即比较基于字符串中每个字符的Unicode值，调用对象对应的字符序列按字典顺序与参数字符串表示的字符序列进行比较。 如果调用对象按字典顺序排在参数字符串之前，则结果为负整数； 如果调用对象按字典顺序在参数字符串之后，则结果为正整数；如果字符串相等，结果为零。

如果两个字符串不同，则要么它们在对两个字符串都是有效索引的某个索引处具有不同的字符，要么它们的长度不同，或者两者都有：

如果它们在一个或多个索引位置具有不同的字符，则令k为最小的索引， compareTo返回两个字符串中位置k处两个字符值的差值，即`this.charAt(k)-anotherString.charAt(k)`；

如果它们没有不同的索引位置，那么较短的字符串按字典顺序排在较长的字符串之前， compareTo返回字符串长度的差值，即`this.length()-anotherString.length()`。

如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/21 13:03 * @description javase-com.stage1.module3 */
    public class StringCompareTest { 
    
        public static void main(String[] args) { 
    
            // 1.构造String类型的对象
            String str = new String("Corley");
            System.out.println("str = " + str);
    
            // 2.使用构造好的String类型对象与其他字符串之间比较大小
            System.out.println(str.compareTo("Jack"));                     // 'C' - 'J' => 67 - 74 => -7
            System.out.println(str.compareTo("Curliy"));                   // 'o' - 'u' => 111 - 117 => -6
            System.out.println(str.compareTo("Conliy"));                   // 'r' - 'n' => 114 - 110 => 4
            System.out.println(str.compareTo("Corley Town"));              // 长度：6 - 11 => -5
            System.out.println(str.compareTo("corley"));                   // 'C' - 'c' => 67 - 99 => -32
            System.out.println(str.compareToIgnoreCase("corley"));         // 0
    
        }
    }

输出：

str = Corley
    -7
    -6
    4
    -5
    -32
    0

## （5）String类中使用方法操作字符串 ##

现在使用方法来操作和判断字符串，如下：

package com.stage1.module3;
    
    import java.util.Locale;
    
    /** * @author Corley * @date 2021/7/22 9:06 * @description javase-com.stage1.module3 */
    public class StringOperationTest { 
    
        public static void main(String[] args) { 
    
            // 1.构造String类型的对象
            String str1 = new String(" You may be out of my sight, but never out of my mind. ");
            System.out.println("str1 = " + str1);
    
            System.out.println("-------------------------------------------");
            // 2.调用各种方法进行测试
            // 判断是否包含某个子串
            boolean b1 = str1.contains("sight");     // true，区分大小写
            System.out.println("b1 = " + b1);
            b1 = str1.contains("Sight");             // false
            System.out.println("b1 = " + b1);
    
            // 将字符串转换为大写、小写，以及去除两边的空白字符
            String str2 = str1.toUpperCase();
            System.out.println("str2 = " + str2);   // YOU MAY BE OUT OF MY SIGHT, BUT NEVER OUT OF MY MIND.
            System.out.println("str1 = " + str1);   // You may be out of my sight, but never out of my mind.
    
            String str3 = str1.toLowerCase();
            System.out.println("str3 = " + str3);   // you may be out of my sight, but never out of my mind.
            System.out.println("str1 = " + str1);   // You may be out of my sight, but never out of my mind.
    
            String str4 = str1.trim();
            System.out.println("str4 = " + str4);   // You may be out of my sight, but never out of my mind.
    
            System.out.println("-------------------------------------------");
            // 判断字符串是否以某个子串开头或结尾
            boolean b2 = str1.startsWith("You");                        // false
            System.out.println("b2 = " + b2);
            b2 = str1.startsWith("You", 9);               // 从下标9开始是否以You开头，true
            System.out.println("b2 = " + b2);
            b2 = str1.endsWith("mind.");                                // false
            System.out.println("b2 = " + b2);
            b2 = str1.endsWith(" ");                                    // true
            System.out.println("b2 = " + b2);
        }
    }

输出：

str1 =          You may be out of my sight, but never out of my mind.           
    -------------------------------------------
    b1 = true
    b1 = false
    str2 =          YOU MAY BE OUT OF MY SIGHT, BUT NEVER OUT OF MY MIND.           
    str1 =          You may be out of my sight, but never out of my mind.           
    str3 =          you may be out of my sight, but never out of my mind.           
    str1 =          You may be out of my sight, but never out of my mind.           
    str4 = You may be out of my sight, but never out of my mind.
    -------------------------------------------
    b2 = false
    b2 = true
    b2 = false
    b2 = true

## （6）String类实现登录功能的模拟 ##

> 案例题目：  
> 提示用户从键盘输入用户名和密码信息，若输入“admin”和“123456”则提示“登录成功，欢迎使用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已冻结，请联系客服人员！”

实现模拟登录功能通过String类中重写Object类中的方法实现，即需要用到`boolean equals(Object anObject)`、`int hashCode()`和`boolean equalsIgnoreCase(String anotherString)`方法，如下：

package com.stage1.module3;
    
    import java.util.Scanner;
    
    /** * @author Corley * @date 2021/7/22 9:28 * @description javase-com.stage1.module3 */
    public class StringLoginTest { 
    
        public static void main(String[] args) { 
    
            Scanner sc = new Scanner(System.in);
            for (int i = 3; i > 0; i--) { 
                // 1.提示用户输入用户名和密码信息并保存
                System.out.println("请输入您的用户名和密码：");
                String userName = sc.next();
                String password = sc.next();
    
                // 2.判断用户名和密码是否分别为admin和123456并给出提示
                if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) { 
                    System.out.println("登录成功，欢迎使用！");
                    break;
                }
                if (1 == i) { 
                    System.out.println("对不起，账户已冻结，请联系客服人员！");
                } else { 
                    System.out.println("对不起，用户名或密码错误，请重新输入，您还有" + (i - 1) + "次机会！");
                }
            }
            // 关闭Scanner对象
            sc.close();
        }
    }

演示如下：

请输入您的用户名和密码：
    admin 123
    对不起，用户名或密码错误，请重新输入，您还有2次机会！
    请输入您的用户名和密码：
    admin 12345
    对不起，用户名或密码错误，请重新输入，您还有1次机会！
    请输入您的用户名和密码：
    admin 123456
    登录成功，欢迎使用！

其中，`"admin".equalsIgnoreCase(userName)`和`"123456".equals(password)`是为了防止变量为空时作为调用对象可能发生的空指针异常。

## （7）String类实现字符和字符串的正向查找 ##

字符和字符串的正向查找需要用到`int indexOf()`方法，使用如下：

输出：

可以看到，在实现查询字符串中所有"re"出现的索引位置的通用代码时，第二种方式更优雅。

## （8）String类实现字符和字符串的反向查找 ##

字符和字符串的反向查找即从右向左查找，需要使用到`int lastIndexOf()`方法。

使用如下：

package com.stage1.module3;
    
    /** * @author Corley * @date 2021/7/22 9:41 * @description javase-com.stage1.module3 */
    public class StringIndexTest { 
    
        public static void main(String[] args) { 
    
            // 1.构造String类型的对象
            String str = new String("You're unique, nothing can replace you.");
            System.out.println("str = " + str);
    
            // 2.实现字符串中指定字符和字符串的查找
            // 查找字符
            int pos1 = str.indexOf('E');                   // 未查找到，返回-1
            System.out.println("pos1 = " + pos1);
            pos1 = str.indexOf('e');                       // 5
            System.out.println("pos1 = " + pos1);
            pos1 = str.indexOf('e', 6);     // 从下标6开始查找字符e第一次出现的位置，12
            System.out.println("pos1 = " + pos1);
    
            System.out.println("-------------------------------------------");
            // 查找字符串
            int pos2 = str.indexOf("are");                 // 查找字符串中第一个字符的下标，-1
            System.out.println("pos2 = " + pos2);
            pos2 = str.indexOf("re");                      // 4
            System.out.println("pos2 = " + pos2);
            pos2 = str.indexOf("re", 10);   // 27
            System.out.println("pos2 = " + pos2);
    
            System.out.println("-------------------------------------------");
            // 通用代码，查询字符串中所有"re"出现的索引位置
            // 方式一
            int pos3 = str.indexOf("re");
            while (-1 != pos3) { 
                System.out.println("pos3 = " + pos3);
                pos3 = str.indexOf("re", pos3 + 1);
            }
            System.out.println("-------------------------------------------");
            // 方式二
            pos3 = 0;
            while (-1 != (pos3 = str.indexOf("re", pos3))) { 
                System.out.println("pos3 = " + pos3);
                pos3 += "re".length();
            }
    
            System.out.println("-------------------------------------------");
            // 3.实现字符和字符串的反向查找
            // 查找字符
            int pos4 = str.lastIndexOf('e');            // 33
            System.out.println("pos4 = " + pos4);
            pos4 = str.lastIndexOf('e', 24);  // 从下标为24的位置开始反向查找，12
            System.out.println("pos4 = " + pos4);
    
            System.out.println("-------------------------------------------");
            // 查找字符串
            int pos5 = str.lastIndexOf("re");            // 27
            System.out.println("pos5 = " + pos5);
            pos5 = str.lastIndexOf("re", 20);  // 从下标为24的位置开始反向查找，4
            System.out.println("pos5 = " + pos5);
            pos5 = str.lastIndexOf("re", 3);   // 从下标为3的位置开始反向查找，-1
            System.out.println("pos5 = " + pos5);
        }
    }

输出：

str = You're unique, nothing can replace you.
    pos1 = -1
    pos1 = 5
    pos1 = 12
    -------------------------------------------
    pos2 = -1
    pos2 = 4
    pos2 = 27
    -------------------------------------------
    pos3 = 4
    pos3 = 27
    -------------------------------------------
    pos3 = 4
    pos3 = 27
    -------------------------------------------
    pos4 = 33
    pos4 = 12
    -------------------------------------------
    pos5 = 27
    pos5 = 4
    pos5 = -1

## （9）String类中子字符串的获取 ##

String类中获取子字符串使用`String substring()`方法。

> 案例题目：  
> 提示用户从键盘输入一个字符串和一个字符，输出该字符（不含）后面的所有子字符串。

实现如下：

package com.stage1.module3;
    
    import java.util.Scanner;
    
    /** * @author Corley * @date 2021/7/22 12:27 * @description javase-com.stage1.module3 */
    public class StringSubStringTest { 
    
        public static void main(String[] args) { 
    
            // 1.构造String类型的对象
            String str1 = new String("Good is good, but better carries it.");
            System.out.println("str1 = " + str1);
    
            System.out.println("-------------------------------------");
            // 2.获取字符串中的部分内容并打印
            // 从当前字符串中下标14开始获取子字符串
            String str2 = str1.substring(14);
            System.out.println("str2 = " + str2);
            // 从当前字符串下标8开始、到12（不包含12）
            String str3 = str1.substring(8, 12);
            System.out.println("str3 = " + str3);
    
            System.out.println("-------------------------------------");
            // 3.获取输入字符串中从输入字符其的字符串内容
            System.out.println("请输入一个字符串：");
            Scanner sc = new Scanner(System.in);
            String str4 = sc.next();
            System.out.println("请输入一个字符：");
            String str5 = sc.next();
            // 从str4中查找str5第一次出现的索引位置
            int pos = str4.indexOf(str5);
            System.out.println("pos = " + pos);
            // 根据获取到的位置获取子字符串
            String str6 = str4.substring(pos + 1);
            System.out.println("获取到的子字符串是：" + str6);
    
        }
    }

输出：

str1 = Good is good, but better carries it.
    -------------------------------------
    str2 = but better carries it.
    str3 = good
    -------------------------------------
    请输入一个字符串：
    hello,corley
    请输入一个字符：
    c
    pos = 6
    获取到的子字符串是：orley

# 3.正则表达式的概念和使用 #

## （1）正则表达式的概念和规则 ##

正则表达式本质是一个**规则字符串** ，可以用于**对字符串数据的格式进行验证** ，以及进行匹配、查找、替换等操作。

该字符串通常使用`^`运算符作为开头标志、`$`运算符作为结尾标志，也可以省略。

常见的规则如下：

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[abc]</td> 
   <td>可以出现a、b、c中任意一个字符</td> 
  </tr> 
  <tr> 
   <td>[^abc]</td> 
   <td>可以出现任何字符，除了a、b、c的任意字符</td> 
  </tr> 
  <tr> 
   <td>[a-z]</td> 
   <td>可以出现a、b、c、……、z中的任意一个字符</td> 
  </tr> 
  <tr> 
   <td>[a-zA-Z0-9]</td> 
   <td>可以出现a<sub>z、A</sub>Z、0~9中任意一个字符</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>任意一个字符（通常不包含换行符）</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>任意一个数字字符，相当于[0-9]</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>任意一个非数字字符</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>空白字符，相当于[\t\n\x0B\f\r]</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>非空白字符</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>任意一个单词字符，相当于[a-zA-Z_0-9]</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>任意一个非单词字符</td> 
  </tr> 
  <tr> 
   <td>X?</td> 
   <td>表示X可以出现一次或一次也没有，也就是0 ~ 1次</td> 
  </tr> 
  <tr> 
   <td>X*</td> 
   <td>表示X可以出现零次或多次，也就是0 ~ n次</td> 
  </tr> 
  <tr> 
   <td>X+</td> 
   <td>表示X可以出现一次或多次，也就是1 ~ n次</td> 
  </tr> 
  <tr> 
   <td>X{n}</td> 
   <td>表示X可以出现恰好 n 次</td> 
  </tr> 
  <tr> 
   <td>X{n, }</td> 
   <td>表示X可以出现至少 n 次，也就是≥n次</td> 
  </tr> 
  <tr> 
   <td>X{n, m}</td> 
   <td>表示X可以出现至少 n 次，但是不超过 m 次，也就是≥n并且≤m次</td> 
  </tr> 
 </tbody> 
</table>

其中，`matches(String regex)`方法可以用于判断调用字符串对象是否与参数指定的正则表达式匹配。

## （2）正则表达式的编程使用 ##

> 案例题目：  
> 使用正则表达式描述一下银行卡密码的规则：要求是由6位数字组成。  
> 使用正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数组成。  
> 使用正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位。  
> 描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X。

如下：

package com.stage1.module3;
    
    import java.util.Scanner;
    
    /** * @author Corley * @date 2021/7/22 18:34 * @description javase-com.stage1.module3 */
    public class StringRETest { 
    
        public static void main(String[] args) { 
    
            Scanner sc = new Scanner(System.in);
            String str;
            // 1.定义描述规则的正则表达式字符串
            // 银行卡密码的规则：由6位数字组成
            String reg1 = "^\\d{6}$";   // "\\d{6}"、"^[0-9]$"
            // QQ号码的规则：由非0开头的5~15位数组成
            String reg2 = "[1-9]\\d{4,14}";
            // 手机号码的规则：由1开头，第二位数是3、4、5、7、8、9中的一位，总共11位
            String reg3 = "1[345789]\\d{9}";
            // 身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X
            String reg4 = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9|X])";
    
            while (true) { 
                // 2.提示用户输入指定的内容
                System.out.println("请输入您的银行卡密码：");
                str = sc.next();
    
                // 3.判断用户输入的内容是否匹配指定的规则
                if (str.matches(reg1)) { 
                    System.out.println("银行卡密码格式正确！");
                    break;
                } else { 
                    System.out.println("银行卡密码格式错误！");
                }
            }
    
            System.out.println("-----------------------------------");
            while (true) { 
                // 2.提示用户输入指定的内容
                System.out.println("请输入您的QQ号码：");
                str = sc.next();
    
                // 3.判断用户输入的内容是否匹配指定的规则
                if (str.matches(reg2)) { 
                    System.out.println("QQ号码格式正确！");
                    break;
                } else { 
                    System.out.println("QQ号码格式错误！");
                }
            }
    
            System.out.println("-----------------------------------");
            while (true) { 
                // 2.提示用户输入指定的内容
                System.out.println("请输入您的手机号码：");
                str = sc.next();
    
                // 3.判断用户输入的内容是否匹配指定的规则
                if (str.matches(reg3)) { 
                    System.out.println("手机号码格式正确！");
                    break;
                } else { 
                    System.out.println("手机号码格式错误！");
                }
            }
    
            System.out.println("-----------------------------------");
            while (true) { 
                // 2.提示用户输入指定的内容
                System.out.println("请输入您的身份证号码：");
                str = sc.next();
    
                // 3.判断用户输入的内容是否匹配指定的规则
                if (str.matches(reg4)) { 
                    System.out.println("身份证号码格式正确！");
                    break;
                } else { 
                    System.out.println("身份证号码格式错误！");
                }
            }
        }
    }

输出：

请输入您的银行卡密码：
    12345
    银行卡密码格式错误！
    请输入您的银行卡密码：
    1234567
    银行卡密码格式错误！
    请输入您的银行卡密码：
    12345a
    银行卡密码格式错误！
    请输入您的银行卡密码：
    123456
    银行卡密码格式正确！
    -----------------------------------
    请输入您的QQ号码：
    012345
    QQ号码格式错误！
    请输入您的QQ号码：
    123
    QQ号码格式错误！
    请输入您的QQ号码：
    12345123451234512345
    QQ号码格式错误！
    请输入您的QQ号码：
    12345
    QQ号码格式正确！
    -----------------------------------
    请输入您的手机号码：
    12311111111
    手机号码格式错误！
    请输入您的手机号码：
    1231111111
    手机号码格式错误！
    请输入您的手机号码：
    123111111111
    手机号码格式错误！
    请输入您的手机号码：
    13111111111
    手机号码格式正确！
    -----------------------------------
    请输入您的身份证号码：
    12121220210722123a
    身份证号码格式错误！
    请输入您的身份证号码：
    12121220210722123X
    身份证号码格式正确！

其中，正则表达式只能对字符串内容的格式进行检查，无法对数据内容的正确性进行检查，内容的正确性检查一般需要查询后台的数据库。

## （3）正则表达式相关方法的使用 ##

正则表达式常用的方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>方法说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String[] split(String regex)</td> 
   <td>参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组</td> 
  </tr> 
  <tr> 
   <td>String replace(char oldChar, char newChar)</td> 
   <td>使用参数newChar替换此字符串中出现的所有参数</td> 
  </tr> 
  <tr> 
   <td>oldChar String replaceFirst(String regex, String replacement)</td> 
   <td>替换此字符串匹配给定的正则表达式的第一个子字符串</td> 
  </tr> 
  <tr> 
   <td>String replaceAll(String regex, String replacement)</td> 
   <td>将字符串中匹配正则表达式regex的字符串替换成replacement</td> 
  </tr> 
 </tbody> 
</table>

现在对这些方法进行测试，如下：

package com.stage1.module3;
    
    import java.util.Arrays;
    
    /** * @author Corley * @date 2021/7/22 19:03 * @description javase-com.stage1.module3 */
    public class StringREMethodTest { 
    
        public static void main(String[] args) { 
    
            // 1.创建字符串对象
            String str1 = "She sells sea shells on the seashore. 12345. The seashells 67890 she sells are seashells she is sure.";
            System.out.println("str1 = " + str1);
    
            System.out.println("---------------------------------------");
            // 2.根据指定字符串切割字符串
            String[] sArr = str1.split("s[eh]");        // 按照se或sh切割字符串
            System.out.println(Arrays.toString(sArr));
    
            System.out.println("---------------------------------------");
            // 3.对字符串进行替换
            String str2 = str1.replace("se", "ma");   // 将se替换为ma
            System.out.println("str2 = " + str2);
            String str3 = str1.replaceFirst("\\d+", "***"); // 将第一个出现的数字字符串替换为***
            System.out.println("str3 = " + str3);
            String str4 = str1.replaceAll("sh?e", "##");    // 将所有的she或se替换为##
            System.out.println("str4 = " + str4);
    
        }
    }

输出：

str1 = She sells sea shells on the seashore. 12345. The seashells 67890 she sells are seashells she is sure.
    ---------------------------------------
    [She , lls , a , ells on the , a, ore. 12345. The , a, ells 67890 , e , lls are , a, ells , e is sure.]
    ---------------------------------------
    str2 = She malls maa shells on the maashore. 12345. The maashells 67890 she malls are maashells she is sure.
    str3 = She sells sea shells on the seashore. ***. The seashells 67890 she sells are seashells she is sure.
    str4 = She ##lls ##a ##lls on the ##ashore. 12345. The ##a##lls 67890 ## ##lls are ##a##lls ## is sure.

# 总结 #

字符串不仅仅在Java中，在所有语言中都是最常用的一个数据类型，可以用于描述字符串事物，再怎怎么评价其重要性都不为过。