目录
📄1.2.2 boolean equals(Object anObject) 方法:比较怕两个引用所指的对象当中的内容是否一致
📑1.2.3 int compareTo(String s) 方法(比较两个字符串大小的关系)
📃1.2.4 int compareToIgnoreCase(String str) 方法:与compareTo方式相同,但是忽略大小写比较
⌨1.4.1 数字和字符串转换(.valueOf——数字转字符串 .parse___(类型)—— 字符串转数字)
📃1.4.2 字母大小写的相互转换(.toUpperCase()——小写转大写 .toLowerCase() ——大写转小写)
📁1.5.3 替换第一个所指的内容(.replaceFirst)
🥂1.6.1 String[] split(String regex) —— 将字符串全部拆分
🥂1.6.2 String[] split(String regex, int limit)—— 将字符串以指定的格式,拆分为limit组
🏹1.7.1 String substring(int beginIndex)——从指定索引截取到结尾
🏹1.7.2 String substring(int beginIndex, int endIndex) ——截取部分内容 ——左闭右开,索引从0开始
📗1.8 String trim()、String toUpperCase()、String toLowerCase()
🎎1.8.1 String trim()——去掉字符串中的左右空格,保留中间空格
🎎1.8.2 String toUpperCase()——字符串转大写
🎎1.8.3 String toLowerCase()——字符串转小写
📒2.1 认识StringBuilder和StringBuffer
➕2.1.1 StringBuilder append(String str)——在尾部追加,相当于String的+=
➕2.1.2 StringBuilder reverse() ——反转字符串
📗2.2 .String、StringBuffer、StringBuilder的区别
🌈学习一个类的时候一定要从构造方法开始学习,类的最终目的是实例化对象,那么就一定会构造方法
✨首先我们来看一段代码:
- public class Test {
- public static void main(String[] args) {
- // 使用常量串构造
- String str1 = "hello";
- // 直接newString对象
- String str2 = new String("hello");
- System.out.println(str1);//hello
- System.out.println(str2);//hello
- //字符数组,使用字符数字进行构造
- char[] values = {'a','b','c','d'};
- String str3 = new String(values);
- System.out.println(str3);//a b c d
- }
- }
👉总结:
常用的构造方法有三种:
1️⃣使用常量串构造
2️⃣直接newString对象
3️⃣使用字符数字进行构造
目前我们只需要掌握这三种即可,如果想要深入研究,可以打开idea,双击shift,搜索String,点击Classes就可以看到String的各种构造方法

➡️当我们定义了字符串之后,需要注意以下几点:
1️⃣String是引用类型,内部并不存储字符串本身。String 有两个成员变量,不管是带参数的还是不带参数的,都会给 value 赋值

两个成员变量:value hash

👆对于以上代码,我们通过调试发现:在java当中,字符串没有所谓的 \0

✨String的内存布局:
➡️并且String 现在是一个类,那么有类就会有很多方法方法
2️⃣String 类通过 .length() 可以输出字符串长度
- public static void main(String[] args) {
- String str1 = "hello";
- System.out.println(str1.length());//5
- }
数组求长度:.length
- public static void main(String[] args) {
- int[] array = {1,2,3,4};
- System.out.println(array.length);//4
- }
✨在这里我们要区分:.length() 是一种方法,而 .length 仅仅是一种属性(注意何时加())
3️⃣ .isEmpty() :如果字符串长度为0,返回true,否则返回false
- public class Test {
- String str2 = "";
- System.out.println(str2.length());//0
- System.out.println(str2.isEmpty());//true
- }
➡️拓展:
String str3 = null
str2.isEmpty() 代表它所指向的对象一个字符串都没有
str3 :代表它不指向任何对象
4️⃣在Java中“ ”引起来的也是String类型对象。
- // 打印"hello"字符串(String对象)的长度
- System.out.println("hello".length());//5
字符串的比较会有两种场景:🕛相不相同🕠大小
- public static void main(String[] args) {
- String str1 = new String("hello");
- String str2 = new String("hello");
- System.out.println(str1 == str2);//false:对于引用类型==比较的是引用中的地址。
- }
- public static void main(String[] args) {
- //比较怕两个引用所指的1对象当中的内容是否一致
- System.out.println(str1.equals(str2));//true:引用中的内容是一样的
- }
✨如果出现不等的字符,直接返回这两个字符的大小差值
- public static void main(String[] args) {
- //比较两个字符串大小的关系
- String str1 = new String("hello");
- String str2 = new String("healo");
- System.out.println(str1.compareTo(str2));//正数
- }
当 str1 > str2,返回一个正数
当 str1 < str2,返回一个负数
当 str1 = str2,返回0
- public static void main(String[] args) {
- //比较两个字符串大小的关系
- String str3 = new String("helloabc");
- String str4 = new String("hello");
- System.out.println(str3.compareTo(str4));//3
- }
- //比较两个字符串大小的关系
- String str5 = new String("Hello");
- String str6 = new String("hello");
- System.out.println(str5.compareToIgnoreCase(str6));//0

