Java常用类与基础API--String的构造器与常用方法

文章目录

一、String的常用API-1
- （1）构造器
- - 1、介绍
  - 2、举例
- （2）String与其他结构间的转换
- - 1、基本数据类型、包装类 --> 字符串
  - 2、字符串 --> 基本数据类型、包装类
  - 3、字符串 --> 字符数组
  - 4、字符数组 --> 字符串
  - 5、字符串 --> 字节数组（编码）
  - 6、字节数组 --> 字符串（解码）
- （3）代码
二、String的常用API-2
- （1）系列1：常用方法
- - 1、isEmpty()
  - 2、length()
  - 3、concat(xx)
  - 4、equals(Object obj)
  - 5、equalsIgnoreCase(Object obj)
  - 6、compareTo(String other)
  - 7、compareToIgnoreCase(String other)
  - 8、toLowerCase()
  - 9、toUpperCase()
  - 10、trim()
  - 11、intern()
  - 12、总代码
- （2）系列2：查找
- - 1、contains(xx)
  - 2、indexOf(xx)
  - 3、indexOf(String str, int fromIndex)
  - 4、lastIndexOf(xx)
  - 5、lastIndexOf(String str, int fromIndex)
  - 6、总代码
- （3）系列3：字符串截取
- - 1、substring(int beginIndex)
  - 2、substring(int beginIndex, int endIndex)
  - 3、总代码
- （4）系列4：和字符/字符数组相关
- - 1、charAt(index)
  - 2、toCharArray()
  - 3、valueOf(char[] data)
  - 4、valueOf(char[] data, int offset, int count)
  - 5、copyValueOf(char[] data)
  - 6、copyValueOf(char[] data, int offset, int count)
  - 7、总代码
- （5）系列5：开头与结尾
- - 1、startsWith(xx)
  - 2、startsWith(String prefix, int toffset)
  - 3、endsWith(xx)
  - 4、总代码
- （6）系列6：替换
- - 1、replace(char oldChar, char newChar)
  - 2、replace(CharSequence target, CharSequence replacement)
  - 3、replaceAll(String regex, String replacement)
  - 4、replaceFirst(String regex, String replacement)
  - 5、总代码

一、String的常用API-1

（1）构造器

1、介绍

public String() ：初始化新创建的 String对象，以使其表示空字符序列。就是new了一个String，里面什么也没有写，即" "，可以理解为对应数组的长度为0，即new char[0]。
public String(String original)：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。就是直接指明一个字符串。
public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的String。
public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
public String(byte[] bytes,String charsetName) ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。

2、举例

①🔥public String()

🗳️初始化新创建的 String对象，以使其表示空字符序列。就是new了一个String，里面什么也没有写，即" "，可以理解为对应数组的长度为0，即new char[0]。

🌱代码

//1.public String()
@Test
public void test1(){
    String s1=new String();
    //或
    String s2=new String("");
}

进入String内部：

public String() {
    this.value = "".value;
}

②🔥public String(String original)

🗳️初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。就是直接指明一个字符串。

🌱代码

//2.public String(String original)
@Test
public void test2(){
    String s3=new String("abc");
}

进入String内部：

@IntrinsicCandidate
public String(String original) {
    this.value = original.value;
}

③🔥public String(char[] value)

🗳️通过当前参数中的字符数组来构造新的String。

🌱代码

//3.public String(char[] value)
@Test
public void test3(){
    String s4=new String(new char[]{'a','b','c'});
    System.out.println(s4);
}

进入String内部：

public String(char[] value) {
    this(value, 0, value.length, null);
}

🍺输出

④🔥public String(char[] value,int offset, int count)

🗳️通过字符数组的一部分来构造新的String。

⑤🔥public String(byte[] bytes)

🗳️通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

⑥🔥public String(byte[] bytes,String charsetName)

🗳️通过使用指定的字符集解码当前参数中的字节数组来构造新的String。

（2）String与其他结构间的转换

关于包装类的使用：
https://blog.csdn.net/m0_55746113/article/details/134990781?spm=1001.2014.3001.5502

1、基本数据类型、包装类 --> 字符串

🗳️说明

调用String类的public String valueOf(int n)可将int型转换为字符串
相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b)可由参数的相应类型到字符串的转换。

🌱案例代码

//1.String与基本数据类型、包装类之间的转换(复习)，要转化成谁，就在谁那里找方法
@Test
public void test7(){
    //①基本数据类型-->String类型
    int num=10;
    //方式一
    String s1=num+"";
    //方式二
    String s2=String.valueOf(num);
}

2、字符串 --> 基本数据类型、包装类

🗳️说明

Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。
类似地，使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。

🌱案例代码

//1.String与基本数据类型、包装类之间的转换(复习)，要转化成谁，就在谁那里找方法
@Test
public void test7(){
    //②String类型-->基本数据类型(它本身没有方法，去找包装类里面的方法):调用包装类的parseXxx(String str)
    String s3="123";
    int i1=Integer.parseInt(s3);

}

3、字符串 --> 字符数组

🗳️说明

public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法。
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法。

🌱案例代码

