1.常用方法

1.1字符串构造

（1）常用的三种方式

public class TextDame {public static void main(String[] args) {//使用常量串构造String str1 = "hello";//直接newString对象String str2 = new String("hello");//使用字符数组进行构造char[] ch = {'h','e','l','l','o'};String str3 = new String(ch);}
}

（2）String是引用类型，内部并不存储字符串本身，在jdk1.8中，字符串实际保存在char类型的数组中

（3）在Java中“”引起来的也是String类型对象

public class TextDame {public static void main(String[] args) {String str1 = new String("hello");String str2 = new String("hello");String str3 = str1;System.out.println(str1 == str2);//falseSystem.out.println(str1 == str3);//trueSystem.out.println(str1.length());//5System.out.println("hello".length());//5}
}

1.2String对象的比较

（1）== 比较是否引用同一个对象（对于简单类型，==比较的是变量中的值；对于引用类型 ==比较的是引用中的地址）

public class TextDame {public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");String s3 = new String("world");String s4 = s1;System.out.println(s1 == s2); // falseSystem.out.println(s2 == s3); // falseSystem.out.println(s1 == s4); // true}
}

（2）equals：比较内容是否相同

public class TextDame {public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");// s1、s2引用的是三个不同对象，因此==比较结果全部为falseSystem.out.println(s1 == s2); // false// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出trueSystem.out.println(s1.equals(s2)); // true}
}

（3）compareTo方法是按照字典序进行比较，compareTo返回的是int类型，具体比较方式：先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值； 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

public class TextDame {public static void main(String[] args) {String s1 = new String("ac");String s2 = new String("abc");String s3 = new String("ac");String s4 = new String("acdef");System.out.println(s1.compareTo(s2));//s1 > s2，输出正数System.out.println(s1.compareTo(s3));//s1 == s3,输出0System.out.println(s1.compareTo(s4));//s1 <s4,输出负数}
}

（4）compareToIgnoreCase方法：与compareTo方式相同，但是忽略大小写比较

public class TextDame {public static void main(String[] args) {String s1 = new String("aBc");String s2 = new String("abc");System.out.println(s1.compareToIgnoreCase(s2));//0}
}

1.3字符串查找

package dame3;public class TextDame {public static void main(String[] args) {String s = "aabcabcaabc";System.out.println(s.charAt(3)); // c，返回3号下标对应的字符System.out.println(s.indexOf('c')); // 3，返回第一个c出现的下标System.out.println(s.indexOf('c', 1)); // 3，从1号下标开始找，返回第一个出现c的下标System.out.println(s.indexOf("abc")); // 1，返回第一个abc出现a的下标System.out.println(s.indexOf("abc", 1)); // 1，从1号下标开始找，返回第一个abc出现a的下标System.out.println(s.lastIndexOf('c')); // 10，从后往前找第一个出现c的下标System.out.println(s.lastIndexOf('a', 10)); // 8，从10号下标开始找，从后往前找第一个出现a的下标System.out.println(s.lastIndexOf("abc")); // 8，从后往前找返回第一个abc出现a的下标System.out.println(s.lastIndexOf("abc", 10)); // 8，从10号下标开始找，从后往前找返回第一个abc出现a的下标}
}

1.4转化

（1）数值和字符串转化

public class TextDame {public static void main(String[] args) {//数字转化为字符串String str1 = String.valueOf(12);String str2 = String.valueOf(12.3);//字符串转化为数字int a = Integer.parseInt("12");Double b = Double.parseDouble("12.3");}
}

（2）字符串大小写转换

public class TextDame {public static void main(String[] args) {String str1 = "abCDeF";String str2 = str1.toLowerCase();//大写转小写String str3 = str1.toUpperCase();//小写转大写System.out.println(str2);//abcdefSystem.out.println(str3);//ABCDEF}
}

（3）字符串和数组转化

public class TextDame {public static void main(String[] args) {String str1 = "hello";//字符串转数组char[] ch = str1.toCharArray();for (int i = 0; i < ch.length; i++) {System.out.print(ch[i] + " ");}System.out.println();//数组转字符串String str2 = new String(ch);System.out.println(ch);}
}

（4）格式化

public class TextDame {public static void main(String[] args) {String str1 = String.format("%d-%d-%d",2023,6,19);System.out.println(str1);//2023-6-19}
}

1.5字符串替换

注意：由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串

public class TextDame {public static void main(String[] args) {String str1 = "hello,world";String ret = str1.replaceAll("l","g");//将所有的l替换为gSystem.out.println(ret);//heggo,worgdString ret1 = str1.replaceFirst("l","c");//将第一个l替换为cSystem.out.println(ret1);//heclo,world}
}

1.6字符串拆分

public class TextDame {public static void main(String[] args) {String str1 = "hello,world,hello,hello,world,hello";String[] str = str1.split(",");//将字符串按逗号分开，存放在字符串数组中for (String s: str) {System.out.print(s + " ");//hello world hello hello world hello }System.out.println();String[] str2 = str1.split(",",2);//将字符串按逗号分开，第二个参数是限制分组的组数，存放在字符串数组中for (String s: str2) {System.out.print(s + " ");//hello world,hello,hello,world,hello }}
}

1.7字符串的截取

public class TextDame {public static void main(String[] args) {String str1 = "hello,world";String str = str1.substring(3);//从指定位置开始截取System.out.println(str);//lo,worldString str2 = str1.substring(3,5);//截取从起始位置到终止位置，左闭右开System.out.println(str2);//lo}
}

1.8去掉字符串中的左右空格，保留中间空格

public class TextDame {public static void main(String[] args) {String str1 = "   hello world hello hello world hello  ";String str = str1.trim();System.out.println(str);//hello world hello hello world hello}
}

2.字符串常量池

（1）为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池
（2）字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable

1. 在JVM中字符串常量池只有一份，是全局共享的
2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多
3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中
4. 字符创常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加

2.1 直接使用字符串常量进行赋值

public class TextDame {public static void main(String[] args) {String s1 = "hello";String s2 = "hello";System.out.println(s1 == s2); // true}
}

2.2通过new创建String类对象

public class TextDame {public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");System.out.println(s1 == s2); // false}
}

2.3 intern方法

该方法的作用是手动将创建的String对象添加到常量池中

public class TextDame {public static void main(String[] args) {char[] ch = new char[]{'a', 'b', 'c'};String s1 = new String(ch); // s1对象并不在常量池中s1.intern(); // 调用之后，会将s1对象的引用放入到常量池中String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用System.out.println(s1 == s2);//true}
}

2.4String类中两种对象实例化的区别

（1）String str = “hello”：只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象
（2）String str = new String(“hello”)：会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟的String对象赋值
（3） String str = new String(new char[]{‘h’, ‘e’, ‘l’, ‘l’, ‘o’})：现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到String对象中

3.字符串的不可变性

（1）String类在设计时就是不可改变的，String类实现描述中已经说明了

String类中的字符实际保存在内部维护的value字符数组中，String类被final修饰，表明该类不能被继承，value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改
（2）所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象。final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的

public class TextDame {public static void main(String[] args) {final int[] array = new int[]{1,2,3,4};array[0] = 100;System.out.println(Arrays.toString(array));//[100, 2, 3, 4]}
}

4.字符串的修改

（1）尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低
（2）String的拼接底层会被优化为StringBuilder对象的拼接，使用的是append，如下述代码中的一行代码会被优化为四行代码，进行拼接的时候会创建新的对象，因此对于String对象进行修改的时候建议使用stringbuffer或者stringbuilder

5.StringBuilder和StringBuffer

5.1StringBuilder

（1）String和StringBuilder类不能直接转换
（2）转换原则：String变为StringBuilder是利用StringBuilder的构造方法或append()方法；StringBuilder变为String是调用toString()方法

public class TextDame {public static void main(String[] args) {StringBuilder sb1 = new StringBuilder("hello");StringBuilder sb2 = sb1;// append：追加字符、字符串、整形数字sb1.append('，');sb1.append("world");sb1.append(123);System.out.println(sb1); // hello，world123System.out.println(sb1 == sb2); // trueSystem.out.println(sb1.charAt(0)); // 获取0号位上的字符 hSystem.out.println(sb1.length()); // 获取字符串的有效长度 14System.out.println(sb1.capacity()); //获取底层数组的总大小 21sb1.setCharAt(0, 'H'); // 设置任意位置的字符sb1.insert(0, "Hello world!!!"); //在任意位置添加字符或字符串System.out.println(sb1);//Hello world!!!Hello，world123System.out.println(sb1.indexOf("Hello")); //获取Hello第一次出现的位置 0System.out.println(sb1.lastIndexOf("Hello")); //获取hello最后一次出现的位置 14sb1.deleteCharAt(0); //删除首字符System.out.println(sb1);//ello world!!!Hello，world123sb1.delete(0,5); // 删除[0, 5)范围内的字符System.out.println(sb1);//world!!!Hello，world123String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回System.out.println(str);//worldSystem.out.println(sb1);//world!!!Hello，world123sb1.reverse(); // 字符串逆转str = sb1.toString(); // 将StringBuffer以String的方式返回System.out.println(str);//321dlrow，olleH!!!dlrow}
}

5.2String、StringBuffer、StringBuilder的区别

1. String的内容不可修改，StringBuffer与StringBuilder的内容可以修改
2. StringBuffer与StringBuilder大部分功能是相似的
3. StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

6.习题

6.1 以下总共创建了多少个String对象

String str = new String("ab"); // 两个（"ab"和new String）
String str = new String("a") + new String("b"); // 六个（"a","b",new String,new String,StringBuilder,toString）

6.2字符串中的第一个唯一字符

解法一：数组

class Solution {public int firstUniqChar(String s) {if(s == null){return -1;}int[] arr = new int[26];for(int i = 0;i < s.length();i++){arr[s.charAt(i) - 'a']++;}for(int i = 0;i < s.length();i++){if(arr[s.charAt(i) - 'a'] == 1){return i;}}return -1;}
}

解法二：HashMap

class Solution {public int firstUniqChar(String s) {if(s == null || s.length() == 0){return -1;}HashMap<Character,Integer> map = new HashMap<>();for(int i = 0; i < s.length();i++){if(map.containsKey(s.charAt(i))){map.put(s.charAt(i),map.get(s.charAt(i)) + 1);}else{map.put(s.charAt(i),1);}}for(int i = 0;i < s.length();i++){if(map.get(s.charAt(i)) == 1){return i;}}return -1;}
}

6.3字符串最后一个单词的长度

import java.util.Scanner;
public class Main {public static int stringLength(String str){if(str == null || str.length() == 0){return -1;}// 找到最后一个空格出现的位置，返回最后一个空格所在位置的下标int index = str.lastIndexOf(" ");return str.length() - index - 1;}public static void main(String[] args) {Scanner sc = new Scanner(System.in);while (sc.hasNext()) { String str = sc.nextLine();int ret = stringLength(str);System.out.println(ret);}}
}

6.4验证字符串是否是回文串

class Solution {// 判断该字符是不是字母或数字public static boolean isCharacterOrNumber(char ch){if(ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'z'){return true;}return false;}public boolean isPalindrome(String s) {if(s == null || s.length() == 0){return true;}// 将字符串全部转化为小写字符s = s.toLowerCase();int left = 0;int right = s.length() - 1;while(left < right){// 在左边找到字母或数字的字符while(left < right && !isCharacterOrNumber(s.charAt(left))){left++;}// 在右边找到字母或数字的字符while(left < right && !isCharacterOrNumber(s.charAt(right))){right--;}// 如果当前对应位置上的字符不相等就返回falseif(s.charAt(left) != s.charAt(right)){return false;}left++;right--;}return true;}
}