目录
一、常用方法
1、字符串构造
2、String对象的比较
（1）、equals方法
（2）、compareTo方法
（3）、compareToIgnoreCase方法（忽略大小写进行比较）
3、字符串查找
4、转化
（1）数值和字符串转化
编辑
（2）大小写转换
（3）字符串转数组
（4）格式化
5、字符串替换
6、字符串拆分
7、字符串截取
8、其他操作方法
二、String的不可变性
三、StringBuffer和StingBuilder
1、方法：
2、String、StringBuffer、StringBuilder的区别
一、常用方法
1、字符串构造
三种构造方法
（1）、直接赋值
String s1 = "hello world";
System.out.println(s1);（2）、创建出新的对象
String s2 = new String("hello");
System.out.println(s2);（3）、使用字符数组进行构造
char[] ch = {'h','e','l','l','o'};
String s3 = new String(ch);
System.out.println(s3);三个输出效果如下：
2、String对象的比较
对于基本变量，可以直接用 “==， <， >， <=， >= ”来进行比较，但对于引用类型变量，不可以直接使用上面的表达式来比较，如图：
代码：
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2);
s1和s2的内容都是一样的，为啥下面输出false呢？
原因是s1和s2是引用类型，使用上述表达式进行比较，比较的是两个对象的地址，两个对象是不同的，地址自然也是不同的。
那么怎么可以比较引用对象的内容呢？有以下方法：
（1）、equals方法
按照字典序比较，字典序：字符大小。
Object的equals默认是按 “==” 进行比较的，如图：
所以类都默认继承Object类，String继承Object类，重写了equals方法，如图：
方法的使用：
代码：
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1.equals(s2)); String s3 = new String("Hello"); System.out.println(s1.equals(s3));执行效果：
（2）、compareTo方法
按照字典序比较，和equals方法不同的是：equals返回的是boolean类型，而compareTo返回的是int类型，具体比较方式：
1、先按照字典序大小比较，如果出现不相等的字符，直接返回这两个字符的大小差值。
2、如果前k个字符相同，返回两个字符串长度差值。
方法内部：
public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; }方法使用：
代码：
String s1 = new String("ab"); String s2 = new String("ac"); String s3 = new String("ab"); 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执行效果：
（3）、compareToIgnoreCase方法（忽略大小写进行比较）
与compareTo方法一样，不过忽略大小写
方法内部：
public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator(); private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable { // use serialVersionUID from JDK 1.2.2 for interoperability private static final long serialVersionUID = 8575799808933029326L; public int compare(String s1, String s2) { int n1 = s1.length(); int n2 = s2.length(); int min = Math.min(n1, n2); for (int i = 0; i < min; i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (c1 != c2) { c1 = Character.toUpperCase(c1); c2 = Character.toUpperCase(c2); if (c1 != c2) { c1 = Character.toLowerCase(c1); c2 = Character.toLowerCase(c2); if (c1 != c2) { // No overflow because of numeric promotion return c1 - c2; } } } } return n1 - n2; }方法的使用：
代码：
String s1 = new String("hello"); String s2 = new String("Hello"); System.out.println(s1.compareToIgnoreCase(s2));执行效果：
3、字符串查找
方法 功能 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第一次出现的位置，没有返
回-1int lastIndexOf(String str) 从后往前找，返回str第一次出现的位置，没有返回-1 int lastIndexOf(String str, int
fromIndex)从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返
回-1
4、转化
（1）数值和字符串转化
数值转字符串：
String s1 = String.valueOf(1234); String s2 = String.valueOf(12.34); System.out.println(s1); System.out.println(s2); System.out.println("=============="); String s3 = String.valueOf(true); String s4 = String.valueOf(new Student("Hanmeimei", 18)); System.out.println(s3); System.out.println(s4);
整型转换为字符串型的内部代码：
public static String valueOf(int i) { return Integer.toString(i); }double类型转换为字符串型代码：
public static String valueOf(double d) { return Double.toString(d); }boolean转换为字符串的内部代码：
public static String valueOf(boolean b) { return b ? "true" : "false"; }引用类型转换为字符串型的内部代码：
public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }
字符串转换为整型 / double类型：
代码：
int data1 = Integer.parseInt("1234"); Double data2 = Double.parseDouble("12.34");如图，执行效果：
（2）大小写转换
代码:
String s1 = "hello"; String s2 = "HELLO"; //小写转大写 System.out.println(s1.toUpperCase()); //大写转小写 System.out.println(s2.toLowerCase());执行效果：
（3）字符串转数组
代码：
//字符串转数组 char[] ch = s1.toCharArray(); //数组转字符串 String s2 = new String(ch);执行效果
（4）格式化
代码：
String s = String.format("%d-%d-%d", 2023, 11, 21);执行效果：
5、字符串替换
使用一个新的字符串替换旧的字符串，方法如下：
| 方法 | 功能 |
| String replaceAll(String regex, String replacement) | 替换所有的指定内容 |
| String replaceFirst(String regex, String replacement) | 替换首个内容 |
代码：
String str = "hello world"; System.out.println(str.replaceAll("l", "-")); System.out.println(str.replaceFirst("l", "-"));执行效果：
6、字符串拆分
可以将一个完整的字符串按照指定的分隔符划分成若干个字符子串
| 方法 | 功能 |
| String[] split(String regex) | 将字符串全部拆分 |
| String[] split(String regex, int limit) | 将字符串以指定的格式，拆分为limit组 |
代码：
String s1 = "hello world hello bit"; String[] result = s1.split(" "); for(String x : result) { System.out.println(x); }执行效果：
字符串的部分拆分代码：
String s1 = "hello world hello bit"; String[] result = s1.split(" ", 2); for(String x : result) { System.out.println(x); }
拆分IP地址：
String s1 = "192.168.1.1"; String[] result = s1.split("\\."); for(String x : result) { System.out.println(x); }执行效果：
注意：要写划分ip地址，在字符串里写进转义字符，在字符串里，两个 “ \\ ” 代表一个 “ \ ”
1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .
2. 而如果是 "\" ，那么就得写成 "\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.如下：
String s1 = "192.16-8.1.1"; String[] result = s1.split("\\.|-"); for(String x : result) { System.out.println(x); }
代码示例: 多次拆分
String str = "name=zhangsan&age=18" ; String[] result = str.split("&") ; for (int i = 0; i < result.length; i++) { String[] temp = result[i].split("=") ; System.out.println(temp[0]+" = "+temp[1]); }
7、字符串截取
从一个完整的字符串截取出部分内容，方法如下：
| 方法 | 功能 |
| String substring(int beginIndex) | 从指定索引截取到结尾 |
| String substring(int beginIndex, int endIndex) | 截取部分内容 |
代码：
String s = "helloworld"; System.out.println(s.substring(5)); System.out.println(s.substring(0, 5));执行效果：
注意：区间是是前闭后开的规则，上面的第二个substring语句，是 [0,5）。所以不包含5下标。
8、其他操作方法
| 方法 | 功能 |
| String trim() | 去掉字符串中的左右空格,保留中间空格 |
| String toUpperCase() | 字符串转大写 |
| String toLowerCase() | 字符串转小写 |
trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
后面两个函数只转换字母
二、String的不可变性
String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：
1. String类在设计时就是不可改变的，String类实现描述中已经说明了
String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：
1. String类被final修饰，表明该类不能被继承。
2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
比如 replace 方法：
原因不是final，
final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的
代码验证如下：final int array[] = {1,2,3,4,5}; array[0] = 100; System.out.println(Arrays.toString(array)); //array = new int[]{4,5,6}; //java: 无法为最终变量array分配值执行效果：
注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下，尽量避免对String的直接修改，如果要修改建议尽量使用StringBuffer或者StringBuilder。
三、StringBuffer和StingBuilder
1、方法：
| 方法 | 说明 |
| 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的内容可以修改。
和StringBuffer的区别也是。频繁修改字符串的情况考虑使用StringBuilder / StringBuffer。
2、String、StringBuffer、StringBuilder的区别
（1）String的内容不可修改，StringBuffer和StringBuilder的内容可修改。
（2）StringBuffer和StringBuilder的大部分功能一样。
（3）StringBuffer采用同步处理，属于线程安全操作，StringBuilder未采用同步处理，不属于线程安全操作。
