String类

String类

String类的重要性

String 类是 Java 语言中最基础、最常用的类之一，几乎所有 Java 程序的开发都离不开它。无论是用户输入的文本、程序中的常量、日志信息，还是网络传输的数据，大多以字符串形式存在。可以说，String 类是 Java 中数据传递和信息交互的 “通用语言”，是程序处理文本数据的基础载体。String 类与 Java 中的许多核心类紧密关联：与StringBuilder/StringBuffer配合实现高效字符串拼接，与集合类（如HashSet、HashMap）结合用于数据存储，与 IO 类（如BufferedReader）协作处理文本输入输出等。它是连接各种功能模块的 “纽带”

常用方法

字符串的构造

String类提供的构造方式有下面三种：

String str1 = "Hello";
String str2 = "World";

String str3 = new String("Hello");
String str4 = new String(new char[]{'W', 'o', 'r', 'l', 'd'});
String str5 = new String(byteArray); // 从字节数组构造

String str6 = "Hello" + " World"; // 编译期拼接，等效于直接赋值
String str7 = "Hello" + new String(" World"); // 运行时拼接
String str8 = str1.concat(" World"); // 使用concat()方法

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World");
String str9 = sb.toString(); // 转换为String对象

三种构造方式的区别：

注意⚠️：
1.String是引用数据类型，内部并不存储字符串本身
2.在java中“”引起来的也是String类对象

String对象比较

1.==运算符：比较对象引用（内存地址）
核心作用：判断两个字符串引用是否指向内存中的同一个对象（即比较内存地址是否相同）
底层原理：Java 中字符串存在常量池优化，相同字面量的字符串可能共享内存，而new创建的字符串则是独立对象

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");

System.out.println(s1 == s2); // true（常量池同一对象）
System.out.println(s1 == s3); // false（s1在常量池，s3在堆内存）
System.out.println(s3 == s4); // false（堆中两个独立对象）

注意事项：
不能用于比较字符串内容，仅能判断是否为同一个对象
常量池中的字符串复用可能导致==“看似正确”（如s1 == s2），但这是内存优化的结果，并非比较内容的正确方式

2.equals()方法：比较字符串内容
核心作用：判断两个字符串的实际内容是否完全相同（区分大小写）
底层原理：String类重写了Object类的equals()方法，会逐字符比较字符串的内容

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = "HELLO";

System.out.println(s1.equals(s2)); // true（内容相同）
System.out.println(s1.equals(s3)); // true（内容相同，内存地址不同不影响）
System.out.println(s1.equals(s4)); // false（大小写不同）注意事项：

注意事项：
比较前需确保左操作数非null，否则会抛出NullPointerException（可使用Objects.equals(s1, s2)避免）
如需忽略大小写比较，可使用equalsIgnoreCase()方法（如s1.equalsIgnoreCase(s4)返回true）

3.compareTo()方法：比较字符串大小（字典顺序）
核心作用：按 Unicode 编码值逐个比较字符，返回一个整数表示两个字符串的大小关系
底层原理：从第一个个字符开始依次比较，若遇个字符不同，返回两者 Unicode 值的差值；若前缀相同，则返回长度差值
返回值规则：
正数：当前字符串大于目标字符串（如 “b”.compareTo (“a”) 返回 1）
负数：当前字符串小于目标字符串（如 “a”.compareTo (“b”) 返回 - 1）
0：两个字符串内容完全相同（如 “a”.compareTo (“a”) 返回 0）

String s1 = "apple";
String s2 = "banana";
String s3 = "app";

System.out.println(s1.compareTo(s2)); // -1（'a' < 'b'）
System.out.println(s1.compareTo(s3)); // 2（前缀相同，长度差为2）
System.out.println(s1.compareTo("apple")); // 0（内容完全相同）

注意事项：
本质是按字典顺序比较，常用于适用于判断内容是否相同（需配合== 0使用）
如需忽略大小写比较大小，可使用compareToIgnoreCase()方法

三种方法对比总结：

字符串查找

下面是常用查找方法总结：

