目录
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虚拟机会在字符串常量池中维护这些字面量，以便重用。直接使用构造方法创建字符串的情况较少，通常只在需要从不同数据源（如数组或缓冲区）创建字符串时才会用到。
8081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