- //字符串查找
- public static void main(String[] args) {
- String s = "aaabbbcccaaabbbccc";
- //char charAt(int index) 返回index位置上字符
- System.out.println(s.charAt(3)); // 'b'
- //int indexOf(int ch) 返回ch第一次出现的位置,没有返回-1
- System.out.println(s.indexOf('c')); // 6
- //int indexOf(int ch, int fromIndex) 从fromIndex位置开始找ch第一次出现的位置,没有
- //返回-1
- System.out.println(s.indexOf('c', 10)); // 15
- //int indexOf(String str) 返回str第一次出现的位置,没有返回-1
- System.out.println(s.indexOf("bbb")); // 3
- //int indexOf(String str, int fromIndex) 从fromIndex位置开始找str第一次出现的位置,
- //没有返回-1
- System.out.println(s.indexOf("bbb", 10)); // 12
- //int lastIndexOf(int ch) 从后往前找,返回ch第一次出现的位置,没有返回-1
- System.out.println(s.lastIndexOf('c')); // 17
- //int lastIndexOf(int ch, int fromIndex) 从fromIndex位置开始找,从后往前找ch第一次
- //出现的位置,没有返回-1
- System.out.println(s.lastIndexOf('c', 10)); // 8
- //int lastIndexOf(String str) 从后往前找,返回str第一次出现的位置,没有返回-1
- System.out.println(s.lastIndexOf("bbb")); // 12
- //int lastIndexOf(String str, int fromIndex) 从fromIndex位置开始找,从后往前找str
- //第一次出现的位置,没有返回-1
- System.out.println(s.lastIndexOf("bbb", 10)); // 3
- }
- //字符串的转换
- public static void main(String[] args) {
- // 数字转字符串
- String str2 = String.valueOf(123);
- System.out.println(str2);//123
- // 字符串转数字
- String str1 = "123";
- Integer.parseInt(str1);
- System.out.println(str1);//123
- }
- public static void main(String[] args) {
- String str3 = "abcd";
- String str4 = "ABCD";
- // 小写转大写
- System.out.println(str3.toUpperCase());//ABCD
- //大写转小写
- System.out.println(str4.toLowerCase());//abcd
- }
- //字符串转数组
- public static void main(String[] args) {
- String str5 = "abcdef";
- char[] array = str5.toCharArray();
- for (int i = 0; i < array.length; i++) {
- System.out.print(array[i]);
- }
- System.out.println();
- }
- //格式化
- public static void main(String[] args) {
- String s = String.format("%d-%d-%d", 2022,11,20);
- System.out.println(s);//2022-11-20
- }
- public static void main(String[] args) {
- String str1 = "ababcabcabcd";
- String ret1 = str1.replace('a','p');//pbpbcpbcpbcd
- System.out.println(ret1);
-
- String ret2 = str1.replace('a','0');//0b0bc0bc0bcd
- System.out.println(ret2);
- }
- public static void main(String[] args) {
- String str1 = "ababcabcabcd";
- //替换所有的指定内容(replaceAll)
- String ret3 = str1.replaceAll("ab","666");//666666c666c666cd
- System.out.println(ret3);
- }
- public static void main(String[] args) {
- String str1 = "ababcabcabcd";
- //替换第一个所指的内容(.replaceFirst)
- String ret4 = str1.replaceFirst("ab","666");//666abcabcabcd
- System.out.println(ret4);
- }
字符串的拆分分为以下两个方法:
- public static void main(String[] args) {
- String str1 = "hello little bitter ";
- String[] strs = str1.split(" ");
- for (int i = 0; i < strs.length; i++) {
- System.out.println(strs[i]);//hello little bitter
- }
- }
- public static void main(String[] args) {
- String str1 = "hello little bitter ";
- String[] strs = str1.split(" ",2);
- for (int i = 0; i < strs.length; i++) {
- System.out.println(strs[i]);//hello little bitter
- }
- }
- public static void main(String[] args) {
- String str1 = "192.168.1.1";
- String[] strs = str1.split("\\.");
- for (int i = 0; i < strs.length; i++) {
- System.out.println(strs[i]);//192 168 1 1
- }
- }
➡️在这里我们是按照“ . ”进行拆分的,为什么要加\\呢?此时不能够识别“ . ”,必须进行转义
1️⃣字符"|","*","+"都得加上转义字符,前面加上 "\\" .2️⃣而如果是 "\" ,那么就得写成 "\\\\" .3️⃣如果一个字符串中有多个分隔符,可以用"|"作为连字符.
- public static void main(String[] args) {
- String str = "abcdefg";
- //String substring(int beginIndex)——从指定索引截取到结尾
- String s = str.substring(4);
- System.out.println(s);//efg
- }
- public static void main(String[] args) {
- String str = "abcdefg";
- // String substring(int beginIndex, int endIndex) ——截取部分内容 ——左闭右开
- String str2 = str.substring(2,6);
- System.out.println(str2);//cdef-----[ )
- }
- public static void main(String[] args) {
- String str = " hello ab ";
- System.out.println(str);// hello ab
- String ret = str.trim();
- System.out.println(ret);//hello ab
- }
- public static void main(String[] args) {
- String str = "abc";
- //String toUpperCase()——字符串转大写
- String ret = str.toUpperCase();
- System.out.println(ret);//ABC
- }
- public static void main(String[] args) {
- String str2 = "AAAABBBBB";
- //String toLowerCase()——字符串转小写
- String ret2 = str2.toLowerCase();
- System.out.println(ret2);//aaaabbbbb
- }
✨所有字面值双引号引起的都会放到常量池当中
- public static void main(String[] args) {
- String str1 = "abcd";
- String str2 = new String("abcd");
- System.out.println(str1 == str2);//false
- }
如果常量池当中存放了“abcd”,就不会再将str2中的“abcd”放入,共用一个体,如果没有则放入

