认识String类
前面我们学习了类和对象，这一小节咱们来谈String类
目录
- 认识String类
- 前言
- 一、String类的创建方式
- 二、String引用类型的特点及方法
- 1.存储内容
- 2.String对象的比较
- 3.字符串查找
- 在这里插入图片描述
- 4.转换
- （一）数字转为为字符串
- （二）字符串转化为数字
- （三）大小写转换
- 5.替换、拆分和截取
- （一）替换：replace/replaceAll 和 replaceFirst
- （二）拆分：spilt
- （三）截取：subString
- 三、字符串的不可变性
- 四、StringBuilder 和 StringJoiner
- 总结
前言
在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。
提示：以下是本篇文章正文内容，下面案例可供参考
一、String类的创建方式
1.直接赋值法
String str1 = "abc";
2.new一个对象
// 空参构造 str3引用了一个空白字符
String str3 = new String();
// 有参构造
String str2 = new String("Hello world");
这种创建方式类似与之前学的类中的构造方法
3.字符数组构造字符串
char[] arr = {'a','b','c','d'};
String ret = new String(arr);
二、String引用类型的特点及方法
1.存储内容
代码如下（示例）：
public static void main(String[] args) {
//直接赋值法
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
//new 创建一个对象
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s3 == s4);
}
运行结果为
为什么是这个结果？
下面我们看内存图
原因是 先直接复值定义了s1这个字符串，编译器会在串池里面找是否存在这个字符串的内容 不存在就在串池里面放上这个字符串的内容 并且把这个地址分配给栈区的变量s1，同理 s2 的内容与s1相同就直接把这个地址给到s2
在引用数据类型中
栈内存区里面存的是方法名 和局部变量及其内容的地址
而在堆内存区中存的是 new出来的对象 和 串池
串池里面存储的内容是直接赋值的字符串也叫常量字符串，这个里面的内容不可更改！
总的就是
下面是new出来的对象
new出来的是一个新对象 s1和s2 里面存的是地址
看图即可
2.String对象的比较
1. ==比较是否引用同一个对象
注意：对于内置类型，== 比较的是变量中的值；对于引用类型 ==比较的是引用中的地址。
基本类型
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
引用类型
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
2. boolean equals(Object anObject) 方法：按照字典序比较
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照
如下规则进行比较，比如： s1.equals(s2)
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
3. int compareTo(String s) 方法: 按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
- 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
- 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}
4. int compareToIgnoreCase(String str) 方法
与compareTo方式相同，但是忽略大小写比较
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}
3.字符串查找
这些方法不需要记忆，需要用到死自行查找即可
=========下面我们将来演示部分代码，便于记忆
1. charAt 用于遍历字符串 获取其中每一个字符，返回值为 char
2. indexof用于查找字符串中的某一个字符所在的索引（字符数组下标）返回值为 int
传两个参表示从某个范围开始依次寻找，还可以传进一个字符串
public static void main(String[] args) {
String s = "abcdefacefg";
System.out.println(s.charAt(4));// e
System.out.println(s.indexOf('c'));//2
System.out.println(s.indexOf('c',5));//7
System.out.println(s.indexOf("def"));//3
}
4.转换
（一）数字转为为字符串
方法：String.valueOf(基本类型数据)；
int n = 123;
double d = 12.34;
boolean flag = true;
String s1 = String.valueOf(n);
String s2 = String.valueOf(d);
String s3 = String.valueOf(flag);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
此时s1,s2,s3 中存储的就是字符串；
（二）字符串转化为数字
包装类型.parse+对应的类型（“字符串”）
parse 的中文意思是解析
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
其中Integer 是int的包装 是引用类型 ，Double是double的包装 是引用类型
（三）大小写转换
方法：toUpperCase and toLowerCase
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
小写转大写
System.out.println(s1.toUpperCase());
大写转小写
System.out.println(s2.toLowerCase());
}
当然还有更多其他转换 请大家自己总结~~！
5.替换、拆分和截取
（一）替换：replace/replaceAll 和 replaceFirst
String s1 = "aabbccbbeeff";
String s2 = s1.replace("b","g");
String s3 = s1.replaceFirst("b","g");
把字符串中的某个字符所有变成另一个字符
System.out.println(s2);结果为 aaggccggeeff
把字符串中的某个字符出现的第一次字符变成另一个字符
System.out.println(s2);结果为 aagbccbbeeff
注意：这里返回的是一个新的字符串，s1不变
（二）拆分：spilt
String str = "hello world hello world" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
System.out.println(s);
}
运行结果：
拆分还可以构成重载 以下表示以“ ”的分割 分成两组
String str = "hello world hello world" ;
String[] result = str.split(" ",2) ;
for(String s: result) {
System.out.println(s);
}
注意这里返回的是字符串数组，拆分方法根据实际需求区实现不同方法
（三）截取：subString
String str = "helloworld" ;
System.out.println(str.substring(5));//从指定索引截取到结尾
System.out.println(str.substring(0, 5));//截取部分内容
运行结果：
- 索引从0开始
- 注意前闭后开区间的写法, substring(0, 5) 表示 左闭右开 的规则
三、字符串的不可变性
String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：
1. String类在设计时就是不可改变的，String类实现描述中已经说明了
String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：
String类被final修饰，表明该类不能被继承
value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
为什么 String 要设计成不可变的?(不可变对象的好处是什么?)
- 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.
- 不可变对象是线程安全的.
- 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中
四、StringBuilder 和 StringJoiner
两者可以看成是一个容器，创建之后里面的内容是可变的
因此实现拼接的效率逼string高，从而提高了字符串的效率
StringBuilder的构造方法
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder("abc");
StringBuilder和StringJoiner的常用方法
总结
提示：这里对文章进行总结：
-
String
表示字符串的类，定义了很多操作字符串的方法 -
StringBuilder
一个可变的操作字符串的容器。
可以高效的拼接字符串，还可以将容器里面的内容进行反转。 -
StringJoiner
JDK8出现的一个可变的操作字符串的容器，可以高效，方便的拼接字符串。