//2.String类型与char[]型数组之间的转换
@Test
public void test8(){
    //①String-->char[]型数组:调用String的toCharArray()
    String str="hello";
    char[] arr = str.toCharArray();
    //遍历
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

🍺输出

4、字符数组 --> 字符串

🗳️说明

String 类的构造器：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象。

🌱案例代码

//2.String与char[]型数组之间的转换
@Test
public void test8(){
    //②char[]型数组-->String类型:调用String的构造器
    char[] arr1={'h','e','l','l','o'};
    String str1=new String(arr1);
    System.out.println(str1);
}

🍺输出

5、字符串 --> 字节数组（编码）

🗳️说明

public byte[] getBytes() ：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
public byte[] getBytes(String charsetName) ：使用指定的字符集将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

🌱案例代码1

//3.String与byte[]型数组之间的转换(有难度，涉及到字符集的问题)
@Test
public void test9(){
    //①String类型-->byte[]型数组:调用String的getBytes()
    String str=new String("hello");
    byte[] arr=str.getBytes();  //getBytes()返回byte类型的数组
    //输出
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

🍺输出

输出的是每个字符对应的ASCLL码。

🌱案例代码2

//3.String与byte[]型数组之间的转换(有难度，涉及到字符集的问题)
@Test
public void test9(){
    //①String类型-->byte[]型数组:调用String的getBytes()
    String str=new String("abc中国");

    //<1> 使用默认字符集(UTF-8)
    byte[] arr=str.getBytes();  //getBytes()返回byte类型的数组，使用默认字符集:UTF-8
    //输出
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

🍺输出

这里涉及到字符集的问题，使用的是UTF-8，在UTF-8中兼容了ASCLL码。

所以我们可以看到，在写abc的时候，就是对应的ASCLL码；在写汉字的时候，是对应的UTF-8。

UTF-8中，一个汉字占用3个字节，一个字母占用1个字节。

☕注意

getBytes()返回byte类型的数组，使用默认字符集，就是我们设置的时候的字符集，如下：

当然，也可以不使用UTF-8，可以显示指明使用的是哪一个字符集。

比如GBK字符集：

//使用GBK字符集
byte[] arr1=str.getBytes("GBK");    //返回byte[]型数组

为了防止瞎写字符集，这里会有一个异常“UnsupportedEncodingException不支持转换”需要处理。

🌱案例代码3

//3.String与byte[]型数组之间的转换(有难度，涉及到字符集的问题)
/*
* UTF-8中，一个汉字占用3个字节，一个字母占用1个字节。
* GBK字符集中，一个汉字占2个字节，一个字母占用1个字节。
* */
@Test
public void test9() throws UnsupportedEncodingException {
    //①String类型-->byte[]型数组:调用String的getBytes()
    String str=new String("abc中国");
    
    //<2> 使用GBK字符集
    byte[] arr1=str.getBytes("GBK");    //返回byte[]型数组，使用GBK字符集
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }
}

🍺输出

GBK字符集中，一个汉字占2个字节，一个字母占用1个字节。

UTF-8和GBK都向下兼容了ASCLL码。

中文操作系统ANSI默认GBK。

🌱整体代码

//3.String与byte[]型数组之间的转换(有难度，涉及到字符集的问题)
/*
* UTF-8中，一个汉字占用3个字节，一个字母占用1个字节。
* GBK字符集中，一个汉字占2个字节，一个字母占用1个字节。
*
* UTF-8和GBK都向下兼容了ASCLL码。
* */
@Test
public void test9() throws UnsupportedEncodingException {
    //①String类型-->byte[]型数组:调用String的getBytes()
    String str=new String("abc中国");
    
    //<1> 使用默认字符集(UTF-8)
    byte[] arr=str.getBytes();  //getBytes()返回byte类型的数组，使用默认字符集:比如UTF-8
    //输出
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    
    //换行
    System.out.println();
    
    //<2> 使用GBK字符集
    byte[] arr1=str.getBytes("GBK");    //getBytes(String charsetName)返回byte[]型数组，使用指定字符集:比如GBK
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }
}

🍺输出

6、字节数组 --> 字符串（解码）

🗳️说明

String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[]，int offset，int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
String(byte[], String charsetName ) 或 new String(byte[], int, int,String charsetName )：解码，按照指定的编码方式进行解码。

🌱案例代码1

 //②byte[]型数组-->String类型:
/*
* 编码与解码
* 编码：将String转换为底层的0101。（String-->字节或字节数组）
* 解码：编码的逆过程。（字节或字节数组-->String）
* 要求：解码时使用的字符集必须与编码时使用的字符集一致。不一致就会乱码！
* */
        
String str1=new String(arr);    //使用默认字符集：UTF-8
System.out.println(str1);

🌱案例代码2

String str=new String("abc中国");
byte[] arr=str.getBytes();  //getBytes()返回byte类型的数组，使用默认字符集:UTF-8

String str1=new String(arr);    //使用默认字符集：UTF-8
System.out.println(str1);   //abc中国

String str2=new String(arr,"UTF-8");    //显示地指明解码的字符集：UTF-8
System.out.println(str2);   //abc中国

String str3=new String(arr,"GBK");  //显示地指明解码的字符集：GBK
System.out.println(str3);   //乱码

🍺输出

🌱案例代码3

String str=new String("abc中国");
byte[] arr1=str.getBytes("GBK");    //getBytes(String charsetName)返回byte[]型数组，使用指定字符集:比如GBK

String str4=new String(arr1,"GBK"); //显示地指明解码的字符集：GBK
System.out.println(str4);	//abc中国

🍺输出

☕注意

编码与解码

编码：将String转换为底层的0101。（String–>字节或字节数组）
解码：编码的逆过程。（字节或字节数组–>String）

要求：解码时使用的字符集必须与编码时使用的字符集一致。不一致就会乱码！

（3）代码

🌱代码

package String;

import org.junit.Test;

import java.io.UnsupportedEncodingException;

/**
 * ClassName: StringMethodTest
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/12 0012 12:07
 */
public class StringMethodTest {
    /*
    * String构造器
    * */

    //1.public String()
    @Test
    public void test1(){
        String s1=new String();
        //或
        String s2=new String("");
    }

    //2.public String(String original)
    @Test
    public void test2(){
        String s3=new String("abc");
    }

    //3.public String(char[] value)
    @Test
    public void test3(){
        String s4=new String(new char[]{'a','b','c'});
        System.out.println(s4);
    }


    /**
     * String与常见的其他结构之间的转换
     */

    //1.String与基本数据类型、包装类之间的转换(复习)，要转化成谁，就在谁那里找方法
    @Test
    public void test7(){
        //①基本数据类型-->String类型
        int num=10;
        //方式一
        String s1=num+"";
        //方式二
        String s2=String.valueOf(num);

        //②String类型-->基本数据类型(它本身没有方法，去找包装类里面的方法):调用包装类的parseXxx(String str)
        String s3="123";
        int i1=Integer.parseInt(s3);

    }

    //2.String与char[]型数组之间的转换
    @Test
    public void test8(){
        //①String类型-->char[]型数组:调用String的toCharArray()
        String str="hello";
        char[] arr = str.toCharArray();
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //②char[]型数组-->String类型:调用String的构造器
        char[] arr1={'h','e','l','l','o'};
        String str1=new String(arr1);
        System.out.println(str1);
    }

    //3.String与byte[]型数组之间的转换(有难度，涉及到字符集的问题)
    @Test
    public void test9() throws UnsupportedEncodingException {
        //①String类型-->byte[]型数组:调用String的getBytes()
        /*
         * UTF-8中，一个汉字占用3个字节，一个字母占用1个字节。
         * GBK字符集中，一个汉字占2个字节，一个字母占用1个字节。
         *
         * UTF-8和GBK都向下兼容了ASCLL码。
         * */
        String str=new String("abc中国");

        //<1> 使用默认字符集(UTF-8)
        byte[] arr=str.getBytes();  //getBytes()返回byte类型的数组，使用默认字符集:比如UTF-8
        //输出
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //换行
        System.out.println();

        //<2> 使用GBK字符集
        byte[] arr1=str.getBytes("GBK");    //getBytes(String charsetName)返回byte[]型数组，使用指定字符集:比如GBK
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }


        //②byte[]型数组-->String类型:
        /*
        * 编码与解码
        * 编码：将String转换为底层的0101。（String-->字节或字节数组）
        * 解码：编码的逆过程。（字节或字节数组-->String）
        * 要求：解码时使用的字符集必须与编码时使用的字符集一致。不一致就会乱码！
        * */

        String str1=new String(arr);    //使用默认字符集：UTF-8
        System.out.println(str1);   //abc中国

        String str2=new String(arr,"UTF-8");    //显示地指明解码的字符集：UTF-8
        System.out.println(str2);   //abc中国

        String str3=new String(arr,"GBK");  //显示地指明解码的字符集：GBK
        System.out.println(str3);   //乱码

        String str4=new String(arr1,"GBK");
        System.out.println(str4);   //abc中国
    }

}