👉总结:双引号 引起来的值就存在字符串常量池当中,如果有,就不存储,直接返回字符串常量池的对象即可
- //字符串如何修改
- public static void main(String[] args) {
- String str = "hello";
- str += "abc";
- System.out.println(str);//helloabc
- }
在这里是两个对象拼接形成一个新的对象
➡️StringBuffffer 和 StringBuilder 的是为了方便字符串的修改
➡️StringBuilder和StringBuffffer这两个类大部分功能是相同的,这里介绍 StringBuilder常用的一些方法
- public static void main(String[] args) {
- StringBuilder stringBuilder = new StringBuilder("abc");
- System.out.println(stringBuilder);
-
- //字符串拼接
- stringBuilder.append("123").append(10);
- stringBuilder.append(19.9);
- System.out.println(stringBuilder);
- }
- public static void main(String[] args) {
- StringBuilder stringBuilder = new StringBuilder("abc");
- System.out.println(stringBuilder);
- //字符串逆置
- stringBuilder.reverse();
- System.out.println(stringBuilder);//cba
- }
1️⃣String的内容无法修改,而StringBuilder、StringBuffer的内容可以修改。
2️⃣StringBuffffer与StringBuilder大部分功能是相似的
3️⃣StringBuffffer采用同步处理,属于线程安全操作;而StringBuilder未采用同步处理,属于线程不安全操作
4️⃣String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
5️⃣StringBuilder变为String: 调用toString()方法
🙈以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】
- String str = new String("ab"); // 会创建多少个对象
- String str = new String("a") + new String("b"); // 会创建多少个对象
第一个代码:
1️⃣双引号ab 2️⃣new String
第二个代码:
1️⃣双引号a 2️⃣双引号b 3️⃣字符串拼接会产生一个StringBuilder 对象 4️⃣赋值给str,调用ToString(),就会创建一个String对象
5️⃣new String 6️⃣第二个new String
✨但是题目问的是创建了多少个String对象,则不包括3️⃣字符串拼接会产生一个StringBuilder 对象 ,一共创建了5个String对象
1️⃣字符串中的第一个唯一字符
2️⃣字符串最后一个单词的长度
3️⃣验证回文串