认识String 类

String类的重要性

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。

常用方法

字符串构造

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

public static void main(String[] args) {
 // 使用常量串构造
 String s1 = "hello bit";
 System.out.println(s1);
 // 直接newString对象
 String s2 = new String("hello bit");
 System.out.println(s1);
 // 使用字符数组进行构造
 char[] array = {'h','e','l','l','o','b','i','t'};
 String s3 = new String(array);
 System.out.println(s1);
}

注意：

• String是引用类型，内部并不存储字符串本身。

public static void main(String[] args) {
    // s1和s2引用的是不同对象  s1和s3引用的是同一对象
    String s1 = new String("hello");
    String s2 = new String("world");
    String s3 = s1;
    
    System.out.println(s1.length());   // 获取字符串长度---输出5
    System.out.println(s1.isEmpty());  // 如果字符串长度为0，返回true，否则返回false
}

• 在Java中“ ”引起来的也是String类型对象。

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

String对象的比较

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

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

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

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("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
}

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

字典序：字符大小的顺序

String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写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
}

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

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

• 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值。
• 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值。

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.int compareToIgnoreCase(String str)方法：与compareTo方式相同，但是忽略大小写比较

字符串查找

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

转化

1. 数值和字符串转化

class Student {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

public class Main {
    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("Hanmeimei", 18));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println("=================================");
        // 字符串转数字
        // 注意：Integer、Double等是Java中的包装类型
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }
}

2.大小写转换

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

3.字符串转数组

 public static void main(String[] args) {
    String s = "hello";
    // 字符串转数组
    char[] ch = s.toCharArray();
    for (int i = 0; i < ch.length; i++) {
        System.out.print(ch[i]);
    }
    System.out.println();
    // 数组转字符串
    String s2 = new String(ch);
    System.out.println(s2);
 }

4.格式化

public static void main(String[] args) {
    String s = String.format("%d-%d-%d", 2025, 7,14);
    System.out.println(s);
 }
运行结果：
2025-7-14

字符串替换

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

注意事项:

由于字符串是不可变对象，替换不修改当前字符串，而是产生一个新的字符串。

字符串拆分

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

public class SplitDemo {
    public static void main(String[] args) {
        String str = "a,b,c,d";
        // 全部拆分
        String[] allParts = str.split(",");
        for (String part : allParts) {
            System.out.print(part + " "); 
        }
        System.out.println();
        
        // 拆分为2组
        String[] limitParts = str.split(",", 2);
        for (String part : limitParts) {
            System.out.print(part + " "); 
        }
    }
}

注意事项:

• 字符"|“,”*“,”+“都得加上转义字符，前面加上”\"。
• 而如果是" \ “，那么就得写成”\\"。
• 如果一个字符串中有多个分隔符，可以用"|"作为连字符。

字符串截取

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

public class SubstringDemo {
    public static void main(String[] args) {
        String str = "HelloWorld";
        // 从索引 5 截取到结尾
        String sub1 = str.substring(5);
        System.out.println(sub1); 
        
        // 截取索引 0 到 5（不包含 5 ）的内容
        String sub2 = str.substring(0, 5);
        System.out.println(sub2); 
    }
}
运行结果：
World
Hello

注意事项：

• 索引从 0 开始。
• 注意前闭后开区间的写法, substring(0,5) 表示包含 0 号下标的字符, 不包含 5 号下标。

其他操作方法

字符串的不可变性

Java 的 String 类是被 final 修饰的，这意味着它不能被继承。String 类内部使用一个 final 修饰的字符数组 value 来存储字符串内容，这保证了数组本身不能被重新赋值，也就保证了字符串内容的不可变性。

为什么 String 要设计成不可变的?

1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了。
2. 不可变对象是线程安全的。
3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中。

字符串修改

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

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

但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。

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();
    StringBuffer sbf = new StringBuffer("");
    for(int i = 0; i < 10000; ++i){
        sbf.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start);

    start = System.currentTimeMillis();
    StringBuilder sbd = new StringBuilder();
    for(int i = 0; i < 10000; ++i){
        sbd.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start);
}

可以看到在对String类直接进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。

StringBuilder和StringBuffer

注意：

• String和StringBuilder类不能直接转换。
• String变为StringBuilder: 利用StringBuilder的构造方法或append()方法。
• StringBuilder变为String: 调用toString()方法。