二、String的常用API-2

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。

（1）系列1：常用方法

1、isEmpty()

🔥boolean isEmpty()：字符串是否为空。

public boolean isEmpty() {
    return value.length == 0;
}

🌱案例代码

public class StringMethodTest1 {
    //1.boolean isEmpty()：判断字符串是否为空 (若空则true，非空则false)
    @Test
    public void test1(){
        String s1="";
        String s2=new String();
        String s3=new String("");

        String s5="hello";

        System.out.println(s1.isEmpty());   //true
        System.out.println(s2.isEmpty());   //true
        System.out.println(s3.isEmpty());   //true

        System.out.println(s5.isEmpty());   //false

        /*String s4=null;
        System.out.println(s4.isEmpty());   //报空指针异常*/
    }
}

🍺输出

☕注意

上面的三种情况都是空，这里怎么判断空的？

其实就是判断底层char型数组它的长度，长度为0就是empty。

若直接赋值为null，调用的话就是空指针异常，别这样赋值。如下：

使用isEmpty()的前提是要有”实例“，没有实例是不能调方法的。

在有实例的情况下，里面没有实打实的字符，使用isEmpty()判断就会是空，输出就是true。

若有实打实的字符，结果就不是empty了，输出就是false。

2、length()

🔥int length()：返回字符串的长度。

public int length() {
    return value.length;
}

🌱案例代码

//2.int length()：返回字符串的长度 (char型数组的长度)
@Test
public void test2(){
    String s1="hello";
    System.out.println(s1.length());    //5
}

🍺输出

3、concat(xx)

🔥String concat(xx)：拼接。

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

🌱案例代码

//3.String concat(xx)：拼接 (将调用这个方法的字符串和xx拼接在一起)
@Test
public void test3(){
    String s1="hello";
    System.out.println(s1.concat("world")); //helloworld
}

🍺输出

☕注意

将调用这个方法的字符串和xx拼接在一起，调用这个方法的字符串没有变化，返回的结果是拼一起的。（String的不可变性）

4、equals(Object obj)

🔥boolean equals(Object obj)：比较字符串是否相等，区分大小写。

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

🌱案例代码

//4.boolean equals(Object obj)：比较字符串是否相等，区分大小写
@Test
public void test4(){
    String s1="hello";
    String s2=new String("hello");
    String s3=new String("Hello");

    System.out.println(s1.equals(s2));  //true
    System.out.println(s1.equals(s3));  //false
    System.out.println(s2.equals(s3));  //false
}

🍺输出

5、equalsIgnoreCase(Object obj)

🔥boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写。

public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true
    : (anotherString != null)
    && (anotherString.value.length == value.length)
    && regionMatches(true, 0, anotherString, 0, value.length);
}

🌱案例代码