public class StringSearchAllMethods {
    public static void main(String[] args) {
        String text = "Hello, welcome to Java world! Java is amazing.";
        char targetChar = 'v';
        String targetStr = "Java";

        // 1. indexOf(String str)
        System.out.println("1. indexOf(\"Java\") → " + text.indexOf(targetStr));

        // 2. indexOf(String str, int fromIndex)
        System.out.println("2. indexOf(\"Java\", 20) → " + text.indexOf(targetStr, 20));

        // 3. indexOf(int ch)
        System.out.println("3. indexOf('v') → " + text.indexOf(targetChar));

        // 4. indexOf(int ch, int fromIndex)
        System.out.println("4. indexOf('v', 15) → " + text.indexOf(targetChar, 15));

        // 5. lastIndexOf(String str)
        System.out.println("5. lastIndexOf(\"Java\") → " + text.lastIndexOf(targetStr));

        // 6. lastIndexOf(String str, int fromIndex)
        System.out.println("6. lastIndexOf(\"Java\", 30) → " + text.lastIndexOf(targetStr, 30));

        // 7. lastIndexOf(int ch)
        System.out.println("7. lastIndexOf('v') → " + text.lastIndexOf(targetChar));

        // 8. lastIndexOf(int ch, int fromIndex)
        System.out.println("8. lastIndexOf('v', 25) → " + text.lastIndexOf(targetChar, 25));

        // 9. contains(CharSequence s)
        System.out.println("9. contains(\"welcome\") → " + text.contains("welcome"));

        // 10. startsWith(String prefix)
        System.out.println("10. startsWith(\"Hello\") → " + text.startsWith("Hello"));

        // 11. startsWith(String prefix, int toffset)
        System.out.println("11. startsWith(\"welcome\", 7) → " + text.startsWith("welcome", 7));

        // 12. endsWith(String suffix)
        System.out.println("12. endsWith(\"amazing.\") → " + text.endsWith("amazing."));
    }
}


1. indexOf("Java") → 21
2. indexOf("Java", 20) → 21
3. indexOf('v') → 10
4. indexOf('v', 15) → 24
5. lastIndexOf("Java") → 21
6. lastIndexOf("Java", 30) → 21
7. lastIndexOf('v') → 24
8. lastIndexOf('v', 25) → 24
9. contains("welcome") → true
10. startsWith("Hello") → true
11. startsWith("welcome", 7) → true
12. endsWith("amazing.") → true

转化

数字和字符串转化

String numStr = "123";
int numInt = Integer.parseInt(numStr);
double numDouble = Double.parseDouble(numStr);
boolean bool = Boolean.parseBoolean("true");

大小写转换

String upper = str.toUpperCase();
String lower = upper.toLowerCase();

字符串转数组

// 3. 字符串转字符数组
String str = "Hello";
char[] charArray = str.toCharArray();        
char[] chars = {'W', 'o', 'r', 'l', 'd'};
String charStr = new String(chars);
        
try {
     byte[] utf8Bytes = str.getBytes("UTF-8");
     byte[] gbkBytes = str.getBytes("GBK");
            
     String fromUtf8 = new String(utf8Bytes, "UTF-8");
     String fromGbk = new String(gbkBytes, "GBK");
} catch (Exception e) {
      e.printStackTrace();
}

格式化

String intFormat = String.format("整数: %d", 123);
String floatFormat = String.format("浮点数: %.2f", 3.14159);
String boolFormat = String.format("布尔值: %b", true);

字符串替换

public class StringReplaceExamples {
    public static void main(String[] args) {
        String text = "Java is great! Java is fun! Java is powerful!";
        
        // 1. replaceAll(String regex, String replacement)
        // 替换所有匹配正则表达式的子串
        String allReplaced = text.replaceAll("Java", "Python");
        System.out.println("replaceAll结果: " + allReplaced);
        // 输出: Python is great! Python is fun! Python is powerful!
        
        // 使用正则表达式应用：替换所有以"is"开头的单词
        String regexReplace = text.replaceAll("is \\w+", "is awesome");
        System.out.println("正则替换结果: " + regexReplace);
        // 输出: Java is awesome! Java is awesome! Java is awesome!
        
        // 2. replaceFirst(String regex, String replacement)
        // 只替换第一个匹配正则表达式的子串
        String firstReplaced = text.replaceFirst("Java", "Python");
        System.out.println("replaceFirst结果: " + firstReplaced);
        // 输出: Python is great! Java is fun! Java is powerful!
        
        // 正则表达式应用：替换第一个感叹号前的内容
        String firstRegexReplace = text.replaceFirst("Java.*?!", "C# is cool!");
        System.out.println("首个正则匹配替换: " + firstRegexReplace);
        // 输出: C# is cool! Java is fun! Java is powerful!
    }
}

