Java的字符串的基础知识(必看)

String

API的使用

String概述

创建String对象的两种方式

==号比的是什么?

难点

经典String案例

易错点

StringBuilder

疑难点:

StringJoiner

字符串相关类的底层原理

中文的存储原理

String的常见的构造方法

Java的字符串的基础知识(必看)

String

API的使用

JavaAPI（Java Application Programming Interface）是Java编程语言提供的一组类库和接口，用于开发Java应用程序。它为开发人员提供了访问Java平台功能的标准方式。JavaAPI包含了大量的类和接口，用于处理各种任务，包括文件操作、网络通信、图形用户界面（GUI）开发、数据库访问、多线程编程等。

JavaAPI是Java语言的核心部分，它定义了Java平台的基本构建块，使开发人员能够利用Java的强大功能。JavaAPI以包（package）的形式组织，每个包包含一组相关的类和接口。开发人员可以通过导入所需的包来使用JavaAPI中的类和接口。

JavaAPI的设计目标是提供简单、一致和易于使用的编程接口，以加快开发速度并降低开发难度。它提供了丰富的功能，使开发人员能够快速构建各种类型的应用程序，从简单的命令行工具到复杂的企业级应用程序。

JavaAPI还具有良好的跨平台性，因为Java程序可以在不同的操作系统上运行，只要目标系统上有Java运行时环境（Java Runtime Environment，JRE）即可。这使得JavaAPI成为广泛应用于各种领域的编程工具，包括桌面应用程序、移动应用程序、Web应用程序、嵌入式系统等。

总之，JavaAPI是Java编程语言提供的一组类库和接口，用于开发Java应用程序。它提供了丰富的功能和简单易用的编程接口，使开发人员能够快速构建各种类型的应用程序，并具有良好的跨平台性。

JRE（Java Runtime Environment）是Java运行时环境的缩写，它是Java应用程序的运行环境。JRE包含了Java虚拟机（Java Virtual Machine，JVM）以及Java类库和其他支持文件，用于执行Java程序。

当你编写一个Java程序并打算运行它时，你需要先安装JRE。JRE提供了Java程序所需的运行时环境，包括Java虚拟机，它是执行Java字节码的虚拟计算机。Java虚拟机负责解释和执行Java程序的字节码，并提供了内存管理、安全性、线程管理等功能。

除了Java虚拟机，JRE还包含了一系列的Java类库，这些类库提供了丰富的功能和工具，用于开发和执行Java程序。这些类库涵盖了各种领域，包括文件操作、网络通信、图形用户界面（GUI）开发、数据库访问、多线程编程等。

JRE的安装通常是随同Java开发工具包（Java Development Kit，JDK）一起提供的。JDK是用于开发Java应用程序的工具包，它包含了JRE以及其他开发工具，如编译器（javac）、调试器（jdb）等。在开发阶段，开发人员通常需要安装JDK来编译、调试和运行Java程序。而在部署阶段，只需要安装JRE来执行已经编译好的Java程序。

总之，JRE是Java运行时环境，它包含了Java虚拟机和Java类库，用于执行Java程序。安装JRE可以提供Java程序所需的运行时环境，使得Java程序能够在计算机上正确运行。

String概述

String name = "123";
name = "456";
System.out.println(name);

运行结果:

这几行代码展示了Java中对字符串（String）对象的操作。

首先，代码创建了一个名为name的字符串变量，并将其初始化为"123"，即String name = "123";。

接下来，代码将字符串变量name的值修改为"456"，即name = "456";。在Java中，字符串是不可变的（immutable），这意味着一旦创建了一个字符串对象，就无法修改它的值。但是，当我们修改字符串变量时，实际上是创建了一个新的字符串对象，并将变量指向新的对象。

最后，代码使用System.out.println()方法将字符串变量name的值打印到控制台。由于name的值已经被修改为"456"，所以打印的结果是"456"。

因此，这几行代码的执行结果是在控制台输出"456"。

在Java中，字符串常量（如"456"）在编译时会被放入字符串常量池（String Pool）中，而不是在堆（Heap）中分配空间。字符串常量池是一块特殊的内存区域，用于存储字符串常量的引用。

当执行name = "456";时，Java会检查字符串常量池中是否已经存在值为"456"的字符串对象。如果存在，那么变量name会指向字符串常量池中的对象；如果不存在，Java会在字符串常量池中创建一个新的字符串对象，并让变量name指向它。