//5.boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
@Test
public void test5(){
    String s1="hello";
    String s2=new String("hello");
    String s3=new String("Hello");

    System.out.println(s1.equalsIgnoreCase(s2));  //true
    System.out.println(s1.equalsIgnoreCase(s3));  //true
    System.out.println(s2.equalsIgnoreCase(s3));  //true
}

🍺输出

☕注意

equals(Object obj)区分大小写。

equalsIgnoreCase(Object obj)不区分大小写。

举例：

@Test
public void test5(){
    String s1="hello";
    String s3=new String("Hello");

    System.out.println(s1.equalsIgnoreCase(s3));  //true
    System.out.println(s1.equals(s3));  //false

}

有的验证码不区分大小写，就是这种情况。

6、compareTo(String other)

🔥int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小。

public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;
    
    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

🌱案例代码

//6.int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
@Test
public void test6(){
    String s1="abcd";
    String s2="adef";
    System.out.println(s1.compareTo(s2));	//b-d=98-100=-2

    String s3="abcd";
    String s4="abcd";
    System.out.println(s3.compareTo(s4));	//0

    String s5="abcd";
    String s6="aBcd";
    System.out.println(s5.compareTo(s6));	//b-B=98-66=32
}

注：

a-97、b-98、c-99、d-100…

A-65、B-66…

🍺输出

☕注意

调用这个方法的是一个字符串，形参也是一个字符串，比较两个字符串的大小。

之前说String类的声明的时候说到Comparable接口：

String类的理解(以JDK8为例说明)
类的声明
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence

> final:String是不可被继承的
> Serializable:可序列化的接口。凡是实现此接口的类的对象就可以通过网络或本地流进行数据的传输。
> Comparable:凡是实现此接口的类，其对象都可以比较大小。

这个接口有一个抽象方法，就叫compareTo。

所以这里说的compareTo方法其实是重写Comparable接口里面的抽象方法。

两个字符串比较大小，若返回的是一个正数，就表示调用此方法的字符串大。

7、compareToIgnoreCase(String other)

🔥int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写。

public int compareToIgnoreCase(String str) {
    return CASE_INSENSITIVE_ORDER.compare(this, str);
}

🌱案例代码

//7.int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
@Test
public void test7(){
    String s1="abcd";
    String s2="adef";
    System.out.println(s1.compareToIgnoreCase(s2));   //b-d=98-100=-2

    String s5="abcd";
    String s6="aBcd";
    System.out.println(s5.compareToIgnoreCase(s6));   //0
}

🍺输出

☕注意1

compareTo(String other)区分大小写。

compareToIgnoreCase(String other)不区分大小写。

举例：

@Test
public void test7(){
    String s5="abcd";
    String s6="aBcd";
    System.out.println(s5.compareTo(s6));   //b-B=98-66=32
    System.out.println(s5.compareToIgnoreCase(s6));   //0
}

☕注意2

如果比较的是汉字，需要注意一下。

比如：

@Test
public void test7(){
    String s7="张ab";
    String s8="李cd";
    System.out.println(s7.compareTo(s8));	//-2094
}

输出：

后边要将排序的问题，到时候会造一个数组，里面放很多字符串，会写汉字，比如“张三”、“李四”等，然后排序的时候会发现不对。

因为我们会潜意识认为“张三”是Z开头的，“李四”是L开头的。

若此时写的是拼音，毫无疑问，“Zhang”比“Li”要大，减一下就是正数。

但是汉字可不是变成拼音去比较的，它就是纯粹地拿着“张”去字符集里面找对应的值，然后与“李”对应的值比较，减出来发现是负数，也就意味着“张”对应的值比“李”要小。（没有原因，就是这样分配的）

在手机通讯里面，名字是按照A、B、C…排序的。

这里会有一个jar包，将汉字转成拼音，然后再拿拼音去排序。而不是直接拿汉字去排序。

8、toLowerCase()

🔥String toLowerCase()：将字符串中大写字母转为小写。

public String toLowerCase() {
    return toLowerCase(Locale.getDefault());
}

private volatile static Locale defaultLocale = initDefault();

public static Locale getDefault() {
        // do not synchronize this method - see 4071298
        return defaultLocale;
}

🌱案例代码

//8.String toLowerCase()：将字符串中大写字母转为小写
@Test
public void test8(){
    String s1="Hello-中国-123";
    System.out.println(s1.toLowerCase());   //hello-中国-123
}

🍺输出

☕注意

若写的是汉字或者数字，输出没有变化。

9、toUpperCase()

🔥String toUpperCase()：将字符串中小写字母转为大写。

public String toUpperCase() {
    return toUpperCase(Locale.getDefault());
}

🌱案例代码

//9.String toUpperCase()：将字符串中小写字母转为大写
@Test
public void test9(){
    String s1=new String("Hello-你好-567");
    System.out.println(s1.toUpperCase());   //HELLO-你好-567
}

🍺输出

10、trim()

🔥String trim()：去掉字符串前后空白符。

public String trim() {
    int len = value.length;
    int st = 0;
    char[] val = value;    /* avoid getfield opcode */

    while ((st < len) && (val[st] <= ' ')) {
        st++;
    }
    while ((st < len) && (val[len - 1] <= ' ')) {
        len--;
    }
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}

🌱案例代码

//10.String trim()：去掉字符串前后空白符
@Test
public void test10(){
    String s1="  he  l   lo     ";  
    System.out.println("***"+s1.trim()+"***");  //***he  l   lo***
}

🍺输出

☕注意

去掉前后的空格，中间的空格保留。

比如搜索东西的时候，可能前后会不小心输入空格，这时候它会自动将前后空格去除。

11、intern()

🔥public String intern()：结果在常量池中共享。