字符串拆分

public class StringSplitExample {
    public static void main(String[] args) {
        String str = "Java;Python,C++|JavaScript";
        
        // 1. 基本用法：按单个分隔符拆分
        String[] parts1 = str.split(";");
        System.out.println("按;拆分: " + Arrays.toString(parts1));
        // 输出: [Java, Python,C++|JavaScript]
        
        // 2. 按正则表达式拆分（多分隔符）
        String[] parts2 = str.split("[;,.|]"); // 匹配; , . | 中的任意一个
        System.out.println("多分隔符拆分: " + Arrays.toString(parts2));
        // 输出: [Java, Python, C++, JavaScript]
        
        // 3. 限制拆分次数（limit参数）
        String[] parts3 = str.split("[;|]", 2); // 最多拆分成2部分
        System.out.println("限制拆分次数: " + Arrays.toString(parts3));
        // 输出: [Java, Python,C++|JavaScript]
        
        // 4. 处理特殊字符（需转义）
        String ip = "192.168.1.1";
        String[] ipParts = ip.split("\\."); // .是正则特殊字符，需用\\转义
        System.out.println("IP拆分: " + Arrays.toString(ipParts));
        // 输出: [192, 168, 1, 1]
        
        // 5. 空字符串处理
        String emptyStr = "a,,b,,c";
        String[] withEmpty = emptyStr.split(","); // 保留中间空字符串
        System.out.println("含空值拆分: " + Arrays.toString(withEmpty));
        // 输出: [a, , b, , c]
        
        String[] noEmpty = emptyStr.split(",", -1); // limit=-1保留所有空字符串
        System.out.println("保留所有空值: " + Arrays.toString(noEmpty));
        // 输出: [a, , b, , c]
    }
}

字符串截取

public class SubstringDemo {
    public static void main(String[] args) {
        String text = "Hello, Java World!";
        
        // 1. substring(int beginIndex) - 从指定索引截取到末尾
        String sub1 = text.substring(7);
        System.out.println("从索引7开始: " + sub1); // "Java World!"
        
        // 2. substring(int beginIndex, int endIndex) - 截取指定范围
        String sub2 = text.substring(7, 11);
        System.out.println("从7到11: " + sub2); // "Java"
        
        // 3. 处理边界情况
        String sub3 = text.substring(0); // 从开头截取到末尾
        System.out.println("从开头截取: " + sub3); // "Hello, Java World!"
        
        String sub4 = text.substring(text.length()); // 截取到末尾（返回空字符串）
        System.out.println("截取到末尾: [" + sub4 + "]"); // []
        
        // 4. 实际应用：提取文件扩展名
        String filename = "document.pdf";
        int dotIndex = filename.lastIndexOf('.');
        if (dotIndex != -1) {
            String extension = filename.substring(dotIndex + 1);
            System.out.println("文件扩展名: " + extension); // "pdf"
        }
    }
}

其他操作方法

