《String类》 - 技术栈

一、定义与概述

二、创建字符串对象

[2.1 直接赋值](#2.1 直接赋值)

[2.2 使用构造函数](#2.2 使用构造函数)

三、字符串的不可变性

四、常用方法

[4.1 String对象的比较](#4.1 String对象的比较)

[4.1.1 ==比较是否引用同一个对象](#4.1.1 ==比较是否引用同一个对象)

[4.1.2 boolean equals(Object anObject)方法：按照字典序比较](#4.1.2 boolean equals(Object anObject)方法：按照字典序比较)

[4.1.3 int compareTo(String s)方法: 按照字典序进行比较](#4.1.3 int compareTo(String s)方法: 按照字典序进行比较)

[4.1.4 int compareToIgnoreCase(String str)方法：](#4.1.4 int compareToIgnoreCase(String str)方法：)

[4.2 字符串查找](#4.2 字符串查找)

[4.2 转化](#4.2 转化)

[4.3 字符串替换](#4.3 字符串替换)

[4.4 字符串拆分](#4.4 字符串拆分)

[4.5 字符串截取](#4.5 字符串截取)

[4.6 其他操作](#4.6 其他操作)

五、StringBuilder和StringBuffer

一、定义与概述

在Java中，Sting类是用来表示字符串的。字符串是一个字符序列，例如"Hello, World! "。String类位于 java.lang包中，这个包是Java语言的核心包之一，不需要显示导入就可以使用。

二、创建字符串对象

2.1 直接赋值

可以通过直接使用双引号来创建String对象，例如：String str = "Hello, World! " 。这种方式创建的字符串，在 Java 的字符串常量池中会检查是否已经存在相同内容的字符串。如果存在，就直接引用该字符串对象；如果不存在，则在常量池中创建一个新的字符串对象。
代码如下：

java 复制代码

public class Test1 {
    public static void main(String[] args) {
        String str = "Hello, World! ";
    }
}

2.2 使用构造函数

String()：创建一个空字符串对象。例如：String str1 = new String();

String(String original): 使用另一个字符串来创建新的字符串对象。String str2 = new String("Another Java String");

String(char[] value): 通过字符数组来创建字符串,例如：char[] chars = {'h','e','l','l','o'};

String str3 = new String(chars); 这里str3的值就是"hello"。

上述代码：

java 复制代码

public class Test1 {
    public static void main(String[] args) {
        String str = "Hello, World! ";
        String str1 = new String();
        String str2 = new String("Another Java String");
        char[] chars = {'h','e','l','l','o'};
        String str3 = new String(chars);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    }

输出：

三、字符串的不可变性

String类是不可变的（immutable）。这意味着一旦一个String对象被创建，它的值就不能被改变。例如：

java 复制代码

String str = "Java";
str = str + " is fun";

在这个例子中，看起来好像是改变了 str 的值，但实际上并不是。当执行 str = str + " is fun"这一行时，会创建一个新的 String 对象，其内容是 "Java is fun"，然后 str 变量会指向这个新创建的对象，原来的 "Java" 字符串对象仍然存在于内存中（如果没有其他引用指向它，它会在适当的时候被垃圾回收）。
String类在设计时就是不可改变的，String类实现描述中已经说明了

String类被final修饰，表明该类不能被继承

value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

四、常用方法

4.1 String对象的比较

4.1.1 ==比较是否引用同一个对象

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

java 复制代码

public class Test2 {
    public static void main(String[] args) {
        int a=100;
        int b=200;
        int c=200;
        // 对于基本类型变量，==比较两个变量中存储的值是否相同
        System.out.println(a == b); //false
        System.out.println(b == c); //true
        
        System.out.println("===========");
        // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1 == s2);   // false
        System.out.println(s2 == s3);   // false
        System.out.println(s1 == s4);   // true
    }
}

输出：

如果写成下面的形式，会输出true。因为s5 创建后 hello会被放入字符串常量池，就会认为s5 和s6引用的时同一对象。

java 复制代码

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5 == s6);

4.1.2 boolean equals(Object anObject)方法：按照字典序比较

String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后。

下面是String类重写equals方法的实现规则

java 复制代码

public class Test3 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("Hello");
        System.out.println(s1.equals(s2));//true
        System.out.println(s2.equals(s3));//false
    }
}

输出截图：

equals比较：String对象中的逐个字符。虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true 。s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false。

4.1.3 int compareTo(String s)方法: 按照字典序进行比较

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值。

如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值。

java 复制代码

public class Test4 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }
}

输出截图：

4.1.4 int compareToIgnoreCase(String str)方法：

与compareTo方式形同，但是忽略大小写。

java 复制代码

public class Test5 {
    public static void main(String[] args) {
        String s1 = new String("abC");
        String s2 = new String("Ac");
        String s3 = new String("Abc");
        String s4 = new String("ABcdef");
        System.out.println(s1.compareToIgnoreCase(s2));
        System.out.println(s1.compareToIgnoreCase(s3));
        System.out.println(s1.compareToIgnoreCase(s4));
    }
}

输出截图：

4.2 字符串查找

|--------------------------------------------|-------------------------------------------------------------|
| 方法 | 功能 |
| char charAt(int index) | 返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常。 |
| int indexOf(int ch) | 返回ch第一次出现的位置，没有返回-1 |
| int indexOf(int ch, int fromIndex) | 从fromIndex位置开始找ch第一次出现的位置，没有返回-1 |
| int indexOf(String str) | 返回str第一次出现的位置，没有返回-1 |
| int indexOf(String str, int fromIndex) | 从fromIndex位置开始找str第一次出现的位置，没有返回-1 |
| int lastIndexOf(int ch) | 从后往前找，返回ch第一次出现的位置，没有返回-1 |
| int lastIndexOf(int ch, int fromIndex) | 从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1 |
| int lastIndexOf(String str) | 从后往前找，返回str第一次出现的位置，没有返回-1 |
| int lastIndexOf(String str, int fromIndex) | 从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1 |

java 复制代码

public class Test6 {
    public static void main(String[] args) {
        String s = "abccbaabccba";
        System.out.println(s.charAt(2)); // 'c'
        System.out.println(s.indexOf('c'));// 2
        System.out.println(s.indexOf('a',2));// 5
        System.out.println(s.indexOf("aa"));// 5
        System.out.println(s.indexOf("cc",4));//8
        System.out.println(s.lastIndexOf('c'));//9
        System.out.println(s.lastIndexOf('b',11));//10
        System.out.println(s.lastIndexOf("aa"));//5
        System.out.println(s.lastIndexOf("aa",4));//-1
    }
}

运行截图：

4.2 转化

数值和字符串转化

java 复制代码

class Student{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "name=" + name +  ", age=" + age ;
    }
}
public class Test7 {
    public static void main(String[] args) {
        //其它类型转化成字符串
        String s1 = String.valueOf(1000);
        String s2 = String.valueOf('a');
        String s3 = String.valueOf(12.34);
        String s4 = String.valueOf(new Student("zhangsan",13));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        //字符串转化数字
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }
}

运行截图：

大小写转换

java 复制代码

public class Test8 {
    public static void main(String[] args) {
        String s1 = "abc";
        //小写转换大写
        System.out.println(s1.toUpperCase());
        String s2 = "ABC";
        //大写转换小写
        System.out.println(s2.toLowerCase());
    }
}

运行截图：

字符串转数组

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "hello";
        //字符串转化数组
        char[] chars = s.toCharArray();
        for (char ch : chars) {
            System.out.print(ch + " ");
        }
        System.out.println();
        //数组转换字符串
        char[] chars1 = {'w','o','r','l','d'};
        String s1 = new String(chars1);
        System.out.println(s1);
    }
}

运行截图：

格式化

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d",2024,11,29);
        System.out.println(s);
    }
}

运行截图：

4.3 字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

|-------------------------------------------------------|-----------|
| 方法 | 功能 |
| String replaceAll(String regex, String replacement) | 替换所有的指定内容 |
| String replaceFirst(String regex, String replacement) | 替换首个内容 |

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "abccba";
        System.out.println(s.replaceAll("c", "_"));
        System.out.println(s.replaceFirst("c","-"));
    }
}

运行截图：

注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。

4.4 字符串拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

|-------------------------------------------|----------------------|
| 方法 | 功能 |
| String[] split(String regex) | 将字符串全部拆分 |
| String[] split(String regex, int limit) | 将字符串以指定的格式，拆分为limit组 |

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "2024-11-29";
        String[] strings = s.split("-");
        for (String str :strings){
            System.out.print(str+" ");
        }
        System.out.println();
        String[] strings1 = s.split("-",2);
        for (String str : strings1){
            System.out.print(str+" ");
        }
    }
}

