【Java】String 类

一、常用方法

1、字符串构造

String类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {
    // 使用常量串构造
    String str1 = "frost cold";
    System.out.println(str1);

    // 直接newString对象
    String str2 = new String("frost cold");
    System.out.println(str2);

    // 使用字符数组进行构造
    char[] ch = {'f', 'r', 'o', 's', 't', ' ', 'c', 'o', 'l', 'd'};
    String str3 = new String(ch);
    System.out.println(str3);
}

其他方法需要用到时，大家参考Java在线文档：String官方文档

【注意】
（1）String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

（2）在Java中""引起来的也是String类型对象。

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

注：数组类型求长度 arr.length，后面不需要()

2、String字符串判空

isEmpty()：字符串为零返回true，非零返回false

public static void main(String[] args) {
    String s1 = "frost cold";
    String s2 = "";
    String s3 = " ";
    System.out.println(s1.isEmpty()); // false
    System.out.println(s2.isEmpty()); // true
    System.out.println(s3.isEmpty()); // false
}

3、String对象的比较

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

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

boolean equals(Object anObject) 方法：按照字典序比较
字典序：字符大小的顺序
如果没有重写父类Object中equals方法，Object中equals默认按照==比较；String类重写了父类Object中equals方法，则比较两个变量中存储的值是否相同。按照如下规则进行比较，比如： s1.equals(s2)

public boolean equals(Object anObject) {
    // 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
    if (this == anObject) {
        return true;
    }
    
    // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
    if (anObject instanceof String) {
        // 将anObject向下转型为String类型对象
        String anotherString = (String)anObject;
        int n = value.length;
        // 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // 4. 按照字典序，从前往后逐个字符进行比较
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello");
    
    // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
    System.out.println(s1 == s2); // false
    System.out.println(s1 == s3); // false
    // equals比较：String对象中的逐个字符
    // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
    System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false
}

int compareTo(String s) 方法：按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
（1）先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
（2）如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

public static void main(String[] args) {
    String s1 = "abc";
    String s2 = "ad";
    String s3 = "abc";
    String s4 = "abcdefg";

    System.out.println(s1.compareTo(s2)); // 不同返回字符差值-2
    System.out.println(s1.compareTo(s3)); // 相同返回0
    System.out.println(s1.compareTo(s4)); // 前k个字符完全相同,返回长度差值-4
}

int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

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("aBcdefg");

    System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
    System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
    System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值-4
}

4、字符串查找

char charAt(int index)：返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常

public static void main(String[] args) {
    String str = "frost cold";
    char ch = str.charAt(3);
    char ch2 = str.charAt(10);
    System.out.println(ch); // 输出下标为3的字符s
    System.out.println(ch2); // StringIndexOutOfBoundsException
}

int indexOf(char ch)：返回ch第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "frost cold";
    int ch = str.indexOf('o');
    int ch2 = str.indexOf('a');
    System.out.println(ch); // o在下标为2和7的地方都出现了，输出第一次出现的位置2
    System.out.println(ch2); // str中没有a,输出-1
}

int indexOf(int ch, int fromIndex)：从fromIndex位置开始找ch第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "frost cold";
    int ch = str.indexOf('o', 7);
    int ch2 = str.indexOf('o', 8);
    System.out.println(ch); // 输出从下标7开始第一次出现的位置7
    System.out.println(ch2); // 下标从7开始没有o,输出-1
}

int indexOf(String str)：返回str第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "this is a potential bloggers";
    int ch = str.indexOf("is");
    int ch2 = str.indexOf("ab");
    System.out.println(ch); // is在下标为2和5的地方都出现了，输出第一次出现的位置2
    System.out.println(ch2); // str中没有ab,输出-1
}

int indexOf(String str, int fromIndex)：从fromIndex位置开始找str第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "this is a potential bloggers";
    int ch = str.indexOf("is", 5);
    int ch2 = str.indexOf("is", 8);
    System.out.println(ch); // 输出从5下标开始第一次出现is的位置5
    System.out.println(ch2); // 从8下标开始没有is,输出-1
}

int lastIndexOf(int ch)：从后往前找，返回ch第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "frost cold";
    int ch = str.lastIndexOf('o');
    int ch2 = str.indexOf('a');
    System.out.println(ch); // 从后往前找输出第一次出现的位置7
    System.out.println(ch2); // str中没有a,输出-1
}

int lastIndexOf(int ch, int fromIndex)：从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "frost cold";
    int ch = str.lastIndexOf('o', 5);
    int ch2 = str.lastIndexOf('o', 1);
    System.out.println(ch); // 从下标5开始找，从后往前找输出第一次出现的位置2
    System.out.println(ch2); // 从下标1开始找，从后往前找没有o,输出-1
}

int lastIndexOf(String str)：从后往前找，返回str第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "this is a potential bloggers";
    int ch = str.lastIndexOf("is");
    int ch2 = str.lastIndexOf("ab");
    System.out.println(ch); // is在下标为2和5的地方都出现了，从后往前找输出第一次出现的位置5
    System.out.println(ch2); // 从后往前找str中没有ab,输出-1
}