public class StringCaseAndTrimDemo {
    public static void main(String[] args) {
        String text = "   Hello, Java World!   ";
        
        // 1. trim()：去除字符串首尾空白字符（空格、制表符等）
        String trimmed = text.trim();
        System.out.println("原字符串: [" + text + "]");
        System.out.println("trim()后: [" + trimmed + "]");
        // 输出: [   Hello, Java World!   ] → [Hello, Java World!]
        
        // 2. toUpperCase()：将字符串转换为全大写
        String upper = text.toUpperCase();
        System.out.println("toUpperCase(): " + upper);
        // 输出:   HELLO, JAVA WORLD!   
        
        // 3. toLowerCase()：将字符串转换为全小写
        String lower = text.toLowerCase();
        System.out.println("toLowerCase(): " + lower);
        // 输出:   hello, java world!   
        
        // 4. 组合使用示例：先trim再转换大小写
        String processed = text.trim().toUpperCase();
        System.out.println("组合处理: " + processed);
        // 输出: HELLO, JAVA WORLD!
    }
}

字符串不可变性

String是一种不可变对象，字符串中的内容是不可以改变的。字符串不可以被修改，是因为：
1.String类在设计的时候就是不可以改变的，String类在描述的时候已经说明了
2.String类中的字符实际上被储存在内部维护的value字符数组中
3.String类被final修饰，表明该类不能被继承
4.value被final修饰，表明自身的值不可以改变，也就是说不能引用其他字符数组，但是引用的数组内容可以改变
5.所有涉及到可能修改字符串内容的操作都是创建一个对象，改变的是新对象

public class StringImmutability {
    public static void main(String[] args) {
        // 1. 初始字符串
        String s = "hello";
        String original = s; // 保存初始引用
        
        // 2. 看似修改字符串的操作（实际创建新对象）
        s = s + " world"; // 拼接操作
        System.out.println("原字符串引用是否相同: " + (original == s)); // false
        
        // 3. 其他"修改"操作的本质
        String upper = s.toUpperCase(); // 转换大写
        String sub = s.substring(0, 5); // 截取子串
        String replaced = s.replace("world", "java"); // 替换内容
        
        // 4. 验证原字符串未被修改
        System.out.println("原字符串: " + original); // 仍为 "hello"
        System.out.println("新字符串: " + s); // 新对象 "hello world"
        System.out.println("大写字符串: " + upper); // 新对象 "HELLO WORLD"
    }
}

不可变性的优势：

1.线程安全：多线程环境下无需额外同步，可安全共享字符串对象
2.缓存优化：字符串常量池（String Pool）可复用相同内容的字符串，节省内存
3.哈希值稳定：字符串哈希值计算后可缓存，作为 HashMap 键时性能更高
4.安全性：避免敏感字符串（如密码）被意外修改

字符串修改

由于 Java 中String是不可变的（内容创建后无法修改），所谓的 “字符串修改” 实际上是通过创建新字符串对象或使用可变字符串类来实现的。以下是常用的字符串修改方式：

public class StringModification {
    public static void main(String[] args) {
        // 1. 不可变字符串：每次        String str = "Hello";
        // 任何修改操作都会创建新对象
        String newStr = str + " World"; // 拼接
        String upperStr = str.toUpperCase(); // 转大写
        System.out.println("原字符串: " + str); // 仍为 "Hello"
        System.out.println("新字符串: " + newStr); // 新对象 "Hello World"

        // 2. 使用StringBuilder（非线程安全，效率高）
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" Java"); // 追加
        sb.insert(5, ","); // 插入
        sb.replace(6, 10, "Python"); // 替换
        sb.delete(5, 6); // 删除
        System.out.println("StringBuilder结果: " + sb.toString()); // "HelloPython"

        // 3. 使用StringBuffer（线程安全，效率较低）
        StringBuffer sbf = new StringBuffer("Hello");
        sbf.append(" World");
        sbf.reverse(); // 反转
        System.out.println("StringBuffer结果: " + sbf.toString()); // "dlroW olleH"
    }
}

三种方式对比：

可以看出在对String类进行修改的时候，效率是非常低下的，因此应该尽量避免对String类直接修改，如果要修改尽量使用StringBuilder或者是StringBuffer

StringBuilder和StringBuffer

常见的方法如下：

下面是具体的例子：

