【JAVA学习笔记】49 - String类，StringBuffer类，StringBuilder类（重要）
项目代码
https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/string_
https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/stringbuffer_
https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/stringbuilder_
String类
一、String入门
1. String对象用于保存字符串，也就是一组字符序列
2.字符串常量对象是用双引号括起的字符序列。例如: "你好"、 "12.97"、 "boy"等
3.字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
4.String类较常用构造器
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a):
String s4 = new String(char[] a,int startindex,int count)
5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]
接口 Comparable [String 对象可以比较大小]
6. String 是final 类，不能被其他的类继承
7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组
8. 一定要注意：value 是一个final类型， 不可以修改(地址不可以修改)：即value不能指向新的地址，但是单个字符内容是可以变化
public class String01 {
public static void main(String[] args) {
//1.String 对象用于保存字符串，也就是一组字符序列
//2. "jack" 字符串常量, 双引号括起的字符序列
//3. 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
//4. String 类有很多构造器，构造器的重载
// 常用的有 String s1 = new String(); //
//String s2 = new String(String original);
//String s3 = new String(char[] a);
//String s4 = new String(char[] a,int startIndex,int count)
//String s5 = new String(byte[] b)
//5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]
// 接口 Comparable [String 对象可以比较大小]
//6. String 是final 类，不能被其他的类继承
//7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组
//8. 一定要注意：value 是一个final类型， 不可以修改(地址不可以修改)：即value不能指向新的地址，但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';
//value = v2; 不可以修改 value地址
}
}
二、创建String对象的两种方式
方式一:直接赋值Strings = "hsp";
方式二:调用构造器String s2 = new String("hsp");
方式一，先从常量池查看是否有"hsp"数据空间，如果有，直接指向;如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp",重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。value指向常量池的空间
3.画出两种方式的内存分布图
练习
1.
true ，String重写了equals方法，先比较地址，然后比较字符串内容，if（a == b），为假后循环遍历比较内容
true，==比较的是地址
2.
String a = "hsp";
String b =new String("hsp");
System.out.println(a.equals(b));
System.out.println(a==b);
System.out.println(a==b.intern0);
System.out.println(b==b.intern();
3.intern方法
public class StringExercise03 {
public static void main(String[] args) {
String a = "hsp";//指向常量池的hsp
String b = new String("hsp");//b指向堆，String内的，对象内的value指向常量池
System.out.println(a.equals(b));//T
System.out.println(a == b);//F a->常量池"hsp" b->堆里的String空间的value
System.out.println(a == b.intern());//T
System.out.println(b == b.intern());//F
//intern:返回当调用intern方法时，如果池已经包含一个等于此，String对象的字符串(用equals(Obiect方法确定)
//则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用
//b.intern()方法最终返回的是常量池的地址(对象)
}
}
4.
public class StringExercise04 {
public static void main(String[] args) {
String s1 = "hspedu";//指向常量池
String s2 = "java";//指向常量池
String s4 = "java";//指向常量池
String s3 = new String("java");//指向堆中对象
System.out.println(s2 == s3);//F
System.out.println(s2 == s4);//T
System.out.println(s2.equals(s3));//T
System.out.println(s1 == s2);//F
}
}
5.
p1.name == p2.name 比较的是两者的地址，两者都指向hspedu，所以当然相等
6.字符串的特性常量池
创建了两个对象
7. 字符串特性常量相加
编译器会优化，等价于String a = "helloabc"，因为创建的hello和abc没人用，所以优化了
8.字符串特性变量相加
.
public class StringExercise08 {
public static void main(String[] args) {
String a = "hello";
String b = "abc";
//1.创建了一个StringBuilder
//2.执行sb.append("hello") 3.再append("abc")
//再调用String sb.toString()
//最后其实是c->堆中的对象的value[] ->池中的"helloabc"
String c = a + b;
//如果有了就直接用
String d = "hello" + "abc";//直接指向堆里的helloabc
System.out.println(c == d);//false
}
}
底层是StringBuilder sb = new StringBuilder(); sb.append(a);sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的.
重要规则，Stringc1 = "ab" + "cd";常量相加，看的是池。
Stringc1 = a+b ;变量相加,看的是堆。
9.
10.数组传递，字符串引用，多看！
三、String类的常用方法
String类是保存宇符事常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。[后面我们还会详细介绍StringBuilder和StringBuffer]
1.equals //区分大小写，判断内容是否相等
2.equalslgnoreCase //忽略大小写的判断内容是否相等
3.length /获取字符的个数，字符串的长度
4.indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
5.lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到返回-1
6.substring //截取指定范围的子串
7.trim //去前后空格
8.charAt:获取某索引处的字符，注意不能使用Str[index]这种方式.
String str = “hello”
str[0] //错误
str.chatAt（0） => h
9.toUpperCase转换成大写Strings = "heLLo";System.out.println(s.toUpperCase();
10.toLowerCaseSystem.out.println(s.toLowerCase();
11.concat拼接字符串
Strings1 =“宝玉";
s1 = s1.concat("林黛玉).concat("薛宝钗").concat(" together");
System.out.println(s1);
12.replace替换字符串中的字符
”Strings1 =“宝玉and薛宝钗薛宝钗薛宝钗";
”s1 = s1.replace("林黛玉"，"薛宝钗");
System.out.println(s1);
13.split分割字符串，对于某些分割字符，我们需要转义比如| |\等
String poem = "锄禾日当午,汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
StringD] split = poem.split(",");
String poem = "E:\laaa\bbb";
String[ split = poem.split("\\|");
String[] split = poem.splt("1lI");
String[] split = poem.split(1"\1I");
”for(int i=0;i< split.length;i+ +){
System.out.println(split[);
}14.toCharArray转换成字符数组
String s = "happy";
char[ chs = s.toCharArray();
StringBuffer类
一、基本介绍
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。很多方法与String相同，但StringBuffer是可变长度的。StringBuffer是一个容器
类结构图
1. StringBuffer 的直接父类 是 AbstractStringBuilder
2. StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化
StringBuffer stringBuffer = new StringBuffer("hello");
3. 在父类中AbstractStringBuilder有属性 char[] value,不是final类型。该 value 数组存放 字符串内容，引出存放在堆中的
4. StringBuffer 是一个 final类，不能被继承
5. 因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
public class StringBuffer01 {
public static void main(String[] args) {
//1. StringBuffer 的直接父类 是 AbstractStringBuilder
//2. StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化
StringBuffer stringBuffer = new StringBuffer("hello");
//3. 在父类中AbstractStringBuilder有属性 char[] value,不是final类型
// 该 value 数组存放 字符串内容，引出存放在堆中的
//4. StringBuffer 是一个 final类，不能被继承
//5. 因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)
// 不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
}
}
二、String和StringBuffer的对比
1) String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址， 效率较低//private final char valuel[];
2) StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; // 这个放在堆.
三、StringBuffer的构造器
1. 创建一个 大小为 16的 char[] ,用于存放字符内容
2. 通过构造器指定 char[] 大小
3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
public class StringBuffer02 {
public static void main(String[] args) {
//构造器的使用
//1. 创建一个 大小为 16的 char[] ,用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();
//2 通过构造器指定 char[] 大小
StringBuffer stringBuffer1 = new StringBuffer(100);
//3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
StringBuffer hello = new StringBuffer("hello");
}
}
四、String和StringBuffer的互相转化
1.String——>StringBuffer
方式1 使用构造器
注意： 返回的才是StringBuffer对象，对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);2.StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();
方式2: 使用构造器来搞定
String s1 = new String(stringBuffer3);
public class StringAndStringBuffer {
public static void main(String[] args) {
//看 String——>StringBuffer
String str = "hello tom";
//方式1 使用构造器
//注意： 返回的才是StringBuffer对象，对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//看看 StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();
//方式2: 使用构造器来搞定
String s1 = new String(stringBuffer3);
}
}
五、StringBuffer常用方法
1.添加方法
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"2.删除方法
/*
* 删除索引为>=start &&* 解读: 删除 11~14的字符 [11, 14) 到14-1下标的索引都同理
*/
s.delete(11, 14);
System.out.println(s);//"hello,张三丰赵敏true10.5"3.修改方法
//使用 周芷若 替换 索引9-11的字符 [9,11)
s.replace(9, 11, "周芷若");
System.out.println(s);//"hello,张三丰周芷若true10.5"
//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
int indexOf = s.indexOf("张三丰");
System.out.println(indexOf);//6
4.插入方法
//在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
s.insert(9, "赵敏");//包含9
System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);
public class StringBufferMethod {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//添加方法
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"
System.out.println(s);//"hello,张三丰赵敏100true10.5"
//删除方法
/*
* 删除索引为>=start && 练习
1.
public class StringBufferExercise01 {
public static void main(String[] args) {
String str = null;// ok
StringBuffer sb = new StringBuffer(); //ok
sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull () 增加了null字符
System.out.println(sb.length());//4
System.out.println(sb);//null
//下面的构造器，会抛出NullpointerException
StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
System.out.println(sb1);
}
}
2.
public class StringBufferExercise02 {
public static void main(String[] args) {
/*
输入商品名称和商品价格，要求打印效果示例, 使用前面学习的方法完成：
商品名 商品价格
手机 123,564.59 //比如 价格 3,456,789.88
要求：价格的小数点前面每三位用逗号隔开, 在输出。
思路分析
1. 定义一个Scanner 对象，接收用户输入的 价格(String)
2. 希望使用到 StringBuffer的 insert ，需要将 String 转成 StringBuffer
3. 然后使用相关方法进行字符串的处理
代码实现
*/
//new Scanner(System.in)
String price = "8123564.59";
StringBuffer sb = new StringBuffer(price);
//先完成一个最简单的实现123,564.59
//找到小数点的索引，然后在该位置的前3位，插入,即可
//int i = sb.lastIndexOf(".");
//sb = sb.insert(i - 3, ",");
//上面的两步需要做一个循环处理,才是正确的
for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
sb = sb.insert(i, ",");
}
System.out.println(sb);//8,123,564.59
}
}StringBuilder类
一、基本介绍
1.一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。
2.在StringBuilder上的主要操作是 append和insert 方法，可重载这些方法，以接受任意类型的数据。
类结构图
1. StringBuilder 继承 AbstractStringBuilder 类
2. 实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
3. StringBuilder 是final类, 不能被继承
4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value 因此，字符序列是堆中
5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用StringBuilder
public class StringBuilder01 {
public static void main(String[] args) {
//1. StringBuilder 继承 AbstractStringBuilder 类
//2. 实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
//3. StringBuilder 是final类, 不能被继承
//4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value 因此，字符序列是堆中
//5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用StringBuilder
StringBuilder stringBuilder = new StringBuilder();
}
}三个String、StringBuffer 和StringBuilder的比较
1) StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2) String:不可变字符序列，效率低,但是复用率高。（如果相同都指向常量池的）
3) StringBuffer:可变字符序列、效率较高(增删)、线程安全
4) StringBuilder:可变字符序列、效率最高、线程不安全
5) String使用注意说明:
string s="a"; //创建了-一个字符串
s += "b"; //实际上原来的" a"字符串对象已经丢弃了，现在又产生了一个字符串s+ "b" (也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能
结论:如果我们对String做大量修改，不要使用String
效率测试
public class StringVsStringBufferVsStringBuilder {
public static void main(String[] args) {
long startTime = 0L;
long endTime = 0L;
StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000次
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000次
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
String text = "";
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//String 拼接 20000
text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间：" + (endTime - startTime));
}
}
三个String、StringBuffer 和StringBuilder的使用原则
使用的原则，结论:
1.如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
3.如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
4.如果我们字符串很少修改，被多个对象引用，使用String， 比如配置信息等