目录
一、定义与概述
二、创建字符串对象
2.1 直接赋值
2.2 使用构造函数
三、字符串的不可变性
四、常用方法
4.1 String对象的比较
4.1.1 ==比较是否引用同一个对象
4.1.2 boolean equals(Object anObject)方法：按照字典序比较
4.1.3 int compareTo(String s)方法: 按照字典序进行比较
4.1.4 int compareToIgnoreCase(String str)方法：
4.2 字符串查找
4.2 转化
4.3 字符串替换
4.4 字符串拆分
4.5 字符串截取
4.6 其他操作
五、StringBuilder和StringBuffer
一、定义与概述
在Java中，Sting类是用来表示字符串的。字符串是一个字符序列，例如"Hello, World! "。String类位于 java.lang 包中，这个包是Java语言的核心包之一，不需要显示导入就可以使用。
二、创建字符串对象
2.1 直接赋值
可以通过直接使用双引号来创建String对象，例如：String str = "Hello, World! " 。这种方式创建的字符串，在 Java 的字符串常量池中会检查是否已经存在相同内容的字符串。如果存在，就直接引用该字符串对象；如果不存在，则在常量池中创建一个新的字符串对象。
代码如下：
public class Test1 {
public static void main(String[] args) {
String str = "Hello, World! ";
}
}2.2 使用构造函数
String()：创建一个空字符串对象。例如：String str1 = new String();
String(String original): 使用另一个字符串来创建新的字符串对象。String str2 = new String("Another Java String");
String(char[] value): 通过字符数组来创建字符串,例如：char[] chars = {'h','e','l','l','o'};
String str3 = new String(chars); 这里str3的值就是"hello"。
上述代码：
public class Test1 {
public static void main(String[] args) {
String str = "Hello, World! ";
String str1 = new String();
String str2 = new String("Another Java String");
char[] chars = {'h','e','l','l','o'};
String str3 = new String(chars);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
}
输出：
三、字符串的不可变性
String类是不可变的（immutable）。这意味着一旦一个String对象被创建，它的值就不能被改变。例如：
String str = "Java";
str = str + " is fun";在这个例子中，看起来好像是改变了 str 的值，但实际上并不是。当执行 str = str + " is fun"这一行时，会创建一个新的 String 对象，其内容是 "Java is fun"，然后 str 变量会指向这个新创建的对象，原来的 "Java" 字符串对象仍然存在于内存中（如果没有其他引用指向它，它会在适当的时候被垃圾回收）。
String类在设计时就是不可改变的，String类实现描述中已经说明了
1. String类被final修饰，表明该类不能被继承
2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。
四、常用方法
4.1 String对象的比较
4.1.1 ==比较是否引用同一个对象
注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。
public class Test2 {
public static void main(String[] args) {
int a=100;
int b=200;
int c=200;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); //false
System.out.println(b == c); //true
System.out.println("===========");
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
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
}
}输出：
如果写成下面的形式，会输出true。因为s5 创建后 hello会被放入字符串常量池，就会认为s5 和s6引用的时同一对象。
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);4.1.2 boolean equals(Object anObject)方法：按照字典序比较
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后。
下面是String类重写equals方法的实现规则
public class Test3 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");
System.out.println(s1.equals(s2));//true
System.out.println(s2.equals(s3));//false
}
}输出截图：
equals比较：String对象中的逐个字符。虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true 。s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false。
4.1.3 int compareTo(String s)方法: 按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值。
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值。
public class Test4 {
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.1.4 int compareToIgnoreCase(String str)方法：
与compareTo方式形同，但是忽略大小写。
public class Test5 {
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));
System.out.println(s1.compareToIgnoreCase(s3));
System.out.println(s1.compareToIgnoreCase(s4));
}
}输出截图：
4.2 字符串查找
| 方法 | 功能 |
| char charAt(int index) | 返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常。 |
| int indexOf(int ch) | 返回ch第一次出现的位置，没有返回-1 |
| int indexOf(int ch, int fromIndex) | 从fromIndex位置开始找ch第一次出现的位置，没有返回-1 |
| int indexOf(String str) | 返回str第一次出现的位置，没有返回-1 |
| int indexOf(String str, int fromIndex) | 从fromIndex位置开始找str第一次出现的位置，没有返回-1 |
| int lastIndexOf(int ch) | 从后往前找，返回ch第一次出现的位置，没有返回-1 |
| int lastIndexOf(int ch, int fromIndex) | 从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返 回-1 |
| int lastIndexOf(String str) | 从后往前找，返回str第一次出现的位置，没有返回-1 |
| int lastIndexOf(String str, int fromIndex) | 从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返 回-1 |
public class Test6 {
public static void main(String[] args) {
String s = "abccbaabccba";
System.out.println(s.charAt(2)); // 'c'
System.out.println(s.indexOf('c'));// 2
System.out.println(s.indexOf('a',2));// 5
System.out.println(s.indexOf("aa"));// 5
System.out.println(s.indexOf("cc",4));//8
System.out.println(s.lastIndexOf('c'));//9
System.out.println(s.lastIndexOf('b',11));//10
System.out.println(s.lastIndexOf("aa"));//5
System.out.println(s.lastIndexOf("aa",4));//-1
}
}运行截图：
4.2 转化
1. 数值和字符串转化
class Student{
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "name=" + name + ", age=" + age ;
}
}
public class Test7 {
public static void main(String[] args) {
//其它类型转化成字符串
String s1 = String.valueOf(1000);
String s2 = String.valueOf('a');
String s3 = String.valueOf(12.34);
String s4 = String.valueOf(new Student("zhangsan",13));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
//字符串转化数字
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}
}运行截图：
2. 大小写转换
public class Test8 {
public static void main(String[] args) {
String s1 = "abc";
//小写转换大写
System.out.println(s1.toUpperCase());
String s2 = "ABC";
//大写转换小写
System.out.println(s2.toLowerCase());
}
}运行截图：
3. 字符串转数组
public class Test9 {
public static void main(String[] args) {
String s = "hello";
//字符串转化数组
char[] chars = s.toCharArray();
for (char ch : chars) {
System.out.print(ch + " ");
}
System.out.println();
//数组转换字符串
char[] chars1 = {'w','o','r','l','d'};
String s1 = new String(chars1);
System.out.println(s1);
}
}运行截图：
4. 格式化
public class Test9 {
public static void main(String[] args) {
String s = String.format("%d-%d-%d",2024,11,29);
System.out.println(s);
}
}运行截图：
4.3 字符串替换
使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：
| 方法 | 功能 |
| String replaceAll(String regex, String replacement) | 替换所有的指定内容 |
| String replaceFirst(String regex, String replacement) | 替换首个内容 |
public class Test9 {
public static void main(String[] args) {
String s = "abccba";
System.out.println(s.replaceAll("c", "_"));
System.out.println(s.replaceFirst("c","-"));
}
}运行截图：
注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。
4.4 字符串拆分
可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
| 方法 | 功能 |
| String[] split(String regex) | 将字符串全部拆分 |
| String[] split(String regex, int limit) | 将字符串以指定的格式，拆分为limit组 |
public class Test9 {
public static void main(String[] args) {
String s = "2024-11-29";
String[] strings = s.split("-");
for (String str :strings){
System.out.print(str+" ");
}
System.out.println();
String[] strings1 = s.split("-",2);
for (String str : strings1){
System.out.print(str+" ");
}
}
}注意事项：
1. 字符"|","*","+"都得加上转义字符，前面加上"\\".
2. 而如果是"\"，那么就得写成"\\\\".
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.
多次拆分：
public class Test9 {
public static void main(String[] args) {
String s = "name=zhangsan&age=18";
String[] strings = s.split("&");
for (String str : strings){
String[] strings1 = str.split("=");
System.out.println(strings1[0]+" "+strings1[1]);
}
}
}输出截图：
4.5 字符串截取
从一个完整的字符串之中截取出部分内容。
| 方法 | 功能 |
| String substring(int beginIndex) | 从指定索引截取到结尾 |
| String substring(int beginIndex, int endIndex) | 截取部分内容 |
public class Test9 {
public static void main(String[] args) {
String s = "abcdefghijk";
System.out.println(s.substring(5));
System.out.println(s.substring(3, 6));//左闭右开
}
}运行截图：
注意事项：
1. 索引从0开始
2. 注意前闭后开区间的写法, substring(3, 6) 表示包含 3 号下标的字符, 不包含 6 号下标
4.6 其他操作
| 方法 | 功能 |
| String trim() | 去掉字符串中的左右空格,保留中间空格 |
trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
public class Test9 {
public static void main(String[] args) {
String s = " hello \t\t";
System.out.println(s);
System.out.println(s.trim());
}
}运行截图：
五、StringBuilder和StringBuffer
因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。
public class Demo1 {
public static void main(String[] args) {
//获得毫秒级时间戳
long start = System.currentTimeMillis();
String s = "";
for (int i = 0; i < 10000; i++) {
s += i;
}
long end = System.currentTimeMillis();
System.out.println(end - start);
start = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
stringBuilder.append(i);
}
end = System.currentTimeMillis();
System.out.println(end - start);
}
}运行截图：
由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的。
| 方法 | 功能 |
| StringBuff append(String str) | 在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量 |
| char charAt(int index) | 获取index位置的字符 |
| int length() | 获取字符串的长度 |
| int capacity() | 获取底层保存字符串空间总的大小 |
| void ensureCapacity(int mininmumCapacity) | 扩容 |
| void setCharAt(int index, char ch) | 将index位置的字符设置为ch |
| int indexOf(String str) | 返回str第一次出现的位置 |
| int indexOf(String str, int fromIndex) | 从fromIndex位置开始查找str第一次出现的位置 |
| int lastIndexOf(String str) | 返回最后一次出现str的位置 |
| int lastIndexOf(String str, int fromIndex) | 从fromIndex位置开始找str最后一次出现的位置 |
| StringBuff insert(int offset, String str) | 在offset位置插入：八种基类类型 & String类型 & Object类型数据 |
| StringBuffer deleteCharAt(int index) | 删除index位置字符 |
| StringBuffer delete(int start, int end) | 删除[start, end)区间内的字符 |
| StringBuffer replace(int start, int end, String str) | 将[start, end)位置的字符替换为str |
| String substring(int start) | 从start开始一直到末尾的字符以String的方式返回 |
| String substring(int start，int end) | 将[start, end)范围内的字符以String的方式返回 |
| StringBuffer reverse() | 反转字符串 |
| String toString() | 将所有字符按照String的方式返回 |
String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可 以修改。频繁修改字符串的情况考虑使用StringBuilder。
注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法。