public native String intern();

🌱案例代码

@Test
public void test11(){
    String s1="hello";
    String s2="helloworld";
    String s3=s1+"world";   //通过查看字节码文件发现，调用了StringBuilder的toString()方法-->new String()
    String s4=s3.intern();	//intern:返回的是字符串常量池中字面量的地址
    System.out.println(s2==s4);	//true
}

🍺输出

☕注意

调用此方法的时候，会在字符串常量池中将字面量返回。

若存在就返回，不存在就生成一个再返回。

12、总代码

🌱系列1–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest1
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 11:39
 */
public class StringMethodTest1 {
    //1.boolean isEmpty()：判断字符串是否为空 (若空则true，非空则false)
    @Test
    public void test1(){
        String s1="";
        String s2=new String();
        String s3=new String("");

        String s5="hello";

        System.out.println(s1.isEmpty());   //true
        System.out.println(s2.isEmpty());   //true
        System.out.println(s3.isEmpty());   //true

        System.out.println(s5.isEmpty());   //false

        /*String s4=null;
        System.out.println(s4.isEmpty());   //报空指针异常*/
    }

    //2.int length()：返回字符串的长度 (char型数组的长度)
    @Test
    public void test2(){
        String s1="hello";
        System.out.println(s1.length());    //5
    }

    //3.String concat(xx)：拼接 (将调用这个方法的字符串和xx拼接在一起)
    @Test
    public void test3(){
        String s1="hello";
        System.out.println(s1.concat("world")); //helloworld
    }

    //4.boolean equals(Object obj)：比较字符串是否相等，区分大小写
    @Test
    public void test4(){
        String s1="hello";
        String s2=new String("hello");
        String s3=new String("Hello");

        System.out.println(s1.equals(s2));  //true
        System.out.println(s1.equals(s3));  //false
        System.out.println(s2.equals(s3));  //false
    }

    //5.boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
    @Test
    public void test5(){
        String s1="hello";
        String s3=new String("Hello");

        System.out.println(s1.equalsIgnoreCase(s3));  //true
        System.out.println(s1.equals(s3));  //false

    }

    //6.int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
    @Test
    public void test6(){
        String s1="abcd";
        String s2="adef";
        System.out.println(s1.compareTo(s2));   //b-d=98-100=-2

        String s3="abcd";
        String s4="abcd";
        System.out.println(s3.compareTo(s4));   //0

        String s5="abcd";
        String s6="aBcd";
        System.out.println(s5.compareTo(s6));   //b-B=98-66=32
    }

    //7.int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
    @Test
    public void test7(){
        String s1="abcd";
        String s2="adef";
        System.out.println(s1.compareToIgnoreCase(s2));   //b-d=98-100=-2

        String s5="abcd";
        String s6="aBcd";
        System.out.println(s5.compareToIgnoreCase(s6));   //0

        String s7="张ab";
        String s8="李cd";
        System.out.println(s7.compareTo(s8));   //-2094
    }

    //8.String toLowerCase()：将字符串中大写字母转为小写
    @Test
    public void test8(){
        String s1="Hello-中国-123";
        System.out.println(s1.toLowerCase());   //hello-中国-123
    }

    //9.String toUpperCase()：将字符串中小写字母转为大写
    @Test
    public void test9(){
        String s1=new String("Hello-你好-567");
        System.out.println(s1.toUpperCase());   //HELLO-你好-567
    }

    //10.String trim()：去掉字符串前后空白符
    @Test
    public void test10(){
        String s1="  he  l   lo     ";
        System.out.println("***"+s1.trim()+"***");  //***he  l   lo***
    }

    //11.public String intern()：结果在常量池中共享
    @Test
    public void test11(){
        String s1="hello";
        String s2="helloworld";
        String s3=s1+"world";   //通过查看字节码文件发现，调用了StringBuilder的toString()方法-->new String()
        String s4=s3.intern(); //intern:返回的是字符串常量池中字面量的地址
        System.out.println(s2==s4);    //true
    }
}

（2）系列2：查找

1、contains(xx)

🔥boolean contains(xx)：是否包含xx。

public boolean contains(CharSequence s) {
    return indexOf(s.toString()) > -1;
}

🌱案例代码

//1.boolean contains(xx)：是否包含xx (判断当前字符串是否包含xx，返回布尔类型的值)
@Test
public void test1(){
    String s1="雨翼轻尘";
        
    System.out.println(s1.contains("轻尘"));      //true
    System.out.println(s1.contains("尘轻"));      //false
    System.out.println(s1.contains("轻  尘"));    //false
    System.out.println(s1.contains("yuyi"));      //false
}

🍺输出

☕注意

汉字换了顺序也不行。

2、indexOf(xx)

🔥int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1。

public int indexOf(String str) {
    return indexOf(str, 0);
}

🌱案例代码

//2.int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
@Test
public void test2(){
    String s1="欢迎来到雨翼轻尘的博客";
    System.out.println(s1.indexOf("雨翼"));   //当前字符串在s1中首次出现的索引位置，即：4
    System.out.println(s1.indexOf("博主"));   //当前字符串在s1中没有，返回-1
}

🍺输出

☕注意

首先要确定该字符串中确实包含了xx，才能查找索引位置，返回的是xx第一次出现的索引位置。

一旦没有找到xx，就会返回-1。（索引最小的是0，没有找到就会取前一个，就是-1）

数据库里面的索引是从1开始的，要是查找没有找到，就会取前一个，返回的是0。

3、indexOf(String str, int fromIndex)

🔥int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

public int indexOf(String str, int fromIndex) {
    return indexOf(value, 0, value.length,
                   str.value, 0, str.value.length, fromIndex);
}

