目录
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
等)创建字符串。文章来源:https://www.toymoban.com/news/detail-846135.htmlCharSequence cs = "Hello"; String s = new String(cs);
注意:在实际编程中,直接使用字符串字面量(如 String s = "Hello";
)是创建字符串的最常见方式,因为这种方式简洁且性能良好。Java虚拟机会在字符串常量池中维护这些字面量,以便重用。直接使用构造方法创建字符串的情况较少,通常只在需要从不同数据源(如数组或缓冲区)创建字符串时才会用到。文章来源地址https://www.toymoban.com/news/detail-846135.html
到了这里,关于Java的字符串的基础知识(必看)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!