注意事项：

字符"|","*","+"都得加上转义字符，前面加上"\\".

而如果是"\"，那么就得写成"\\\\".

如果一个字符串中有多个分隔符，可以用"|"作为连字符.
多次拆分：

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "name=zhangsan&age=18";
        String[] strings = s.split("&");
        for (String str : strings){
            String[] strings1 = str.split("=");
            System.out.println(strings1[0]+" "+strings1[1]);
        }
    }
}

输出截图：

4.5 字符串截取

从一个完整的字符串之中截取出部分内容。

|------------------------------------------------|------------|
| 方法 | 功能 |
| String substring(int beginIndex) | 从指定索引截取到结尾 |
| String substring(int beginIndex, int endIndex) | 截取部分内容 |

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "abcdefghijk";
        System.out.println(s.substring(5));
        System.out.println(s.substring(3, 6));//左闭右开
    }
}

运行截图：

注意事项：

索引从0开始

注意前闭后开区间的写法, substring(3, 6) 表示包含 3 号下标的字符, 不包含 6 号下标

4.6 其他操作

|---------------|--------------------|
| 方法 | 功能 |
| String trim() | 去掉字符串中的左右空格,保留中间空格 |

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).

java 复制代码

public class Test9 {
    public static void main(String[] args) {
        String s = "          hello \t\t";
        System.out.println(s);
        System.out.println(s.trim());
    }
}