🌱案例代码

//3.int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
@Test
public void test3(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.indexOf("博客",1)); //从第1个索引的位置(迎)开始找，返回"博客"首次出现的位置，即：9
}

🍺输出

☕注意

indexOf(xx)：从前往后找当前字符串中xx，返回第一次出现的索引位置。

indexOf(String str, int fromIndex)：从指定索引开始找字符串xx，返回第一次出现的索引位置。

比如：

@Test
public void test3(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";

    System.out.println(s1.indexOf("欢迎"));   //首次出现“欢迎”的位置，即：0
    System.out.println(s1.indexOf("欢迎",1)); //从第1个位置开始，首次出现“欢迎”的位置，即：11
}

输出：

画个图瞅瞅：

4、lastIndexOf(xx)

🔥int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1。

public int lastIndexOf(String str) {
    return lastIndexOf(str, value.length);
}

🌱案例代码

//4.int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
@Test
public void test4(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.lastIndexOf("欢迎"));   //从后往前找(就是最后一次出现的位置)，即：11
}

🍺输出

☕注意

lastIndexOf(xx)从后往前找(就是最后一次出现的位置)，索引还是从0开始（从前往后的顺序）。

虽然是反向搜索，但还是要从头开始数（索引为0的地方开始数）。

5、lastIndexOf(String str, int fromIndex)

🔥int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

public int lastIndexOf(String str, int fromIndex) {
    return lastIndexOf(value, 0, value.length,
                       str.value, 0, str.value.length, fromIndex);
}

🌱案例代码

//5.int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
@Test
public void test5(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.lastIndexOf("欢迎",2)); //从索引为2的位置(来)，往前面找“欢迎”，即：0
}

🍺输出

☕注意

lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1。

lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

比如：

@Test
public void test5(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";

    System.out.println(s1.lastIndexOf("欢迎"));   //从后往前找，第一次出现“欢迎”的索引为11
    System.out.println(s1.lastIndexOf("欢迎",3)); //从索引号为3的位置往前找，第一次出现“欢迎”的索引号为0
}

输出：

画个图瞅瞅：

6、总代码

🌱系列2–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest2
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 14:42
 */
public class StringMethodTest2 {
    //1.boolean contains(xx)：是否包含xx (判断当前字符串是否包含xx，返回布尔类型的值)
    @Test
    public void test1(){
        String s1="雨翼轻尘";

        System.out.println(s1.contains("轻尘"));      //true
        System.out.println(s1.contains("尘轻"));      //false
        System.out.println(s1.contains("轻  尘"));    //false
        System.out.println(s1.contains("yuyi"));    //false
    }

    //2.int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
    @Test
    public void test2(){
        String s1="欢迎来到雨翼轻尘的博客";
        System.out.println(s1.indexOf("雨翼"));   //当前字符串在s1中首次出现的索引位置，即：4
        System.out.println(s1.indexOf("博主"));   //当前字符串在s1中没有，返回-1
    }

    //3.int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
    @Test
    public void test3(){
        //        String s1="欢迎来到雨翼轻尘的博客欢迎";
        //        System.out.println(s1.indexOf("博客",1)); //从第1个索引的位置(迎)开始找，返回"博客"首次出现的位置，即：9

        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.indexOf("欢迎"));   //首次出现“欢迎”的位置，即：0
        System.out.println(s1.indexOf("欢迎",1)); //从第1个位置开始，首次出现“欢迎”的位置，即：11
    }

    //4.int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
    @Test
    public void test4(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.lastIndexOf("欢迎"));   //从后往前找(就是最后一次出现的位置)，即：11
    }

    //5.int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
    @Test
    public void test5(){
        //        String s1="欢迎来到雨翼轻尘的博客欢迎";
        //        System.out.println(s1.lastIndexOf("欢迎",2)); //从索引为2的位置(来)，往前面找“欢迎”，即：0

        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.lastIndexOf("欢迎"));   //从后往前找，第一次出现“欢迎”的索引为11
        System.out.println(s1.lastIndexOf("欢迎",3)); //从索引号为3的位置往前找，第一次出现“欢迎”的索引号为0
    }
}

（3）系列3：字符串截取

1、substring(int beginIndex)

🔥String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

🌱案例代码

//1.String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
@Test
public void test1(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.substring(8));    //取当前字符串的子串，从8开始取一直到最后，即：的博客欢迎
}

🍺输出

☕注意

substring在底层返回了一个新new的字符串。

如下：

2、substring(int beginIndex, int endIndex)

🔥String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
    : new String(value, beginIndex, subLen);
}

🌱案例代码

//2.String substring(int beginIndex, int endIndex):从begin的索引一直取到end的索引，不包含end
@Test
public void test2(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.substring(4,8));  //[4,8)，索引从第4个位置取到第7个位置，即：雨翼轻尘
}

🍺输出

☕注意

在Java中，凡是看到从一个位置开始，到某一个位置结束。就是这种索引的问题，都是左闭右开。

注意有的时候是从一个位置开始，一共几个长度（不是到某一个位置结束），这样就是另一种情况了。

3、总代码

🌱系列3–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest3
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 16:53
 */
public class StringMethodTest3 {
    //1.String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
    @Test
    public void test1(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.substring(8));    //取当前字符串的子串，从8开始取一直到最后，即：的博客欢迎
    }

    //2.String substring(int beginIndex, int endIndex):从begin的索引一直取到end的索引，不包含end
    @Test
    public void test2(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.substring(4,8));  //[4,8)，索引从第4个位置取到第7个位置，即：雨翼轻尘
    }
}

（4）系列4：和字符/字符数组相关

1、charAt(index)