public class StringBufferMethodsDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Initial");
        System.out.println("初始 StringBuffer: " + sb);

        // 1. StringBuffer append(任意类型)
        sb.append(" String").append(123).append(true);
        System.out.println("append 后: " + sb);
        // 输出示例：Initial String123true

        // 2. char charAt(int index)
        char ch = sb.charAt(2);
        System.out.println("charAt(2) 获取字符: " + ch);
        // 假设索引 2 对应 'i'，输出：i 

        // 3. int length()
        int len = sb.length();
        System.out.println("length 获取长度: " + len);
        // 示例输出（依实际内容）：15 

        // 4. int capacity()
        int cap = sb.capacity();
        System.out.println("capacity 获取容量: " + cap);
        // 初始默认容量等情况，示例输出：22（默认初始容量计算等因素 ）

        // 5. void ensureCapacity(int minimumCapacity)
        sb.ensureCapacity(30);
        System.out.println("ensureCapacity 后容量: " + sb.capacity());
        // 若原容量不足，扩容后输出对应容量，示例可能输出：34 

        // 6. void setCharAt(int index, char ch)
        sb.setCharAt(0, 'X');
        System.out.println("setCharAt(0, 'X') 后: " + sb);
        // 输出示例：Xnitial String123true 

        // 7. int indexOf(String str)
        int firstIdx = sb.indexOf("String");
        System.out.println("indexOf(\"String\") 索引: " + firstIdx);
        // 示例输出：8 

        // 8. int indexOf(String str, int fromIndex)
        int firstIdxFrom = sb.indexOf("i", 5);
        System.out.println("indexOf(\"i\", 5) 索引: " + firstIdxFrom);
        // 查找从索引5开始 "i" 第一次出现位置，示例输出：9 

        // 9. int lastIndexOf(String str)
        int lastIdx = sb.lastIndexOf("t");
        System.out.println("lastIndexOf(\"t\") 索引: " + lastIdx);
        // 找 "t" 最后出现位置，示例输出：14 

        // 10. int lastIndexOf(String str, int fromIndex)
        int lastIdxFrom = sb.lastIndexOf("i", 8);
        System.out.println("lastIndexOf(\"i\", 8) 索引: " + lastIdxFrom);
        // 从索引8往前找 "i" 最后出现位置，示例输出：3 

        // 11. StringBuffer insert(int offset, 任意类型)
        sb.insert(5, ", Insert");
        System.out.println("insert(5, \", Insert\") 后: " + sb);
        // 输出示例：Xniti, Insertal String123true 

        // 12. StringBuffer deleteCharAt(int index)
        sb.deleteCharAt(5);
        System.out.println("deleteCharAt(5) 后: " + sb);
        // 移除索引5字符，输出示例：Xniti Insertal String123true 

        // 13. StringBuffer delete(int start, int end)
        sb.delete(3, 7);
        System.out.println("delete(3, 7) 后: " + sb);
        // 删除索引3到6（左闭右开）字符，输出示例：XnitInsertal String123true 

        // 14. StringBuffer replace(int start, int end, String str)
        sb.replace(3, 8, "Replace");
        System.out.println("replace(3, 8, \"Replace\") 后: " + sb);
        // 替换索引3 - 7字符为"Replace"，输出示例：XniReplaceal String123true 

        // 15. String substring(int start)
        String sub1 = sb.substring(2);
        System.out.println("substring(2) 结果: " + sub1);
        // 从索引2截取到末尾，输出示例：iReplaceal String123true 

        // 16. String substring(int start, int end)
        String sub2 = sb.substring(2, 6);
        System.out.println("substring(2, 6) 结果: " + sub2);
        // 截取索引2 - 5字符，输出示例：iRep 

        // 17. StringBuffer reverse()
        sb.reverse();
        System.out.println("reverse 后: " + sb);
        // 反转内容，输出示例：eurt321 gnirtS laRepiX 

        // 18. String toString()
        String str = sb.toString();
        System.out.println("toString 结果: " + str);
        // 转换为String，输出示例：eurt321 gnirtS laRepiX 
    }
}

从上述例子可以看出：String 和 StringBuilder 最大的区别在于 String 的内容无法修改，而 StringBuilder 的内容可以修改，频繁修改字符串的情况考虑使用 StringBuilder

注意：String 和 StringBuilder 不能直接转换，如果要互相转换，可以采用如下原则：

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