因此，在这段代码中，变量name实际上指向了字符串常量池中的对象，而不是在堆中分配新的空间。这是因为字符串常量是不可变的，可以被共享和重复使用。这种设计有助于提高性能和节省内存。

需要注意的是，如果使用new关键字创建字符串对象，例如String name = new String("456");，那么会在堆中分配新的空间来存储字符串对象。这种情况下，字符串常量池中不会有对应的对象，而是在堆中创建一个新的对象。但是，在一般情况下，推荐使用字符串常量来初始化字符串变量，以便利用字符串常量池的优势。

字符串常量池（String Pool）是Java中的一块特殊内存区域，用于存储字符串常量。它是在运行时存储字符串对象的一个缓存区域。

在Java中，当我们使用字符串字面量（如"hello"）创建字符串对象时，Java会首先检查字符串常量池中是否已经存在相同内容的字符串对象。如果存在，那么新的字符串对象将直接引用已存在的对象，而不会创建新的对象；如果不存在，Java会在字符串常量池中创建一个新的字符串对象，并将其放入常量池中。

通过使用字符串常量池，Java实现了字符串的共享和重用。这样做有助于提高性能和节省内存，因为多个字符串变量可以共享同一个字符串常量，而不需要每次都创建新的对象。

需要注意的是，字符串常量池是存储在堆中的一部分，而不是存储在栈中。这意味着字符串常量池中的字符串对象在垃圾回收时不会被回收，除非整个字符串常量池被清空。

总之，字符串常量池是Java中用于存储字符串常量的缓存区域，它提供了字符串对象的共享和重用机制，以提高性能和节省内存。

在Java中，变量存储的是对象的引用，而不是对象本身。当我们声明一个变量并将其赋值为一个字符串对象时，变量实际上保存的是字符串对象在内存中的引用地址。

在字符串常量池中，每个字符串常量都有一个唯一的引用地址。当我们将一个字符串常量赋值给一个变量时，变量会保存该字符串常量的引用地址。这样做的好处是，可以通过变量来访问和操作字符串对象，而不需要直接操作引用地址。

例如，当我们执行以下代码：

String name = "456";

变量name会保存字符串常量"456"在字符串常量池中的引用地址。

通过使用引用地址，Java可以实现字符串的共享和重用。如果多个变量都指向同一个字符串常量，它们实际上指向的是相同的对象，而不是每个变量都拥有一个独立的对象。这样可以节省内存空间，并提高性能。

总结起来，变量保存的是对象的引用地址，而不是直接保存对象本身或字符串常量的地址。这样可以通过变量来访问和操作对象，同时实现对象的共享和重用。

在Java中，对象的引用地址和字符串常量的地址实际上是同一个概念，都表示对象在内存中的位置。引用地址是一个唯一标识对象的值，可以用来定位和访问对象。

区别在于对象的引用地址和字符串常量的地址所指向的内容不同。

对象的引用地址指向堆内存中的对象实例。当我们使用new关键字创建一个对象时，Java会在堆中为该对象分配内存空间，并返回该对象在堆中的引用地址。我们可以通过该引用地址来访问和操作对象的属性和方法。
字符串常量的地址指向字符串常量池中的字符串对象。字符串常量池是一个存储字符串常量的缓存区域，用于存储在代码中直接使用的字符串字面量。当我们使用字符串字面量创建字符串对象时，Java会首先检查字符串常量池中是否已经存在相同内容的字符串对象。如果存在，新的字符串对象将直接引用已存在的对象；如果不存在，Java会在字符串常量池中创建一个新的字符串对象，并将其放入常量池中。因此，字符串常量的地址指向的是字符串常量池中的对象。

需要注意的是，字符串常量池是存储在堆中的一部分，而不是存储在栈中。因此，字符串常量的地址和对象的引用地址都指向堆内存中的对象实例，只是它们指向的具体位置不同。

总结起来，对象的引用地址和字符串常量的地址都表示对象在内存中的位置，但对象的引用地址指向堆内存中的对象实例，而字符串常量的地址指向字符串常量池中的对象。

因此，System.out.println(name);语句输出的是name变量当前所引用的字符串常量的内容，即"456"，而不是name变量所指向的地址.

在Java中，System.out.println()方法会根据参数的类型进行适当的转换和输出。对于字符串类型的参数，它会输出字符串的内容而不是引用地址。

创建String对象的两种方式