🔥char charAt(index)：返回[index]位置的字符。

public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

🌱案例代码

//1.char charAt(index)：返回[index]位置的字符
@Test
public void test1(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.charAt(2));   //返回第2个位置的字符，即：来
}

🍺输出

☕注意

从左往右，索引号从0开始。

2、toCharArray()

🔥char[] toCharArray()：将此字符串转换为一个新的字符数组返回。

public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);
    return result;
}

🌱案例代码

//2.char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
@Test
public void test2(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    char[] arr=s1.toCharArray();
    //输出
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

🍺输出

在这里插入图片描述

3、valueOf(char[] data)

🔥static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String。

public static String valueOf(char data[]) {
    return new String(data);
}

🌱案例代码

//3.static String valueOf(char[] data)  ：返回指定数组中表示该字符序列的 String
@Test
public void test3(){
    String s1 = String.valueOf(new char[]{'a', 'b', 'c'});  //将等号后面的char型数组转化为字符串s1 (新new了一个)
    System.out.println(s1);
}

🍺输出

☕注意

static修饰的，拿类去调用。

valueOf前面也说过，可以看作把基本数据类型转化成字符串的一种方法。如下：

4、valueOf(char[] data, int offset, int count)

🔥static String valueOf(char[] data, int offset, int count) ：返回指定数组中表示该字符序列的 String。

public static String valueOf(char data[], int offset, int count) {
    return new String(data, offset, count);
}

🌱案例代码

//4.static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
@Test
public void test4(){
    char[] arr=new char[]{'a', 'b', 'c'};
    String s1 = String.valueOf(arr,1,2);    //在arr数组中，从索引为1的位置开始，长度为2.即：bc
    System.out.println(s1);
}

🍺输出

☕注意

5、copyValueOf(char[] data)

🔥static String copyValueOf(char[] data)：返回指定数组中表示该字符序列的 String。

public static String copyValueOf(char data[]) {
    return new String(data);
}

🌱案例代码

//5.static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
@Test
public void test5(){
    String s1 = String.copyValueOf(new char[]{'a', 'b', 'c'});  //将等号后面的char型数组转化为字符串s1 (新new了一个)
    System.out.println(s1);
}

🍺输出

☕注意

valueOf(char[] data)和copyValueOf(char[] data)，若处理的都是char型数组，其实作用是一样的。返回字符串的复制品，就是再整一份字符串。

既然是新new的，那么地址值肯定不相等。

比如：

@Test
public void test5(){
    String s1 = String.copyValueOf(new char[]{'a', 'b', 'c'});  //将等号后面的char型数组转化为字符串s1 (新new了一个)
    System.out.println(s1); //abc

    String s2=String.copyValueOf(new char[]{'a', 'b', 'c'});
    System.out.println(s2); //abc

    System.out.println(s1==s2);	//false
}

输出：

6、copyValueOf(char[] data, int offset, int count)

🔥static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String。

public static String copyValueOf(char data[], int offset, int count) {
    return new String(data, offset, count);
}

🌱案例代码

//6.static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
@Test
public void test6(){
    char[] arr=new char[]{'a', 'b', 'c','d'};
    String s1 = String.copyValueOf(arr,1,2);    //在arr数组中，从索引为1的位置开始，长度为2.即：bc
    System.out.println(s1); //bc
}

🍺输出

☕注意

7、总代码

🌱系列4–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest4
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 17:09
 */
public class StringMethodTest4 {
    //1.char charAt(index)：返回[index]位置的字符
    @Test
    public void test1(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.charAt(2));   //返回第2个位置的字符，即：来
    }

    //2.char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
    @Test
    public void test2(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        char[] arr=s1.toCharArray();
        //输出
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    //3.static String valueOf(char[] data)  ：返回指定数组中表示该字符序列的 String
    @Test
    public void test3(){
        String s1 = String.valueOf(new char[]{'a', 'b', 'c'});  //将等号后面的char型数组转化为字符串s1 (新new了一个)
        System.out.println(s1); //abc
    }

    //4.static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
    @Test
    public void test4(){
        char[] arr=new char[]{'a', 'b', 'c'};
        String s1 = String.valueOf(arr,1,2);    //在arr数组中，从索引为1的位置开始，长度为2.即：bc
        System.out.println(s1); //bc
    }

    //5.static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
    @Test
    public void test5(){
        String s1 = String.copyValueOf(new char[]{'a', 'b', 'c'});  //将等号后面的char型数组转化为字符串s1 (新new了一个)
        System.out.println(s1); //abc

        String s2=String.copyValueOf(new char[]{'a', 'b', 'c'});
        System.out.println(s2); //abc

        System.out.println(s1==s2); //false
    }

    //6.static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
    @Test
    public void test6(){
        char[] arr=new char[]{'a', 'b', 'c','d'};
        String s1 = String.copyValueOf(arr,1,2);    //在arr数组中，从索引为1的位置开始，长度为2.即：bc
        System.out.println(s1); //bc
    }

}

（5）系列5：开头与结尾

1、startsWith(xx)

🔥boolean startsWith(xx)：测试此字符串是否以指定的前缀开始。

public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}

🌱案例代码

//1.boolean startsWith(xx)：测试此字符串是否以指定的前缀开始
@Test
public void test1(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.startsWith("欢迎"));    //是以“欢迎”开头的吗？是。输出true
    System.out.println(s1.startsWith("雨翼"));    //不是以“雨翼”开头的，输出false
}

🍺输出

☕注意

参数里面的字符个数没有限制，写一个“欢”或者写两个“欢迎”都是可以的。

只要判断是以这几个字符开头的，输出就是true。

2、startsWith(String prefix, int toffset)

🔥boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

