文章目录
前言
一、常用的方法
1、字符串构造
2、字符串比较
3、字符串查找
4、字符串转化
5、字符串替换
6、字符串分割
7、字符串截取
二、字符串的不可变性
三、StringBuilder、StringBuffer
总结
前言
📕各位读者好, 我是小陈, 这是我的个人主页
📗小陈还在持续努力学习编程, 努力通过博客输出所学知识
📘如果本篇对你有帮助, 烦请点赞关注支持一波, 感激不尽
📙 希望我的专栏能够帮助到你:
JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统等
Java数据结构: 顺序表, 链表, 堆, 二叉树, 二叉搜索树, 哈希表等
JavaEE初阶: 多线程, 网络编程, TCP/IP协议, HTTP协议, Tomcat, Servlet, Linux, JVM等(正在持续更新)
在校招和笔试过程中，字符串是相当频繁被问到的话题，在之前的文章【数据类型与变量】中提到了，Java中设计了一种引用数据类型：String，可以专门来存储字符串。
今天主要介绍不可变的String，以及可变的StringBuilder和StringBuffer
提示：是正在努力进步的小菜鸟一只，如有大佬发现文章欠佳之处欢迎评论区指点~ 废话不多说，直接上干货！
一、常用的方法
1、字符串构造
我们常用的定义一个字符串的方式为：
String str = "我爱你中国";
1
我们知道，String是一个引用数据类型，是一个类，类可以new对象，所以还可以这样定义一个字符串：
String str = new String("我爱你中国");
1
实际上，正因为String是一个类，所以这样的写法才标准，只不过编译器提供了一种简化的写法，就是直接赋值
要学习String这个类，首先要从这个类的构造方法学起
在IDEA中——敲两次shift——导航栏搜索String——选择class——选择String java.lang
就可以看到String这个类中所有的成员属性和方法了
例如：
这只是一部分，也是最常用的三种定义字符串的方式，代码如下：
// 1
String str1 = new String();
str1 = "我爱你中国";
// 2
String str2 = new String("我爱你中国");
// 3
char[] value = {'我','爱','你','中','国'};
String str3 = new String(value);
1
2
3
4
5
6
7
8
简单了解了String类的构造方法之后，需要注意的是：
String 内部并不存储字符串本身
我们打开调试窗口：
可以看到，String类new出来的三个对象中的成员变量都只有两个：value( 数组类型 ) 和 hash
hash有什么作用咱先别管 ，只需看到value这个数组，可以推断，实际上 字符串是被存放在了一个数组中，而数组也是一个引用类型，可以理解为value的值就是数组的地址
例如 str1 这个字符串，可以简单理解为：
2、字符串比较
一般有两种场景：1，字符串是否相同 2，大小是否相等
1，判断字符串是否相同：
String str1 = new String("我爱你中国");
String str2 = new String("我爱你中国");
System.out.println(str1 == str2);
// 输出：false
System.out.println(str1.equals(str2));
// 输出：true
1
2
3
4
5
6
7
因为 str1 和 str2 存储的都是对象的地址，两个对象的地址不同
equals 是用来比较两个引用指向的对象的内容是否一致
2，比较字符串大小关系
String str1 = new String("我爱你中国");
String str2 = new String("我爱你中国");
String str3 = new String("我爱你中国我爱你中国");
System.out.println(str1.compareTo(str2));
// 输出：0
System.out.println(str2.compareTo(str3));
// 输出：-5
1
2
3
4
5
6
7
8
9
compareTo 是用来比较两个引用指向的对象的内容大小关系
比较方式：
先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
String str1 = new String("iloveyou");
String str2 = new String("ILOVEYOU");
System.out.println(str1.compareTo(str2));
// 输出：32
System.out.println(str1.compareToIgnoreCase(str2));
// 输出：0
1
2
3
4
5
6
7
8
compareToIgnoreCase与compareTo方式相同，但是忽略大小写比较
3、字符串查找
方法 功能
char charAt (int index) 返回 index 位置上字符，如果 index 为负数或者越界，抛出 IndexOutOfBoundsException 异常
int indexOf (int ch) 返回 ch 第一次出现的位置，没有返回-1
int indexOf (int ch, intfromIndex) 从 fromIndex 位置开始找 ch 第一次出现的位置，没有返回-1
int indexOf (String str) 返回 str 第一次出现的位置，没有返回-1
int indexOf (String str, intfromIndex) 从 fromIndex 位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf (int ch) 从后往前找，返回 ch 第一次出现的位置，没有返回-1
int lastIndexOf (int ch, intfromIndex) 从 fromIndex 位置开始找，从后往前找 ch 第一次出现的位置，没有返回-1
int lastIndexOf (String str) 从后往前找，返回 str 第一次出现的位置，没有返回-1
int lastIndexOf (String str, intfromIndex) 从 fromIndex 位置开始找，从后往前找 str 第一次出现的位置，没有返回-1
1，char charAt (int index)
String str = "我爱你中国";
System.out.println(str.charAt(0));
// 输出第一个字符：我
System.out.println(str.charAt(10));
// 找不到第10个字符，抛出 IndexOutOfBoundsException 异常
1
2
3
4
5
6
因为字符串存放在数组中，所以编号和数组下标一致，从0开始
2， int indexOf(int ch)
String str = "ababcabcdabcde";
System.out.println(str.indexOf('c'));
// 找到 str 这个字符串中第一次出现 c 的位置，在4下标处
// 输出：4
1
2
3
4
3，int indexOf (int ch, intfromIndex）
多了一个参数，表示起始位置的下标，如果不写第二个参数，默认从0下标处开始找
String str = "ababcabcdabcde";
System.out.println(str.indexOf('c',4));
// 从4位置开始找 输出：4
System.out.println(str.indexOf('c',5));
// 从5位置开始找 输出：7
1
2
3
4
5
4，int indexOf (String str)
String str = "ababcabcdabcde";
System.out.println(str.indexOf("abc"));
// 找字符串 "abc" 在 str 中出现的位置
// 输出：2
1
2
3
4
实现这个方法，有一种比较有难度的算法：KMP算法，感兴趣的小伙伴可以看看我写的这篇文章：大白话式解析KMP算法
5，int indexOf (String str, intfromIndex)
多了一个参数，表示起始位置的下标，如果不写第二个参数，默认从0下标处开始找
String str = "ababcabcdabcde";
System.out.println(str.indexOf("abc"));
System.out.println(str.indexOf("abc",3));
// 从3位置开始找 "abc" 输出：5
1
2
3
4
6，int lastIndexOf (int ch)
方法名多了一个单词：last
这个方法表示从后往前找
String str = "ababcabcdabcde";
System.out.println(str.lastIndexOf('a'));
// 从后往前找到第一次出现字符'a'，返回'a'的下标
// 输出：9
1
2
3
4
7，int lastIndexOf (int ch, intfromIndex)
String str = "ababcabcdabcde";
System.out.println(str.lastIndexOf('a',8));
// 从8位置处开始从后往前找，相当于把8位置当成最后一位
// 输出：5
1
2
3
4
剩下的就不再赘述啦，原理同上
4、字符串转化
1，将数字转字符串：
String str = String.valueOf(123);
System.out.println(str);
1
2
valueOf能转化的类型有很多：
这就是重载的好处，不需要设计那么多方法名
2、字符串转数字：
String str = "123";
int a = Integer.parseInt(str);
System.out.println(a);
1
2
3
3，大小写转化：
String str1 = "love";
String str2 = "LOVE";
System.out.println(str1.toUpperCase());
// 输出：LOVE
System.out.println(str2.toLowerCase());
// 输出：love
1
2
3
4
5
6
4，字符串转数组
String str = "我爱你中国";
char[] array = str.toCharArray();
1
2
5，数组转字符串
char[] array = {'我','爱','你','中','国'};
String str = new String(array);
1
2
5、字符串替换
String str = "abababaabab";
String newStr1 = str.replaceAll('a','b');
// 将字符 'a' 全部替换为 'b'
String newStr1 = str.replaceFirst('a','b');
// 将首个字符 'a' 替换为 'b'
System.out.println(newStr);
// 输出：bbababaabab
1
2
3
4
5
6
7
6、字符串分割
将一个完整的字符串按照指定的分隔符划分为若干个子字符串
1，String[] split (String regex) 将字符串全部拆分
String str = "I LOVE YOU";
String[] strs = str.split(" ");
// 按照空格分割 返回值类型为字符型数组
for (String newstr : strs) {
// 遍历数组
System.out.println(newstr);
}
// 输出：
// I
// LOVE
// YOU
1
2
3
4
5
6
7
8
9
10
11
2，String[] split (String regex, int limit) 将字符串以指定的格式，拆分为 limit 组
String str = "I LOVE YOU";
String[] strs = str.split(" "，2);
// 多了一个参数，表示分割成两组
for (String newstr : strs) {
// 遍历数组
System.out.println(newstr);
}
// 输出：
// I
// LOVE YOU
1
2
3
4
5
6
7
8
9
10
注意：
字符" | "， " + "， " . "， " * " 都得加上转义字符，前面加上 " \ "
而如果是 " \ " ，那么就得写成 " \\ "
如果一个字符串中有多个分隔符，可以用 " | " 作为连字符，例如：
String str = "I-LOVE=YOU";
String[] strs = str.split("-|=");
for (String newstr : strs) {
System.out.println(newstr);
}
// 输出：
// I
// LOVE
// YOU
1
2
3
4
5
6
7
8
9
7、字符串截取
从一个完整的字符串之中截取出部分内容
1，String substring (int beginIndex) 从指定索引截取到结尾
String str = "我爱你中国";
String newstr = str.substring(2);
// 从2下标位置开始，截取之后的所有字符
System.out.println(newstr);
// 输出：你中国
1
2
3
4
5
2，String substring (int beginIndex, int endIndex) 截取部分内容
String str = "我爱你中国";
String newstr = str.substring(2,3);
// 从2下标位置开始，截取到3下标位置（不包含3下标）
System.out.println(newstr);
// 输出：你
1
2
3
4
5
二、字符串的不可变性
为什么说字符串是不可变的呢？
说到字符串的不可变性就要提出“ 常量池 ” 的概念了，这里暂不讲解，随着学习的深入，之后再做分享，现在先简单分析一下：
可以看到第114行 value 这个数组是被 private final 修饰的，那不可变性是因为 private 还是因为 final 呢？
关于 final：
final 修饰类表明该类不想被继承，final 修饰 引用类型 表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的
final int[] array = {1,2,3,4,5};
array[0] = 10;
System.out.println(array[0]);
// 可以改变array指向的对象的值
array = new int[]{1,2,3,4,5};
// 报错，不能再改变array的指向
1
2
3
4
5
6
7
真正使字符串不可变的是因为 private ，把 value 封装起来了，使得value只能在String这个类里面访问，并且String类中没有提供 setter 和 getter 方法，所以不能在String类外范围value
了解即可：
为什么 String 要设计成不可变的?(不可变对象的好处是什么?)
方便实现字符串对象池，如果 String 可变，那么对象池就需要考虑写时拷贝的问题了
不可变对象是线程安全的
不可变对象更方便缓存 hash code，作为 key 时可以更高效的保存到 HashMap 中
三、StringBuilder、StringBuffer
在了解 StringBuilder 和 StringBuffer 之前呢，我们先了解一下字符串拼接
Java提供了使用加号（+）拼接字符串的功能，例如：
public class Test {
public static void main(String[] args) {
String str = "我爱你";
str += "中国";
System.out.println(str);// 输出：我爱你中国
}
}
1
2
3
4
5
6
7
但刚刚说过，字符串是不可修改的，所以这种方式的拼接，并不是对str本身进行修改，而是又 new 了不止一个临时对象，所以这种方式的对字符串的拼接，效率十分低下
如何去证明？打开汇编界面可以证明，博主才疏学浅，就不过多展示了，感兴趣的可以自己去查一下，这里只说结论：
str += "中国";
1
这一行代码，实际上是这四行：
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(str);
stringBuilder.append("中国");
str = stringBuilder.toString();
1
2
3
4
我们知道，双引号括起来的就是一个字符串对象，并且我们摁住 ctrl 点击 toString 方法，就可以看到 toString 方法的返回值处，也 new 了一个对象
再加上 new 出来的 stringBuilder 对象，可以算出，在 “拼接” 这看似一行代码背后
str += "中国";
1
实际上创建了三个临时对象
所以，如果实在循环当中使用加号对字符串进行拼接，效率可不是一般的低呀，接下来我们就要认识一下 StringBuilder 和 StringBuffer
StringBuilder 和 StringBuffer 对比 String 最直接的区别就是，StringBuilder 和 StringBuffer new出来的字符串是可变的
通过 StringBuilder 的 reverse（逆序）方法就可以证明 StringBuilder 的字符串可变性：
public class Test {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("我爱你");
stringBuilder.reverse();
System.out.println(stringBuilder);// 输出：你爱我
}
}
1
2
3
4
5
6
7
这里我们并没有重新重新定义字符串类型的变量，但打印 stringBuilder 的时候却变成了逆序之后的“你爱我”，说明这个字符串本身确实是被修改了
我们还可以通过StringBuilder 的 append（附加）方法再证明一下：
public class Test {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("我爱你");
// stringBuilder.reverse();
stringBuilder.append("中国").append("母亲");
System.out.println(stringBuilder);// 输出：我爱你中国母亲
}
1
2
3
4
5
6
7
这里可以看到，append() 方法甚至可以连续使用
这两个栗子就充分说明了，StringBuilder 实例化出来的对象，调用方法的返回值都是字符串本身（this），所以不会产生临时对象
StringBuffer 同理
Java 中提供的 StringBuilder 和 StringBuffer 这两个类大部分功能是相同的，这两个类有自己的一些方法是 String 类没有的（互补关系），具体在这里不多赘述了，感兴趣的可以自己查一下在线文档
那么这两个类又有什么不同呢？
功能基本都一样，刚刚用 StringBuilder 的代码 StringBuffer 也可以，他俩的区别就是就在于：
说人话：在多线程时，StringBuffer 内置有 “一把锁” ，会相对安全
但是！也不能无脑使用 StringBuffer ，频繁的 “上锁”，“开锁” 的过程也会消耗系统资源的呀，等学习到多线程的时候再做分享~
————————————————
版权声明：本文为CSDN博主「灵魂相契的树」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yzhcjl_/article/details/127937201