int lastIndexOf(String str, int fromIndex)：从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

public static void main(String[] args) {
    String str = "this is a potential bloggers";
    int ch = str.lastIndexOf("is", 8);
    int ch2 = str.lastIndexOf("is", 4);
    System.out.println(ch); // 从下标8开始找，从后往前找输出第一次出现is的位置5
    System.out.println(ch2); // 从下标4开始找，从后往前找输出第一次出现is的位置2
}

5、转化

5.1 数值和字符串转化

class Student {
    private String name;
    private int age;

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

    public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("frost cold", 18));

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        
        System.out.println("=================================");
        
        // 字符串转数字
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1+1);
        System.out.println(data2+1);
    }
}

运行结果：

1234
12.34
true
demo2.Student@1b6d3586
=================================
1235
13.34

5.2 大小写转换

public static void main(String[] args) {
    String str1 = "frost cold";
    String str2 = "FROST COLD";

    // 小写转大写
    System.out.println(str1.toUpperCase()); // FROST COLD
    // 大写转小写
    System.out.println(str2.toLowerCase()); // frost cold
}

5.3 字符串转数组

public static void main(String[] args) {
    String str = "frost cold";
    char[] ch = str.toCharArray();
    for (char c : ch) {
        System.out.print(c);
    } // frost cold
    System.out.println();
    // 数组转字符串
    String str2 = new String(ch);
    System.out.println(str2); // frost cold
}

运行结果：

frost cold
frost cold

5.4 格式化

public static void main(String[] args) {
    String s = String.format("%d-%d-%d", 2024, 3, 10);
    System.out.println(s); // 2024-3-10

    String s2 = String.format("%d.%d.%d", 2024, 2, 27);
    System.out.println(s2); // 2024.2.27

    String s3 = String.format("%d年%d月%d日", 2024, 3, 10);
    System.out.println(s3); // 2024年3月10日
}

运行结果：

2024-3-10
2024.2.27
2024年3月10日

6、字符串替换

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

String replaceAll(String regex, String replacement)：替换所有的指定内容，replace 与 replaceAll 的功能一样

public static void main(String[] args) {
    String str = "abcdabcdababbbbbbab";
    String strReplace = str.replace("ab", "xy");
    String strReplace2 = str.replaceAll("ab", "xy");
    
    System.out.println(strReplace); // xycdxycdxyxybbbbbxy
    System.out.println(strReplace2); // xycdxycdxyxybbbbbxy
}

运行结果：

xycdxycdxyxybbbbbxy
xycdxycdxyxybbbbbxy

String replaceFirst(String regex, String replacement)：替换首个内容

public static void main(String[] args) {
    String str = "abcdabcdababbbbbbab";
    String strReplace = str.replaceFirst("ab", "xy");
    
    System.out.println(strReplace); // xycdabcdababbbbbbab
}

7、字符串拆分

String[] split(String regex)：将字符串全部拆分

public static void main(String[] args) {
    String str = "frost cold";
    String[] str2 = str.split(" ");
    for (String e : str2) {
        System.out.println(e);
    }
}

运行结果：

frost
cold

注意有些特殊字符作为分割符可能无法正确切分，需要加上转义：

public static void main(String[] args) {
    String str = "192.168.1.1";
    String[] str2 = str.split("\\.");
    for (String e : str2) {
        System.out.println(e);
    }
}

运行结果：

192
168
1
1

String[] split(String regex, int limit)：将字符串以指定的格式，拆分为limit组

public static void main(String[] args) {
    String str = "frost cold frost cold";
    String[] str2 = str.split(" ", 3);
    for (String e : str2) {
        System.out.println(e);
    }
}

运行结果：

frost
cold
frost cold

注意事项：
（1）字符 “|”，“*”，“+” 都得加上转义字符，前面加上 “\” .
（2）而如果是 “” ，那么就得写成 “\\” .
（3）如果一个字符串中有多个分隔符，可以用 “|” 作为连字符.

public static void main(String[] args) {
    String str = "name=frostcold&age=18";
    String[] str2 = str.split("=|&");
    for (String e : str2) {
        System.out.println(e);
    }
}

运行结果：

name
frostcold
age
18

8、字符串截取

String substring(int beginIndex)：从指定索引截取到结尾

public static void main(String[] args) {
    String str = "frost cold";
    String str2 = str.substring(3);
    System.out.println(str2); // st cold
}

String substring(int beginIndex, int endIndex)：截取部分内容

public static void main(String[] args) {
    String str = "frost cold";
    String str2 = str.substring(2, 7); // 截取内容为所选索引前闭后开部分[2,7),包含2下标，不包含7下标
    System.out.println(str2);
}

运行结果：

ost c

9、其他操作方法

String trim()：去掉字符串中的左右空格,保留中间空格

public static void main(String[] args) {
    String str = "   frost cold   ";
    System.out.println("[" + str + "]");
    System.out.println("[" + str.trim() + "]");
}

运行结果：

[   frost cold   ]
[frost cold]

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

10、字符串常量池

10.1 创建对象的思考