public boolean startsWith(String prefix, int toffset) {
    char ta[] = value;
    int to = toffset;
    char pa[] = prefix.value;
    int po = 0;
    int pc = prefix.value.length;
    // Note: toffset might be near -1>>>1.
    if ((toffset < 0) || (toffset > value.length - pc)) {
        return false;
    }
    while (--pc >= 0) {
        if (ta[to++] != pa[po++]) {
            return false;
        }
    }
    return true;
}

🌱案例代码

//2.boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
@Test
public void test2(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.startsWith("欢迎",2));  //从索引为2的地方开始，是以“欢迎”开头的吗？不是，输出false
    System.out.println(s1.startsWith("雨翼",4));  //从索引为4的地方开始，是以“雨翼”开头的吗？是，输出true
}

🍺输出

3、endsWith(xx)

🔥boolean endsWith(xx)：测试此字符串是否以指定的后缀结束。

public boolean endsWith(String suffix) {
    return startsWith(suffix, value.length - suffix.value.length);
}

🌱案例代码

//3.boolean endsWith(xx)：测试此字符串是否以指定的后缀结束
@Test
public void test3(){
    String s1="欢迎来到雨翼轻尘的博客欢迎";
    System.out.println(s1.endsWith("欢迎"));  //以“欢迎”结束吗？是，输出true
    System.out.println(s1.endsWith("博客欢迎"));  //以“博客欢迎”结束吗？是，输出true
}

🍺输出

4、总代码

🌱系列5–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest5
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 17:47
 */
public class StringMethodTest5 {
    //1.boolean startsWith(xx)：测试此字符串是否以指定的前缀开始
    @Test
    public void test1(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.startsWith("欢迎"));    //是以“欢迎”开头的吗？是。输出true
        System.out.println(s1.startsWith("雨翼"));    //不是以“雨翼”开头的，输出false
    }

    //2.boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    @Test
    public void test2(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.startsWith("欢迎",2));  //从索引为2的地方开始，是以“欢迎”开头的吗？不是，输出false
        System.out.println(s1.startsWith("雨翼",4));  //从索引为4的地方开始，是以“雨翼”开头的吗？是，输出true
    }

    //3.boolean endsWith(xx)：测试此字符串是否以指定的后缀结束
    @Test
    public void test3(){
        String s1="欢迎来到雨翼轻尘的博客欢迎";
        System.out.println(s1.endsWith("欢迎"));  //以“欢迎”结束吗？是，输出true
        System.out.println(s1.endsWith("博客欢迎"));  //以“博客欢迎”结束吗？是，输出true
    }

}

（6）系列6：替换

1、replace(char oldChar, char newChar)

🔥String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。不支持正则。

public String replace(char oldChar, char newChar) {
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        char[] val = value; /* avoid getfield opcode */

        while (++i < len) {
            if (val[i] == oldChar) {
                break;
            }
        }
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            return new String(buf, true);
        }
    }
    return this;
}

🌱案例代码

//1.String replace(char oldChar, char newChar):用后面的字符newChar替换前面的字符oldChar
@Test
public void test1(){
    String s1="hello";
    String s2 = s1.replace('l', 'w');   //将s1的l换成w，s1没有变化，是返回值变化了
    System.out.println(s1); //s1没有变，输出hello
    System.out.println(s2); //s2是变化之后的，输出hewwo
}

🍺输出

2、replace(CharSequence target, CharSequence replacement)

🔥String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
        this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

🌱案例代码

//2.String replace(CharSequence target, CharSequence replacement):可以换字符串
@Test
public void test2(){
    String s1="hello";
    String s2 = s1.replace("ll", "edr");//可以替换字符串，而且可以换成多个字符
    System.out.println(s1); //s1没有变化，即：hello
    System.out.println(s2); //s2中，将s1的“ll”换成了"edr"，即：heedro
}

🍺输出

☕注意

CharSequence：字符序列，是一个接口。

String实现了CharSequence接口，如下：

3、replaceAll(String regex, String replacement)

🔥String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

🌱案例代码

@Test
public void test1(){
    String str1 = "hello244world.java;887";
    //把其中的非字母去掉
    str1 = str1.replaceAll("[^a-zA-Z]", "");
    System.out.println(str1);

    String str2 = "12hello34world5java7891mysql456";
    //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
    String string = str2.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
    System.out.println(string);

}

☕注意

regex：regular规则+expression表达式，即：正则表达式，就是有规则要求的字符串。（比如经常设置密码的时候，要求6位数，包含大小写等要求，校验就使用的是正则表达式）

推荐一个学习正则表达式的网站：https://codejiaonang.com/#/

4、replaceFirst(String regex, String replacement)

🔥String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

5、总代码

🌱系列6–整体代码

package String;

import org.junit.Test;

/**
 * ClassName: StringMethodTest6
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/14 0014 20:41
 */
public class StringMethodTest6 {
    //1.String replace(char oldChar, char newChar):用后面的字符newChar替换前面的字符oldChar
    @Test
    public void test1(){
        String s1="hello";
        String s2 = s1.replace('l', 'w');   //将s1的l换成w，s1没有变化，是返回值变化了
        System.out.println(s1); //s1没有变，输出hello
        System.out.println(s2); //s2是变化之后的，输出hewwo
    }

    //2.String replace(CharSequence target, CharSequence replacement):可以换字符串
    @Test
    public void test2(){
        String s1="hello";
        String s2 = s1.replace("ll", "edr");//可以替换字符串，而且可以换成多个字符
        System.out.println(s1); //s1没有变化，即：hello
        System.out.println(s2); //s2中，将s1的“ll”换成了"edr"，即：heedro
    }
}