目录
String类
常用方法
字符串的不可变性
String的内存分析
StringBuilder类
解释可变和不可变字符串
常用方法
面试题：String，StringBuilder，StringBuffer之间的区别和联系
String类的OJ练习
String类
【1】直接使用，无需导包：
【2】形象说一下字符串：
【3】
String str = “abc”;
"abc"就是String类下的一个具体的对象
【4】字符串是不可变的：
【5】这个String类不可以被继承，不能有子类：
【6】String底层是一个char类型的数组
验证：
注意：没有用'\0'来标识结尾
String类中的字符实际保存在内部维护的value字符数组中
value被final修饰，表明value自身的值不能改变，即不能引用其它字符数组
但是其引用空间中的内容可以修改。
常用方法
【1】构造器：底层就是给对象底层的value数组进行赋值操作。
//通过构造器创建对象：
String s1 = new String();
String s2 = new String("abc");
String s3 = new String(new char[]{'a', 'b', 'c'});【2】常用方法：
String s4= "abc";
System.out.println("字符串的长度为："+s4.length());
String s5 = new String("abc");
System.out.println("字符串是否为空："+s5.isEmpty());
System.out.println("获取字符串的下表对应的字符为："+s5.charAt(1));【3】equals:比较两个值的内容是否相同
String s6 = new String("abc");
String s7 = new String("abc");
System.out.println(s6.equals(s7));
/*String s6 = new String("abc");
String s7 = new String("abc");
System.out.println(s6.equalsIgnoreCase(s7));//忽略大小写*/equals底层：
【4】String类实现了Comparable接口，里面有一个抽象方法叫compareTo，所以String中一定要对这个方法进行重写：
比较两个值的内容的大小，相等返回0，大于返回一个整数，小于返回一个负数
String s8 = new String("abc");
String s9 = new String("accdef");
System.out.println(s8.compareTo(s9));
/*String s8 = new String("abc");
String s9 = new String("Abc");
System.out.println(s8.compareToIgnoreCase(s9));//忽略大小写
*/compareTo底层：
【5】其它常用方法：
//字符串的截取：
String s10 = "abcdefghijk";
System.out.println(s10.substring(3));
System.out.println(s10.substring(3,6));//[3,6)
//字符串的拼接/合并：
System.out.println(s10.concat("pppp"));
//字符串中的字符的替换：
String s11 = "abcdeahija";
System.out.println(s11.replace('a','u'));
//按照指定的字符串进行分裂为数组的形式：
String s12 = "a-b-c-d-e-f";
String[] strs = s12.split("-");
System.out.println(Arrays.toString(strs));
//转大小写的方法：
String s13 = "abc";
System.out.println(s13.toUpperCase());
System.out.println(s13.toUpperCase().toLowerCase());
//去除首尾空格：
String s14 = " a b c ";
System.out.println(s14.trim());
//toString()
String s15 = "abc";
System.out.println(s15.toString());
//转换为String类型：传入任何类型的数据都将转换为String类型
System.out.println(String.valueOf(String.valueOf(false)));【6】String类的练习：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String str = " hello themyth ";
System.out.println(str);
String ret = str.trim();//去掉的字符串开头和结尾的空白字符(空格、换行、制表符等)
System.out.println(ret);
String string = "themyth@ws";
System.out.println(string.contains("ws"));//判断字符串里面是否包含了这个内容。
}
//这是一个main方法，是程序的入口：
public static void main2(String[] args) {
//字符串的拆分：
String str1 = "hello handsome themyth";
String[] strs = str1.split(" ");
/*for (String s : strs) {
System.out.println(s);
}*/
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
//hello
//handsome
//themyth
}
String[] strs2 = str1.split(" ", 2);
for (int i = 0; i < strs2.length; i++) {
System.out.println(strs2[i]);
//hello
//handsome themyth
}
String str2 = "192.168.0.1";
String[] strs3 = str2.split("\\.");
for (int i = 0; i < strs3.length; i++) {
System.out.println(strs3[i]);
//192
//168
//0
//1
}
System.out.println("===");
String str3 = "192\\168\\0\\1";
String[] strs4 = str3.split("\\\\");// "\\"表示一个"\"
for (int i = 0; i < strs4.length; i++) {
System.out.println(strs4[i]);
//192
//168
//0
//1
}
System.out.println("===");
String str4 = "192&168=1";
String[] strs5 = str4.split("&|=");//
for (int i = 0; i < strs5.length; i++) {
System.out.println(strs5[i]);
//192
//168
//1
}
System.out.println("===");
//多次拆分：
String message = "name=themyth&age=22";
String[] ms = message.split("&|=");
for (String s : ms) {
System.out.println(s);
//name
//themyth
//age
//22
}
System.out.println("===");
String message2 = "name=themyth&age=22";
String[] ms2 = message2.split("&");
for (int i = 0; i < ms2.length; i++) {
String[] ms3 = ms2[i].split("=");
for (String s : ms3) {
System.out.println(s);
//name
//themyth
//age
//22
}
}
//字符串的截取：
String str = "abcdefgh";
String s1 = str.substring(2);//cdefgh 返回从2位置开始所截去的字符
System.out.println(s1);
String s2 = str.substring(2,6);//cdef 截取下标区间[2,6)的字符
System.out.println(s2);
}
//这是一个main方法，是程序的入口：
public static void main1(String[] args) {
String str1 = "themyth";
char ch = str1.charAt(1);//h 下标对应的字符
System.out.println(ch);
for (int i = 0; i < str1.length(); i++) {
if (i != str1.length() - 1) {
System.out.print(str1.charAt(i) + " ");
} else {
System.out.println(str1.charAt(i));
}
}//t h e m y t h
String str2 = "ababcabcabc";
int b = str2.indexOf('b');//1 字符第一次出现位置的下标，默认从下标为0开始查找
System.out.println(b);
int b1 = str2.indexOf('b', 5);//6 从下标为5的字符开始查找，字符第一次出现位置的下标
System.out.println(b1);
//在主串中 查找子串
int abc = str2.indexOf("abc");
System.out.println(abc);//2 返回"abc"首字符a第一次出现的位置
int b2 = str2.lastIndexOf('b');//9 从后往前找，字符第一次出现位置的下标
System.out.println(b2);
int b3 = str2.lastIndexOf('b', 5);//3 从下标为5的字符从后往前开始查找，字符第一次出现位置的下标
System.out.println(b3);
int b4 = str2.lastIndexOf("abc", 7);//5 从下标为7的字符从后往前找子串，如果找到了第一个能够匹配的字串，返回该子串的第一个字符
System.out.println(b4);
String str3 = String.valueOf(123);//将...转换为字符串
System.out.println(str3);
String str4 = "123";
int data = Integer.parseInt(str4);
System.out.println(data);
Double data2 = Double.parseDouble(str4);
System.out.println(data2);//123.0
String str5 = "TheMyth";
String str6 = "themyth";
System.out.println(str5.toLowerCase());//themyth
System.out.println(str6.toUpperCase());//THEMYTH
String str7 = "abcdef";
char[] chars = str7.toCharArray();//字符串--->字符数组
for (int i = 0; i < chars.length; i++) {
if (i != chars.length - 1) {
System.out.print(chars[i] + " ");
} else {
System.out.println(chars[i]);
}
}//a b c d e f
String str8 = new String(chars);//字符数组->字符串
System.out.println(str8);
String str9 = String.format("%d-%d-%d", 2021, 6, 16);//格式化打印（用的很少）
System.out.println(str9);
//参数不同。replace的参数是char和CharSequence，即可以支持字符的替换，也支持字符串的替
//换；replaceAll的参数是regex，即基于规则表达式的替换。
//替换方式不同。replace是全部替换，即把源字符串中的某一字符或字符串全部换成指定的字符或
//字符串；replaceAll也是全部替换，但如果所用的参数据不是基于规则表达式的，则只替换第一
//次出现的字符串。
String str10 = "abcabcdabcde";
String replace = str10.replace('a', 'o');//obcobcdobcde
System.out.println(replace);
String replace1 = str10.replace("abc", "x");//xxdxde
System.out.println(replace1);
String replace2 = str10.replaceAll("abc", "ooo");//oooooodooode
System.out.println(replace2);
String replace3 = str10.replaceFirst("abc", "520");//520abcabcde
System.out.println(replace3);
//注意：字符串是不可变的对象，替换不修改当前字符串！
}
}字符串的不可变性
所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
例如：substring，返回的都是一个新的字符串对象
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1 == str2);//false
}
}
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);//true
}
}
总结：“”双引号里面的值存在字符串常量池中，
如果已经存过一次了，就不会进行第二次存储，
直接返回字符串常量池的对象即可
【纠正】网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。
final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。
例如：
import java.util.Arrays;
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
final int[] array = new int[]{1, 2, 3, 4};
array[0] = 666;//指向的内容可以修改
//array = new int[]{1, 2, 3, 4, 5};指向本身不能修改
System.out.println(Arrays.toString(array));//[666, 2, 3, 4]
}
}
真实的原因是：
在String类中是压根拿不到value[ ]的值，因为根本就没有提供设置和获取value的方法
所以字符串不可变的
为什么 String 要设计成不可变的?(不可变对象的好处是什么?)
1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.
2. 不可变对象是线程安全的.
3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.
String的内存分析
【1】字符串拼接：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String s1 = "a"+"b"+"c";
String s2 = "ab"+"c";
String s3 = "a"+"bc";
String s4 = "abc";
String s5 = "abc"+"";
}
}上面的字符串，会进行编译器优化，直接合并成为完整的字符串，我们可以反编译验证：
然后在常量池中，常量池的特点是第一次如果没有这个字符串，就放进去，如果有这个字符串，就直接从常量池中取：
内存：
【2】new关键字创建对象：
String s6 = new String("abc");
内存：开辟两个空间（1.字符串常量池中的字符串 2.堆中的开辟的空间）
【3】有变量参与的字符串拼接：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String a = "abc";
String b = a + "def";
System.out.println(b);
}
}a变量在编译的时候不知道a是“abc”字符串，所以不会进行编译期优化，不会直接合并为“abcdef”
反汇编过程：为了更好的帮我分析字节码文件是如何进行解析的：
利用IDEA中的控制台：
字符串修改：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
/*String str = "hello";
str += "abc";
System.out.println(str);
for (int i = 0; i < 10; i++) {
str += "abc";//不建议在循环中使用+对字符进行拼接，要创建很多临时的对象，效率低
}*/
//在底层的代码：
String str = "hello";//对象
StringBuilder sb = new StringBuilder();//对象
sb.append(str);
sb.append("abc");//对象
str = sb.toString();//对象
//共创建了4个对象，所以上面那种写法很不好，如果还是在循环里面进行字符拼接，那效率更低
System.out.println(str);
}
}尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。
public class Test {
//这是一个main方法，是程序的入口：
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();
StringBuffer sbf = new StringBuffer("");
for (int i = 0; i < 10000; ++i) {
sbf.append(i);
}
end = System.currentTimeMillis();
System.out.println(end - start);
start = System.currentTimeMillis();
StringBuilder sbd = new StringBuilder("");
for (int i = 0; i < 10000; ++i) {
sbd.append(i);
}
end = System.currentTimeMillis();
System.out.println(end - start);
}
}
可以看到在对String类进行修改时，效率是非常慢的，
因此：尽量避免对String的直接修改，如果要修改建议尽量使用StringBuffer或StringBuilder
StringBuilder类
【1】字符串的分类：
（1）不可变字符串：String
（2）可变字符串：StringBuilder，StringBuffer
【2】StringBuilder底层：非常重要的两个属性：
【3】对应内存分析：
从源码分析：
因为value数组被使用了，所以count的值要发生改变
最后返回当前构建的那个对象，实际上在底层就是返回一个复制之后的数组。
注意：count是StringBuilder底层那个value数组被使用的长度
上述说的第几步到第几步不是真正程序执行的步骤，是自定义，方便自己理解的步骤。
从源码分析新传入的7个o在底层怎样运作的：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建StringBuilder的对象：
StringBuilder sb3 = new StringBuilder();
//表面上调用StringBuilder的空构造器，实际底层是对value数组进行初始化，长度为16
StringBuilder sb2 = new StringBuilder(3);
//表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层就是对value数组进行初始化，长度为你传入的数字
StringBuilder sb = new StringBuilder("abc");
System.out.println(sb.append("def").append("aaaaaaaa").append("bbb").append("ooooooo").toString());//链式调用方式：return this
}
} 
解释可变和不可变字符串
【1】String---》不可变
【2】StringBuilder---》可变
可变，在StringBuilder这个对象的地址不变的情况下，想把“abc”变成“abcdef”是可能的，直接追加即可
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
System.out.println(sb.append("abc") == sb.append("def"));//true，同一个对象
}
}常用方法
【1】StringBuilder常用方法：
public class TestStringBuilder {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("nihaojavawodeshijie");
//增
sb.append("这是梦想");
System.out.println(sb);//nihaojavawodeshijie这是梦想
//删
sb.delete(3,6);//删除位置在[3,6)上的字符
System.out.println(sb);//nihavawodeshijie这是梦想
sb.deleteCharAt(16);//删除位置在16上的字符
System.out.println(sb);//nihavawodeshijie是梦想
//改-->插入
StringBuilder sb1 = new StringBuilder("$23445980947");
sb1.insert(3,",");//在下标为3的位置上插入","
System.out.println(sb1);//$23,445980947
//改-->替换
StringBuilder sb2 = new StringBuilder("$2你好吗5980947");
sb2.replace(3,5,"我好累");//在下表[3,5)位置上替换字符串
System.out.println(sb2);//$2你我好累5980947
sb.setCharAt(3,'!');
System.out.println(sb);//nih!vawodeshijie是梦想
//查
StringBuilder sb3 = new StringBuilder("asdfa");
for (int i = 0; i < sb3.length(); i++) {
System.out.print(sb3.charAt(i)+"\t");//a s d f a
}
System.out.println();
//截取
String str = sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
System.out.println(str);//df
//反转
sb3.reverse();
System.out.println(sb3);//afdsa
}
}【2】StringBuffer常用方法： 与StringBuilder一致，他们的父类都是AbstractStringBuilder
public class Test03 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("nihaojavawodeshijie");
//增
sb.append("这是梦想");
System.out.println(sb);//nihaojavawodeshijie这是梦想
//删
sb.delete(3,6);//删除位置在[3,6)上的字符
System.out.println(sb);//nihavawodeshijie这是梦想
sb.deleteCharAt(16);//删除位置在16上的字符
System.out.println(sb);//nihavawodeshijie是梦想
//改-->插入
StringBuffer sb1 = new StringBuffer("$23445980947");
sb1.insert(3,",");//在下标为3的位置上插入 ,
System.out.println(sb1);//$23,445980947
//改-->替换
StringBuffer sb2 = new StringBuffer("$2你好吗5980947");
sb2.replace(3,5,"我好累");//在下表[3,5)位置上插入字符串
System.out.println(sb2);//$2你我好累5980947
sb.setCharAt(3,'!');
System.out.println(sb);//nih!vawodeshijie是梦想
//查
StringBuffer sb3 = new StringBuffer("asdfa");
for (int i = 0; i < sb3.length(); i++) {
System.out.print(sb3.charAt(i)+"\t");//a s d f a
}
System.out.println();
//截取
String str = sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
System.out.println(str);//df
//反转
sb3.reverse();
System.out.println(sb3);//afdsa
}
}
String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。
频繁修改字符串的情况考虑使用StringBuilder。
注意：String和StringBuilder类不能直接转换。
如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法。
面试题：String，StringBuilder，StringBuffer之间的区别和联系
（1）String、StringBuffer、StringBuilder区别与联系
1. String类是不可变类，即一旦一个String对象被创建后，包含在这个对象中的字符序列是不可改变的，直至这个对象销毁。
2. StringBuffer类则代表一个字符序列可变的字符串，可以通过append、insert、reverse、setChartAt、setLength等方法改变其内容。一旦生成了最终的字符串，调用toString方法将其转变为String。
3. JDK1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和方法基本相同。
StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作，即StringBuffer是线程安全的，而StringBuilder是线程不安全的，所以性能略高。
通常情况下，创建一个内容可变的字符串，应该优先考虑使用StringBuilder
StringBuilder:JDK1.5开始 效率高 线程不安全
StringBuffer:JDK1.0开始 效率低 线程安全
StringBuilder没有synchronized
而StringBuffer有synchronized
（2）以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】
String str = new String("ab"); // 会创建多少个对象
String str = new String("a") + new String("b"); // 会创建多少个对象
String类的OJ练习
（1）字符串中的第一个唯一的字符
题目链接：https://leetcode.cn/problems/first-unique-character-in-a-string/
class Solution {
public int firstUniqChar(String s) {
//int[] count = new int[256];
int[] count = new int[26];
// 统计每个字符出现的次数
for (int i = 0; i < s.length(); ++i) {
count[s.charAt(i) - 'a']++;
}
// 找第一个只出现一次的字符
for (int i = 0; i < s.length(); ++i) {
if (1 == count[s.charAt(i) - 'a']) {
return i;
}
}
return -1;
}
}（2）字符串中最后一个单词的长度
题目链接：https://www.nowcoder.com/practice/8c949ea5f36f422594b306a2300315da?tpId=37&&tqId=21224&rp=5&ru=/activity/oj&qru=/ta/huawei/question-ranking
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextLine()) { // 注意 while 处理多个 case
String s = in.nextLine();
// 1. 找到最后一个空格
// 2. 获取最后一个单词：从最后一个空格+1位置开始，一直截取到末尾
// 3. 打印最后一个单词长度
int index = s.lastIndexOf(" ");
String ret = s.substring(index+1);
System.out.println(ret.length());
}
}
}（3）验证回文串
题目链接：https://leetcode.cn/problems/valid-palindrome/
class Solution {
public boolean isPalindrome(String s) {
s = s.toLowerCase();
int left = 0;
int right = s.length() - 1;
while (left < right) {
//不是有效字符就++遍历下个字符，有可能有多个空格，所以要用while，还有个前提是全程一直要left < right，因为有可能一直都没有遇到有效字符，left >= right
while (left < right && !isValidChar(s.charAt(left))) {
left++;
}
//left是有效字符了
while (left < right && !isValidChar(s.charAt(right))) {
right--;
}
//right是有效字符了
if (s.charAt(left) != s.charAt(right)) {
return false;
} else {
left++;
right--;
}
}
return true;
}
private boolean isValidChar(char ch) {
if (Character.isDigit(ch) || Character.isLetter(ch)) {
return true;
}
return false;
/*if (ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'z') {
return true;
}
return false;*/
}
}(4)华为研发工程师编程题——字符集合
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str = sc.nextLine();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (!sb.toString().contains(ch + "")) {//contains里面只能是字符串序列，ch是单个字符，ch+""就变成了字符串
sb.append(ch);
}
}
System.out.println(sb.toString());
}
sc.close();
}
}