运行截图：

五、StringBuilder和StringBuffer

因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。

java 复制代码

public class Demo1 {
    public static void main(String[] args) {
        //获得毫秒级时间戳
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 10000; i++) {
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            stringBuilder.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

运行截图：

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的。

|------------------------------------------------------|--------------------------------------------------------------------------------------------------|
| 方法 | 功能 |
| StringBuff append(String str) | 在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量 |
| char charAt(int index) | 获取index位置的字符 |
| int length() | 获取字符串的长度 |
| int capacity() | 获取底层保存字符串空间总的大小 |
| void ensureCapacity(int mininmumCapacity) | 扩容 |
| void setCharAt(int index, char ch) | 将index位置的字符设置为ch |
| int indexOf(String str) | 返回str第一次出现的位置 |
| int indexOf(String str, int fromIndex) | 从fromIndex位置开始查找str第一次出现的位置 |
| int lastIndexOf(String str) | 返回最后一次出现str的位置 |
| int lastIndexOf(String str, int fromIndex) | 从fromIndex位置开始找str最后一次出现的位置 |
| StringBuff insert(int offset, String str) | 在offset位置插入：八种基类类型 & String类型 & Object类型数据 |
| StringBuffer deleteCharAt(int index) | 删除index位置字符 |
| StringBuffer delete(int start, int end) | 删除[start, end)区间内的字符 |
| StringBuffer replace(int start, int end, String str) | 将[start, end)位置的字符替换为str |
| String substring(int start) | 从start开始一直到末尾的字符以String的方式返回 |
| String substring(int start，int end) | 将[start, end)范围内的字符以String的方式返回 |
| StringBuffer reverse() | 反转字符串 |
| String toString() | 将所有字符按照String的方式返回 |

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。
注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

String变为StringBuilder: 利用StringBuilder的构造方法或append()方法

StringBuilder变为String: 调用toString()方法。