java String类 万字详解（通俗易懂）
目录
一、前言
二、介绍和溯源
三、String类常用构造器
1.String()
2.String(byte[] bytes)
3.String(char[] value)
4.String(char[] value, int offset, int count)
5.String(String original)
Δ演示 :
四、不同方式创建String类对象的区别
1.直接赋值的方式
2.常规new的方式
3.内容延申
五、String类常用成员方法
0.前言 :
1.判断功能的方法 :
①boolean equals(Object anObject)
②boolean equalsIngoreCase(String anotherString)
③boolean startWith(String prefix)
④boolean isEmpty()
演示 :
2.获取功能的方法 :
①int length()
②char charAt(int index)
③int indexOf(String str)
④int indexOf(String str, int t)
⑤int lastIndexOf(String str)
⑥int compareTo(String anotherString)
⑦String substring(int beginIndex)
⑧String substring(int beginIndex, int endIndex)
演示 :
3.转换功能的方法 ：
①byte[] getByte()
②char[] toCharArray()
③static String valueOf(...)
④String replace(String old, String new)
⑤String[] split(String regex)
⑥String trim()
⑦String concat(String str)
⑧String toUpperCase()
⑨String toLowerCase()
⑩static String format(String format, Object... args)
演示 :
六、String类总结
一、前言
本节内容是我们《API-常用类》专题的第二小节了。本节内容主要讲String类， 内容包括但不限于 String介绍和溯源 ， String类的类图 ， String类的构造器 ， 不同方式创建String类对象的区别，以及 String类常用方法的演示。up希望通过这篇博文的知识分享，能够帮助大家快速上手并理解java String类。 注意 : ① 代码中的注释也很重要； ② 不要眼高手低，自己敲一遍才能知道怎么用。 ③ 点击侧边栏目录或者文章开头的目录可以跳转。良工不示人以朴，所有文章都会适时改进。大家如果有什么问题，都可以在评论区一块儿交流，或者私信up。 感谢阅读！
二、介绍和溯源
字符串是一组用双引号括起来的字符序列，eg : "CSDN"，"Cyan"，"RA9"等等。每一个字符串对象都是常量。字符串中的字符使用unicode编码，一个字符（不区分中英文）均占两个字节。java中用String类描述字符串，如下图所示 :
可以看到，String类用final关键字修饰，因此String类是不可被其他类继承的；并且，通过String类中的属性value及其源码描述，我们可以得知String类的底层实际其实是字节数组byte[]（up使用的是JDK－17，属于高版本。低版本比如JDK8，String类底层是字符数组char[]）。也就是说，new出的String对象在堆空间中，该对象的空间里有value属性，用于存放字符串的内容（实际是指向常量池的地址）。同时，该value数组也使用了final关键字修饰，我们在面向对象专题详解过final关键字，当final关键字修饰引用类型时，不可更改其引用的指向，即不能更改其保存的地址值。
接下来我们再来看看String类的“家庭关系图”。首先，String类属于java.base模块，java.lang包下，并且实现了Serializable，Comparable等接口。如下图所示 :
我们再来看看String类的类图，如下 :
可以看到，String类除了继承自Object类之外，还实现了许多接口。这么多接口中，大家只需要记住关键的两个接口——①Serializable接口，实现该接口使得String类型可串行化，串行化后，String类型可以进行网络传输。②Comparable接口，实现该接口使得String类型可以进行“比较”的操作。
三、String类常用构造器
String类的构造器非常多，如下图所示 :
有些还是过时的。当然，我们就挑几个重点的，常见的构造器给大家演示一下即可。
1.String()
该构造器可以初始化一个String对象，使其指向一个空字符序列。
2.String(byte[] bytes)
该构造器可以初始化一个String对象，并将指定字节数组中的数据转化成字符串。
3.String(char[] value)
该构造器可以初始化一个String对象，并将指定字符数组中的数据转化成字符串。
4.String(char[] value, int offset, int count)
该构造器可以初始化一个String对象，并将指定字符数组中的指定数据转化成字符串。
5.String(String original)
该构造器可以初始化一个String对象，使该对象实际指向的字符串常量与传入的字符串形参相同，相当于是形参的一份拷贝。
Δ演示 :
以String_Constructors为演示类，代码如下 :
package csdn.knowledge.api.string;
public class String_Constructors {
public static void main(String[] args) {
//演示 : String类的常用构造器
//1 —— String()
String str_0 = new String();
System.out.println(str_0);
System.out.println("--------------------");
//2 —— String(byte[] bytes)
byte[] bytes = {65, 66, 67, 68}; //65~68对应ASCII码表A~D
String str_1 = new String(bytes);
System.out.println(str_1);
System.out.println("--------------------");
//3 —— String(char[] value)
char[] value = {'C', 'y', 'a', 'n', '_', 'R', 'A', '9'};
String str_2 = new String(value);
System.out.println(str_2);
System.out.println("--------------------");
//4 —— String(char[] value, int offset, int count)
String str_3 = new String(value, 0, 4);
System.out.println(str_3);
System.out.println("--------------------");
//5 —— String(String original)
String str_4 = new String("CSDN yyds!");
System.out.println(str_4);
}
}
运行结果 :
四、不同方式创建String类对象的区别
1.直接赋值的方式
String类在实际开发中的使用场景非常多，java在底层提供了针对String类的优化，即可以不通过构造器来创建String对象。而是直接赋值一个字符串。
eg : String str_0 = "Cyan"; ，使用这种方式来创建String对象，jvm会先从常量池中查看是否有"Cyan"字符串的数据空间，若有，令引用变量直接指向该空间；若无，重写创建"Cyan"的数据空间并令其引用变量指向它。因此，str_0引用最终直接指向的是常量池中"Cyan"常量的空间地址。
内存图如下所示 :
2.常规new的方式
eg : String str_1 = new String("Cyan"); ，使用这种方式来创建String对象，jvm会先在堆空间中给String对象开辟空间，这片空间中维护了value数组这一属性，该属性指向常量池的"Cyan"数据空间。若常量池中没有"Cyan"，则重写创建"Cyan"数据空间，并让value引用指向该数据空间。最后，将该对象堆空间的地址值返回给str_1引用。因此，str_1引用最终直接指向的是堆中的空间地址。
内存图如下所示 :
3.内容延申
若使用字符串拼接的方式来创建字符串对象，如下 :
eg : String str_0 = "Cyan" + "RA9";
当我们以两个字符串拼接的形式来创建字符串对象时，jvm不会在常量池中分别创建"Cyan"字符串常量和"RA9"字符串常量，再把它们拼接起来。而是直接在底层优化，先把两个字符串拼接起来，之后直接去常量池中寻找有没有拼接起来的这个字符串常量，如果有，直接令该引用指向这个字符串常量的空间地址；如果没有则先创建该字符串常量，再让引用指向这里。当然，我们已经学过了Debug，此时我们就可以直接通过Debug来验证我们的结论，如下图所示 :
五、String类常用成员方法
0.前言 :
在IDEA类图中我们可以查看String类中的方法，如下GIF图所示 :
可以看到，String类中的方法真是多得⑧彳亍！不过你放心，up从这些方法中挑选了一些我们经常用到的方法，并根据它们的功能将其分为了“判断功能”，“获取功能”，以及“转化功能”三部分。如此一来，大家就可以放心食用！
1.判断功能的方法 :
①boolean equals(Object anObject)
该方法可以判断当前字符串与指定对象的内容是否相同，实际在底层比较的就是字符串的内容，会区分大小写。
②boolean equalsIngoreCase(String anotherString)
该方法可以判断当前字符串与给定字符串的内容是否相同，不区分大小写。
③boolean startWith(String prefix)
该方法可以判断当前字符串是否以给定字符串开头。
④boolean isEmpty()
该方法可以判断当前字符串是否为空。
演示 :
以String_methods类为演示类，代码如下 :
package csdn.knowledge.api.string;
public class String_methods {
public static void main(String[] args) {
//演示 : String常用方法之判断功能的方法
//1 —— boolean equals(Object anObject)
String str_0 = "cyan";
System.out.println("\"Cyan\"字符串与str_0字符串的内容相等吗？" + "Cyan".equals(str_0));
System.out.println("================");
//2 —— boolean equalsIgnoreCase(String anotherString)
System.out.println("\"Cyan\"字符串与str_0字符串的内容相等吗？" + "Cyan".equalsIgnoreCase(str_0));
System.out.println("================");
//3 —— boolean startWith(String prefix)
System.out.println("str_0字符串是否以\"cy\"开头？" + str_0.startsWith("cy"));
System.out.println("str_0字符串是否以\"Cy\"开头？" + str_0.startsWith("Cy"));
System.out.println("================");
//4 —— boolean isEmpty()
System.out.println("str_0字符串是否为空？" + str_0.isEmpty());
}
}
运行结果 :
2.获取功能的方法 :
①int length()
获取当前字符串的长度。
②char charAt(int index)
获取指定位置索引的字符（指字符串的指定索引)。
③int indexOf(String str)
获取指定字符(串) 第一次出现的索引，默认从第0位开始。若返回-1，则表示没有该字符（串）。
④int indexOf(String str, int t)
功能与上一次方法相同，但默认从字符串索引第 t 位开始找。
⑤int lastIndexOf(String str)
获取指定字符(串)最后一次出现的索引，若没有，返回-1。
⑥int compareTo(String anotherString)
返回两个字符串对象的比较结果——若相等，返回0；若不相等，从两个字符串的第一个字符开始比较，返回第一个不相等的字符的ASCII码差值。当较长字符串的前面部分恰巧是较短的字符串时，返回两个字符串的长度差。
⑦String substring(int beginIndex)
获取指定索引位置（包含该位置) 之后的字符串。
⑧String substring(int beginIndex, int endIndex)
获取从索引beginIndex开始，到索引endIndex之间的字符串（区间为前闭后开）。
演示 :
以String_methods_2类为演示类，代码如下 :
package csdn.knowledge.api.string;
public class String_methods_2 {
public static void main(String[] args) {
//演示 : String常用方法之获取功能的方法
//1 —— int length()
String str_0 = "We are the best.";
System.out.println("当前字符串str_0 : " + str_0);
int length = str_0.length();
System.out.println("str_0字符串的长度为：" + length);
System.out.println("========================");
//2 —— char charAt(int index)
char ch_0 = str_0.charAt(0);
char ch_1 = str_0.charAt(5);
System.out.println("str_0字符串中，索引为0的字符是：" + ch_0);
System.out.println("str_0字符串中，索引为5的字符是：" + ch_1);
System.out.println("========================");
//3 —— int indexOf(String str)
int i_0 = str_0.indexOf('e');
System.out.println("字符\'e\'在字符串str_0中首次出现时的索引为：" + i_0);
int i_2 = str_0.indexOf("are");
System.out.println("字符串\"are\"在字符串str_0中首次出现时的索引为：" + i_2);
System.out.println("========================");
//4 —— int indexOf(String str, int t)
int i_1 = str_0.indexOf('e', 7);
System.out.println("从字符串str_0索引为7的地方开始找，字符\'e\'在字符串str_0中首次出现时的索引为：" + i_1);
System.out.println("========================");
//5 —— int lastIndexOf(String str)
int i_3 = str_0.lastIndexOf('t');
System.out.println("字符\'t\'在字符串str_0中最后一次出现时的索引为：" + i_3);
System.out.println("========================");
//6 —— int compareTo(String anotherString)
//第一种情况 : 俩字符串相同
int i_4 = str_0.compareTo("We are the best.");
System.out.println("compareTo方法返回0说明俩字符串相等: " + i_4);
//第二种情况 : 俩字符串长度相同，内容不同
int i_5 = str_0.compareTo("You are so good."); //W : 77, Y : 79.
System.out.println("\'W\'和\'Y\'的ASCII码差值为：" + i_5);
//第三种情况 : 俩字符串长度不相同，但长的字符串的前一部分与短的字符串相同。
int i_6 = str_0.compareTo("We are the best.we are the king!");
int i_7 = "We are the best.we are the king!".compareTo(str_0);
System.out.println("str_0字符串与传入字符串的长度差值为：" + i_6);
System.out.println("传入字符串与str_0字符串的长度差值为：" + i_6);
System.out.println("========================");
//7 —— String substring(int beginIndex)
String str_1 = str_0.substring(11); //"best."
System.out.println("str_0字符串中，从索引11开始到结束的字符串为：" + str_1);
System.out.println("========================");
//8 —— String substring(int beginIndex, int endIndex)
String str_2 = str_0.substring(7, 10); //[7,10)——注意区间的格式。
System.out.println("str_0字符串中，从索引7到10（不包括10）的字符串为：" + str_2);
}
}
运行结果 :
3.转换功能的方法 ：
①byte[] getByte()
将字符串转换成字节数组。（ASCII码）。
②char[] toCharArray()
将字符串转换成字符数组。
③static String valueOf(...)
将指定类型数据转换成字符串。
④String replace(String old, String new)
将指定字符(串)替换为新的字符(串)。原字符串不受影响。
⑤String[] split(String regex)
以传入的字符(串)为标准来切割原字符串，返回切割后的字符串数据，以String类型的数组作为接收。原字符串不受影响。
⑥String trim()
去掉字符串两端的空白字符。（eg : 对登录账号和密码的处理）。
⑦String concat(String str)
将传入的字符串拼接到当前字符串的末尾。
⑧String toUpperCase()
将当前字符串全部转换成大写后返回。
⑨String toLowerCase()
将当前字符串全部转换成小写后返回。
⑩static String format(String format, Object... args)
将指定参数以指定的输出控制格式来输出。形参“String format部分”即输出格式控制，是包含占位符的String类型。形参“Object... args”部分即要输出的参数。占位符由后面的参数按照顺序来一一替换。
至于什么是占位符，比如 : "%s", "%d", "%f"这些，就是C语言中的printf语句用的那几个，这里不再赘述。
演示 :
以String_methods_3类为演示类，代码如下 :
package csdn.knowledge.api.string;
public class String_methods_3 {
public static void main(String[] args) {
//演示 : String常用方法之转换功能的方法
//1 —— byte[] getByte()
String str_0 = "ABCD"; //A~D对应ASCII码值 = 65~68
byte[] bytes = str_0.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println("字节数组的第" + (i + 1) + "个元素 = " + bytes[i]);
}
System.out.println("-----------------------");
//2 —— char[] toCharArray()
char[] chars = str_0.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println("字符数组的第" + (i + 1) + "个元素 = " + chars[i]);
}
System.out.println("-----------------------");
//3 —— static String valueOf(...)
String str_1 = String.valueOf(1111);
String str_2 = String.valueOf('h');
String str_3 = String.valueOf(123.6666);
System.out.println("int类型转String类型：" + str_1);
System.out.println("char类型转String类型：" + str_2);
System.out.println("double类型转String类型：" + str_3);
System.out.println("-----------------------");
//4 —— String replace(String old, String new)
String str_4 = "You_are_so_beautiful!";
String str_5 = str_4.replace('_', ' '); //以' '替换掉'_'
System.out.println("原字符串：" + str_4);
System.out.println("新字符串：" + str_5);
System.out.println("-----------------------");
//5 —— String[] split(String regex)
String str_6 = "What hahaa hahacoincidence haha!";
String[] strings = str_6.split("haha"); //以"haha"来切割字符串。
for (String string : strings) {
System.out.print(string);
}
System.out.println("\n-----------------------");
//6 —— String trim()
String str_7 = " hey,man! ";
String str_8 = str_7.trim();
System.out.println("去掉两端空白字符前的字符串：" + str_7);
System.out.println("去掉两端空白字符后的字符串：" + str_8);
System.out.println("-----------------------");
//7 —— String concat(String str)
String str_9 = "I ";
String str_10 = str_9.concat("love ").concat("programming!");
System.out.println("拼接后的字符串str_10 = " + str_10);
System.out.println("-----------------------");
//8 —— String toUpperCase()
String str_11 = "i love you!";
System.out.println("大写之前的字符串：" + str_11);
System.out.println("大写之后的字符串：" + str_11.toUpperCase());
System.out.println("-----------------------");
//9 —— String toLowerCase()
System.out.println("小写之前的字符串：" + str_11.toUpperCase());
System.out.println("小写之后的字符串：" + str_11.toUpperCase().toLowerCase());
System.out.println("-----------------------");
//10 —— static String format(String format, Object... args)
String name = "Cyan";
int age = 21;
String hobby = "programming!";
String sss = String.format("My name is %s, and I'm %d years old, my hobby is %s", name, age, hobby);
System.out.println(sss);
}
}
运行结果 :
六、String类总结
，以上就是关于String类的全部内容了。希望这篇博文的内容分享，可以帮助大家对String类有进一步的认识。同时，关于String类的常用方法，up都做了较为详细的演示和批注，大家可以多回来看看。API专题的下一小节，我们来讲讲常用类StringBuilder和StringBuffer类，不见不散。感谢阅读！