public static void main(String[] args) {
    String str1 = "frost";
    String str2 = "frost";
    String str3 = new String("frost");
    String str4 = new String("frost");

    System.out.println(str1 == str2); // true
    System.out.println(str1 == str3); // false
    System.out.println(str3 == str4); // false
}

上述程序创建方式类似，为什么s1和s2引用的是同一个对象，而s3和s4不是呢？

在Java程序中，类似于：1， 2， 3，3.14，“frost” 等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。

“池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …

为了节省存储空间以及程序的运行效率，Java中引入了：
（1）Class文件常量池：每个 .Java 源文件编译后生成 .Class 文件中会保存当前类中的字面常量以及符号信息
（2）运行时常量池：在 .Class 文件被加载时，.Class 文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份
（3）字符串常量池

10.2 字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构)，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

JDK版本	字符串常量池位置	大小设置
Java6	(方法区)永久代	固定大小：1009
Java7	堆中	可设置，没有大小限制，默认大小：60013
Java8	堆中	可设置，有范围限制，最小是1009

注意：
（1）在JVM中字符串常量池只有一份，是全局共享的
（2）刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多
（3）当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中
（4）字符串常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加

10.3 再谈String对象创建

（1）直接使用字符串常量进行赋值

public static void main(String[] args) {
    String s1 = "frost·";
    String s2 = "frost";
    System.out.println(s1 == s2); // true
}

在字节码文件加载时，先要将 .Class 文件中的常量池加载到内存中称为运行时常量池，此时也会将 "hello" 字符串保存到字符串常量池中。

（2）通过new创建String类对象

public static void main(String[] args) {
    String s1 = "frost";
    String s2 = "frost";
    String s3 = new String("cold");
    String s4 = new String("cold");

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

结论：只要是new的对象，都是唯一的。
通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的字符串对象通过 intern 方式添加进字符串常量池中。

（3）intern 方法
intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

public static void main(String[] args) {
    char[] ch = new char[]{'a', 'b', 'c'};
    String s1 = new String(ch); // s1对象并不在常量池中
    s1.intern(); // s1.intern()调用之后，会将s1对象的引用放入到常量池中
    String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
    System.out.println(s1 == s2); // true
}

如果不调用 s1.intern()，则输出 false，调用则输出 true。

面试题：请解释String类中两种对象实例化的区别
JDK1.8中

1. String str = “hello”
   只会开辟一块堆内存空间，保存在字符串常量池中，然后 str 共享常量池中的String对象
2. String str = new String(“hello”)
   会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟的String对象赋值。
3. String str = new String(new char[]{‘h’, ‘e’, ‘l’, ‘l’, ‘o’})
   现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到String对象中

11、字符串的不可变性

String是一种不可变对象，字符串中的内容是不可改变。字符串不可被修改，是因为：
String类在设计时就是不可改变的，String类实现描述中已经说明了

String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

（1）String类被 final 修饰，表明该类不能被继承
（2）value 被 final 修饰，表明 value 自身的值不能改变，即：不能引用其它字符数组，但是其引用空间中的内容可以修改。

所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

12、字符串修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

public static void main(String[] args) {
	String str = "frost";
	str += " cold";
	System.out.println(str); // 输出：frost cold
}

上述代码相当于如下代码：

public static void main(String[] args) {
    String str = "frost"; // 第1个:str对象,放"cols"
    StringBuilder sb = new StringBuilder(); // 第2个:sb对象
    sb.append(str);
    sb.append("cold"); // 第3个:产生"cold"对象
    str = sb.toString(); // 第4个:toString()返回值new了一个对象
    System.out.println(str); // 输出：frost cold
}

上述代码共产生4个对象。

public static void main2(String[] args) {
    String str = "frost";
    str = str + " cold";
    str = str + "!!!";
    System.out.println(str); // 输出：frost cold!!!
}

若不考虑 StringBuilder 和 toString() 产生的对象，则上述代码共产生5个对象：（1）“frost”（2）" cold"（3）“frost cold”（4）“!!!”（5）“frost cold!!!”

二、StringBuilder和StringBuffer

1、StringBuilder的介绍

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法，其它需要用到了大家可参阅 StringBuilder在线文档

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。

String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

• String变为StringBuilder：利用StringBuilder的构造方法或append()方法
• StringBuilder变为String：调用toString()方法

public static void main(String[] args) {
    // String变为StringBuilder：利用StringBuilder的构造方法
    String s = "frost";
    StringBuilder sb = new StringBuilder(s);

    // StringBuilder变为String：调用toString()方法
    StringBuilder stringBuilder = new StringBuilder("cold");
    String str = stringBuilder.toString();
}

2、面试题

2.1 String、StringBuffer、StringBuilder的区别
（1）String的内容不可修改，StringBuffer与StringBuilder的内容可以修改。
（2）StringBuffer与StringBuilder大部分功能是相似的。
（3）StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作。

2.2 以下总共创建了多少个String对象（前提不考虑常量池之前是否存在）

String str = new String("ab"); // 会创建2个对象:(1)"ab"对象(2)new String对象

String str = new String("a") + new String("b"); // 会创建6个对象

三、String类oj

1、字符串中的第一个唯一字符

2、字符串最后一个单词的长度

3、验证回文串