是的，String 是Java中的引用数据类型。在Java中，基本数据类型（如整数、浮点数等）是直接存储值的，而引用数据类型（如 String、数组、对象等）存储的是对象的引用或地址。

当我们声明一个 String 类型的变量时，实际上是在栈内存中创建了一个变量，该变量存储了字符串对象的引用。这个引用指向存储在堆内存中的实际字符串对象。

例如，以下代码中的 str 是一个 String 类型的引用变量：

String str = "Hello";

这里，str 存储了字符串 "Hello" 对象的引用。实际的字符串对象被存储在字符串常量池或堆内存中，而 str 只是指向该对象的引用。

因为 String 是引用数据类型，所以可以对字符串对象进行各种操作，例如拼接、截取、比较等。同时，由于字符串的不可变性，每次对字符串进行修改操作时，实际上是创建了一个新的字符串对象，而原始的字符串对象保持不变。

总结起来，String 是Java中的引用数据类型，用于表示字符串对象，并提供了丰富的字符串操作方法。

==号比的是什么?

在Java中，== 运算符用于比较两个对象的引用是否相等，而不是比较对象的内容。具体来说，== 比较的是两个对象的内存地址是否相同。

当使用 == 比较两个引用类型的变量时，会进行如下判断：

如果两个引用变量指向同一个对象（即它们的内存地址相同），则 == 返回 true。
如果两个引用变量指向不同的对象（即它们的内存地址不同），则 == 返回 false。

这里需要注意的是，对于基本数据类型（如 int、double 等），== 比较的是它们的值是否相等，而不是比较内存地址。

如果我们想要比较两个字符串对象的内容是否相等，应该使用 equals() 方法，而不是 == 运算符。equals() 方法是在 Object 类中定义的，子类可以覆盖它以提供自定义的相等判断逻辑。在 String 类中，equals() 方法已经被重写，用于比较字符串对象的内容是否相等。

例如，以下示例演示了 == 运算符和 equals() 方法的使用：

String str1 = "Hello";
String str2 = "Hello";
String str3 = new String("Hello");

System.out.println(str1 == str2);      // 输出 true，因为两个引用变量指向同一个字符串常量池中的对象
System.out.println(str1 == str3);      // 输出 false，因为两个引用变量指向不同的对象
System.out.println(str1.equals(str2)); // 输出 true，因为两个字符串对象的内容相等
System.out.println(str1.equals(str3)); // 输出 true，因为两个字符串对象的内容相等

总之，== 运算符比较的是对象的引用是否相等，而 equals() 方法比较的是对象的内容是否相等。

难点

在Java中，当一个字符串与其他类型的数据进行连接操作时，Java会自动将其他类型的数据转换为字符串。这个过程称为字符串的拼接或字符串的连接。

在代码中，表达式s = s + 12;中，整数12会自动转换为字符串"12"，然后与字符串s连接在一起，形成新的字符串"[12"。

经典String案例

package com.xiaonan.exercise06;

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的身份证号");
        //在while外定义 身份证号
        String idCard;
        while(true){
           idCard = sc.next();
            if(idCard.length()!=18){
                System.out.println("您输入的身份证号码有误,请重新输入");
            }else {
                System.out.println("输入成功");
                break;
            }
        }

        //1. 获取出生年月日
        String year = idCard.substring(6,10);
        String month = idCard.substring(10,12);
        String day = idCard.substring(12,14);
        //2. 获取性别
        String gender = idCard.substring(16,17);
        char c = gender.charAt(0);
        //这里的test的值为 ASCII码值 不是真正的"数字"
        //我要拿的是里面的之前存储的数字1,2 来计算 而不是拿数字对应的码值来计
        int test = (int)c;  //所以这是错的
        System.out.println("--------"+test);
        //**注意点1, 这里要转化**
        if((c-'0')%2==0){
            gender = "女";
        }else{
            gender = "男";
        }
        //3. 输出
        System.out.println("人物信息为");
        System.out.println(year+"年"+month+"月"+day+"日");
        System.out.println("性别为: "+gender);
    }
}

易错点

//2. 获取性别 String gender = idCard.substring(16,17); char c = gender.charAt(0); //这里的test的值为 ASCII码值不是真正的"数字" //我要拿的是里面的之前存储的数字1,2 来计算而不是拿数字对应的码值来计 int test = (int)c; //所以这是错的 System.out.println("--------"+test); //注意点1, 这里要转化 if((c-'0')%2==0){ gender = "女"; }else{ gender = "男"; }

StringBuilder

在Java中，你可以使用 StringBuilder 类来构建可变的字符串。StringBuilder 允许你进行字符串的修改和拼接，而不需要创建新的字符串对象。

下面是使用 StringBuilder 进行字符串替换的示例：

String talk = "Hello, world!";
String[] arr = {"Hello", "world"};

StringBuilder sb = new StringBuilder(talk);

for (String word : arr) {
    int index = sb.indexOf(word);
    while (index != -1) {
        sb.replace(index, index + word.length(), "***");
        index = sb.indexOf(word, index + 1);
    }
}

String result = sb.toString();
System.out.println(result);

在上面的示例中，我们首先创建了一个 StringBuilder 对象 sb，并将初始字符串 talk 传递给它的构造函数。然后，我们使用 indexOf 方法找到要替换的字符串的位置，并使用 replace 方法将其替换为 "***"。我们使用 indexOf 方法的第二个参数来查找下一个出现的位置，并在循环中重复这个过程，直到找不到更多的匹配。

最后，我们使用 toString 方法将 StringBuilder 对象转换回普通的字符串，并将结果打印出来。

使用 StringBuilder 可以避免每次替换都创建新的字符串对象，从而提高性能和效率。

打印对象不是地址值,而是属性值
StringBuilder容器里的值是可以改的,而String是不可以改的,String需要创建新的字符串(重复就不用创建,两个对象都会指向这个字符串)

在Java中，String 和 StringBuilder 都提供了一些常用的方法来操作字符串。下面是它们的一些常用方法：

String常用方法：

length()：返回字符串的长度。
charAt(int index)：返回指定索引位置的字符。
substring(int beginIndex)：返回从指定索引开始到字符串末尾的子字符串。
substring(int beginIndex, int endIndex)：返回从指定索引开始到指定索引结束的子字符串。
indexOf(String str)：返回指定字符串在当前字符串中第一次出现的索引位置。
lastIndexOf(String str)：返回指定字符串在当前字符串中最后一次出现的索引位置。
startsWith(String prefix)：检查当前字符串是否以指定的前缀开始。
endsWith(String suffix)：检查当前字符串是否以指定的后缀结束。
toUpperCase()：将字符串转换为大写。
toLowerCase()：将字符串转换为小写。
trim()：去除字符串两端的空格。
replace(CharSequence target, CharSequence replacement)：将指定的目标字符串替换为指定的替换字符串。

StringBuilder常用方法：
append(String str)：将指定字符串追加到当前字符串的末尾。
insert(int offset, String str)：在指定的偏移位置插入指定的字符串。
delete(int start, int end)：删除从指定开始索引到指定结束索引之间的字符。
reverse()：反转当前字符串。
replace(int start, int end, String str)：将指定范围内的字符替换为指定的字符串。
length()：返回字符串的长度。
charAt(int index)：返回指定索引位置的字符。
substring(int start)：返回从指定索引开始到字符串末尾的子字符串。
substring(int start, int end)：返回从指定索引开始到指定索引结束的子字符串。
toString()：将 StringBuilder 对象转换为普通的字符串。

这些方法只是 String 和 StringBuilder 类中的一部分，它们提供了丰富的功能来处理字符串。你可以根据具体的需求选择适合的方法来操作字符串。

疑难点:

在你给出的代码中：

//1. 创建一个StringBuilder对象
StringBuilder sb = new StringBuilder("abc");
//2. 反转
StringBuilder s = sb.reverse();
//3. 转化为String
String str = s.toString();

这里没有错误，让我解释一下为什么这样是有效的：

首先，你创建了一个 StringBuilder 对象 sb 并用字符串 "abc" 初始化它。
然后，你调用了 sb 的 reverse() 方法。reverse() 方法是 StringBuilder 类的一个实例方法，它的作用是将 StringBuilder 对象内部的字符序列反转。这个方法返回的是反转后的 StringBuilder 对象本身的引用，即 this 引用。因此，s 和 sb 实际上是引用同一个对象。
接着，你调用了 s.toString() 方法。由于 s 是 StringBuilder 类型的一个引用，它指向的是一个有效的 StringBuilder 对象（即最初的 sb 对象，现在字符序列已被反转），因此调用 toString() 方法是合法的。toString() 方法将 StringBuilder 对象内部的字符序列转换为一个新的 String 对象。

在Java中，变量名（如 s 和 sb）只是对象的引用，它们不是对象本身。在这段代码中，s 和 sb 都是指向同一个 StringBuilder 对象的引用。当你对这个对象调用方法时，不管是通过哪个引用调用的，效果都是相同的。因此，s.toString() 是完全有效的，它会调用那个共享对象的 toString() 方法，并不会产生错误。

在 Java 中，System.out.println() 方法用于将内容打印到控制台。当你传递一个表达式作为参数时，Java 会将其解析为一个字符串并进行打印。

在你的代码中，len + sb 是一个表达式，其中 len 是一个整数，sb 是一个 StringBuilder 对象。如果你直接将这个表达式作为参数传递给 System.out.println()，Java 会将其解析为一个整数和一个 StringBuilder 对象的相加操作，而不是将它们转换成字符串进行拼接。

为了将表达式转换为字符串拼接，你可以在表达式前面添加一个空字符串 ""，这会触发 Java 将整个表达式转换为字符串的操作。这样，len + sb 就会被解析为字符串拼接，而不是数值相加。

因此，正确的写法是 System.out.println("" + len + sb);，其中空字符串 "" 会将整个表达式转换为字符串拼接。这样就可以将 len 和 sb 转换为字符串，并进行拼接输出到控制台。

StringJoiner

在Java中，StringJoiner 是一个用于连接字符串的实用类。它可以方便地将多个字符串连接成一个字符串，并可以在字符串之间指定分隔符。

StringJoiner 类提供了以下构造方法：

StringJoiner(CharSequence delimiter): 创建一个新的 StringJoiner 对象，使用指定的分隔符。
StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): 创建一个新的 StringJoiner 对象，使用指定的分隔符、前缀和后缀。

StringJoiner 类的常用方法包括：

StringJoiner add(CharSequence element): 向当前 StringJoiner 对象添加一个元素。
StringJoiner merge(StringJoiner other): 将另一个 StringJoiner 对象中的元素合并到当前对象中。
String toString(): 返回连接后的字符串。

下面是一个示例，展示了如何使用 StringJoiner 类将多个字符串连接成一个字符串：

import java.util.StringJoiner;

public class Example {
    public static void main(String[] args) {
        StringJoiner stringJoiner = new StringJoiner(", "); // 使用逗号和空格作为分隔符
        stringJoiner.add("Apple");
        stringJoiner.add("Banana");
        stringJoiner.add("Orange");

        String result = stringJoiner.toString();
        System.out.println(result); // 输出: Apple, Banana, Orange
    }
}

在上述示例中，我们创建了一个 StringJoiner 对象 stringJoiner，指定了分隔符为逗号和空格。然后，我们使用 add() 方法向 stringJoiner 添加了三个字符串。最后，通过调用 toString() 方法，我们得到了连接后的字符串，并将其打印出来。

StringJoiner 类在处理字符串连接时非常方便，特别是在需要拼接多个字符串并指定分隔符的情况下。它可以避免手动处理分隔符和边界情况的麻烦，并提供了简洁的 API。

字符串相关类的底层原理

在Java中，字符串相关的类主要有String、StringBuilder和StringBuffer。它们在内存中存储和处理字符串的方式略有不同。

String类：
- String类是不可变的，即创建后不能被修改。每次对字符串进行修改（如拼接、替换等），都会创建一个新的字符串对象。
- 字符串常量池（String Pool）是String类的一个重要特性。当创建字符串字面量时，JVM会首先检查字符串常量池中是否存在相同内容的字符串，如果存在，则直接返回常量池中的引用，而不会创建新的对象。
- String对象在内存中以连续的字符数组（char[]）形式存储。
StringBuilder类：
- StringBuilder类是可变的，可以进行字符串的拼接、插入、删除等操作，而不会创建新的对象。
- StringBuilder使用一个可调整大小的字符数组（char[]）来存储字符串内容，当需要修改字符串时，会直接在字符数组上进行操作。
- StringBuilder的操作是非线程安全的，适用于单线程环境。
StringBuffer类：
- StringBuffer类与StringBuilder类类似，也是可变的，可以进行字符串的修改操作。
- StringBuffer也使用一个可调整大小的字符数组（char[]）来存储字符串内容，但与StringBuilder不同的是，StringBuffer的操作是线程安全的。
- StringBuffer的方法使用了synchronized关键字来保证线程安全，因此在多线程环境中推荐使用StringBuffer。

总体来说，String类适用于字符串不经常修改的场景，而StringBuilder和StringBuffer适用于需要频繁修改字符串的场景。StringBuilder和StringBuffer的底层实现都是通过字符数组来存储和操作字符串，不同之处在于线程安全性。

中文的存储原理

在 Java 中，中文字符是使用 Unicode 编码进行存储的。Unicode 是一种字符集，它为世界上几乎所有的字符都分配了一个唯一的标识符，包括中文字符。

Unicode 为每个字符分配了一个唯一的代码点，用十六进制表示。例如，中文字符 "中" 的 Unicode 编码是 \u4E2D，其中 \u 表示后面跟着的是一个 Unicode 编码。

Java 中的字符串类型 String 是基于 Unicode 编码的，它可以存储任意 Unicode 字符，包括中文字符。当你在 Java 中创建一个字符串时，你可以直接使用中文字符，例如：

String chinese = "中文字符串";

在内存中，Java 使用 UTF-16 编码来表示字符串。UTF-16 是一种可变长度的编码方案，它可以用 16 位编码表示大部分常见字符，但对于一些罕见的字符，可能需要使用两个 16 位编码来表示。

Java 提供了一些方法来处理字符串和字符的 Unicode 编码。例如，可以使用 charAt() 方法获取字符串中指定位置的字符，然后使用 char 类型来表示该字符的 Unicode 编码。还可以使用 getBytes() 方法将字符串转换为字节数组，其中每个字符都使用 UTF-8 编码进行存储。

需要注意的是，Java 中的字符类型 char 是使用 UTF-16 编码的，它占用 16 位（2 字节）的存储空间。对于大部分常见的字符，一个 char 可以存储一个字符，但对于一些罕见的字符或辅助字符，可能需要使用两个 char 来表示一个字符。

总结来说，Java 使用 Unicode 编码来存储中文字符和其他字符，它提供了一种统一的方式来表示世界上几乎所有的字符。

String的常见的构造方法

在Java中，String 类有多种构造方法，可以用来以不同的方式创建字符串。以下是一些常见的 String 构造方法：

无参构造方法：创建一个空的字符串。
```
String s = new String();
```

从数组构造：从字符数组中创建字符串。

char[] chars = {'H', 'e', 'l', 'l', 'o'};
String s = new String(chars);

从数组的子集构造：从字符数组的子集中创建字符串。

char[] chars = {'H', 'e', 'l', 'l', 'o'};
String s = new String(chars, 1, 3); // "ell"

从另一个字符串构造：复制另一个字符串的内容。
```
String original = "Hello";
String s = new String(original);
```
从字节数组构造：使用平台默认的字符集，将字节数组转换为字符串。
```
byte[] bytes = {72, 101, 108, 108, 111};
String s = new String(bytes);
```
从字节数组的子集构造：使用平台默认的字符集，将字节数组的子集转换为字符串。
```
byte[] bytes = {72, 101, 108, 108, 111};
String s = new String(bytes, 1, 3); // "ell"
```

指定字符集的字节数组构造：指定字符集将字节数组转换为字符串。

byte[] bytes = {72, 101, 108, 108, 111};
String s = new String(bytes, Charset.forName("UTF-8"));

指定字符集的字节数组的子集构造：指定字符集将字节数组的子集转换为字符串。

byte[] bytes = {72, 101, 108, 108, 111};
String s = new String(bytes, 1, 3, Charset.forName("UTF-8")); // "ell"

从StringBuilder构造：从一个StringBuilder对象中创建字符串。
```
StringBuilder sb = new StringBuilder("Hello");
String s = new String(sb);
```
从StringBuffer构造：从一个StringBuffer对象中创建字符串。
```
StringBuffer sb = new StringBuffer("Hello");
String s = new String(sb);
```
从CharSequence接口构造：从实现了CharSequence接口的任意类型（如String, StringBuilder, StringBuffer等）创建字符串。
```
CharSequence cs = "Hello";
String s = new String(cs);
```

注意：在实际编程中，直接使用字符串字面量（如 String s = "Hello";）是创建字符串的最常见方式，因为这种方式简洁且性能良好。Java虚拟机会在字符串常量池中维护这些字面量，以便重用。直接使用构造方法创建字符串的情况较少，通常只在需要从不同数据源（如数组或缓冲区）创建字符串时才会用到。