常用类学习（String类和StringBuffer类详解）
String类
❤️String字符串的存储原理
关于Java JDK中内置的一个类：java.lang.String
1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。
2、在java中随便使用双引号括起来的都是String对象。例如："abc"，"def"，"hello world!"，这是3个String对象。
3、java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"
4、在JDK当中双引号括起来的字符串，例如： "abc" "def"都是直接存储在“方法区”的“字符串常量池” 当中的。
5、为什么SUN公司把字符串存储在一个“字符串常量池”当中呢？因为字符串在实际的开发中使用太频繁。为了执行效率，所以把字符串放到了方法区的字符串常量池当中。
⭐️例1：
package com.bjpowernode.javase; public class StringTest01 { public static void main(String[] args) { //1、这两行代码表示底层创建了3个字符串对象，都在"字符串常量"池当中。 //2、实际上s1指向"abcdef"；第二次发现有"abcdef"不会在重新创建， //而是直接从“方法区”的“字符串常量池”当中直接拿取 //3、并没有什么指向 "xy"; //4、s2指向的是"abcdefxy" String s1 = "abcdef"; String s2 = "abcdef" + "xy"; // 分析：这是使用new的方式创建的字符串对象。这个代码中的"xy"是从哪里来的？ // 凡是双引号括起来的都在字符串常量池中有一份。 // new对象的时候一定在堆内存当中开辟空间。 String s3 = new String("xy"); } }
只有s1和s2内存图
s1、s2、s3内存图
⭐️例2：对于String类型，存储的都是内存地址
package com.bjpowernode.javase; public class User { private int id; private String name; //入口 public static void main(String[] args) { User user = new User(110,"张三"); } //构造方法 public User() { } public User(int id, String name) { this.id = id; this.name = name; } //setter and getter public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
重画一下以前理解的内存图
⭐️例3：
package com.bjpowernode.javase; public class StringTest02 { public static void main(String[] args) { //"hello"是存储在方法区的字符串常量池当中，所以"hello"不会新建 String s1 = "hello"; String s2 = "hello"; //双等号比较的是变量中保存的地址，s1和s2保存的地址是相同的 System.out.println(s1==s2); //true String x = new String("xyz"); String y = new String("xyz"); System.out.println(x==y); //false //通过这两个例题，我们知道对象之间的比较不能用"==" //"=="不保险，应该使用String类中的equals方法进行比较 // String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。 System.out.println(x.equals(y)); //true //深度理解 String k = new String("abcd"); System.out.println(k.equals("abcd")); //true //也可以把字符串写在前面，避免空指针异常 System.out.println("abcd".equals(k)); //true //当k为空指针 k = null; System.out.println("abcd".equals(k)); //false System.out.println(k.equals("abcd")); //空指针异常 //重新强调一下重点 int i = 100; // i变量中保存的是100这个值。 String s = "abc"; // s变量中保存的是字符串对象的内存地址。 // s引用中保存的不是"abc"，是0x1111 // 而0x1111是"abc"字符串对象在“字符串常量池”当中的内存地址。 } }
内存图
⭐️例4：分析以下程序创建了几个对象
package com.bjpowernode.javase; //分析以下程序创建了几个对象 public class StringTest03 { public static void main(String[] args) { //一共创建三个对象：方法区字符串常量池中有1个"hello"；堆内存中有2个String对象 String s1 = new String("hello"); String s2 = new String("hello"); } }
❤️String类的常用构造方法
第一个：String s = new String("abc");
第二个：String s = "abc"; 最常用
第三个：String s = new String(char数组);
第四个：String s = new String(char数组,起始下标,长度);
第五个：String s = new String(byte数组);
第六个：String s = new String(byte数组,起始下标,长度)
package com.bjpowernode.javase; //String类中常用的构造方法 public class StringTest04 { public static void main(String[] args) { //1\. 创建字符串对象最常用的一种方法 String s1 = "hello world"; String s = new String("world"); System.out.println(s1); //hello world，String类重写了toString方法 System.out.println(s); //world //2.String里面传byte数组 byte[] b = {97,98,99}; // a b c String s2 = new String(b); //输出一个引用的时候，会自动调用toString方***自动输出对象的内存地址 //现在输出结果是abc，得出结论：String类那个重写了toString()方法 //所以这里输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身 System.out.println(s2); //abc System.out.println(s2.toString()); //abc //3.String(字节数组,数组元素下标的起始地址,长度) //将byte数组中的一部分转换成字符串 String s3 = new String(b,1,2); //偏移量也就是下标、长度 System.out.println(s3); //bc //4.将char数组全部转换成字符串 char[] c= {'a','b','c','d'}; String s4 = new String(c); System.out.println(s4); //abcd //5.将char数组的一部分转换成字符串 String s5 = new String(c,2,2); System.out.println(s5); //cd } }
❤️String类的常用方法
1.(掌握)char charAt(int index)；返回指定索引的char值
2.(了解)int compareTo(String anotherString)；比较两个字符串的大小
3.(掌握)boolean contains(CharSequence s)；看后面字符串是不是前面字符串的子串
4.(掌握)boolean endsWith(String suffix)；判断当前字符串是否以某个“字符串”结尾
5.(掌握)boolean startsWith(String prefix)；判断当前字符串是否以某个“字符串”开始
6.(掌握)boolean equals(Object anObject)；判断两个字符串是否相等
注意：equals只能看出是否相等；compareTo方法不仅可以看出是否相等，还可以看出谁大谁小
7.(掌握)boolean equalsIgnoreCase(String anotherString)；判断两个字符串是否相等，忽略大小写
8.(掌握)byte[] getBytes()；将字符串对象转换成字节数组
9.(掌握)int indexOf(String str)；判断某个字符串在当前字符串中第一次出现处的索引(下标)；返回对应的下标。和contains方法一块记忆
10.(掌握) int lastIndexOf(String str)；判断某个字符串在当前字符串中最后一次出现的索引(下标)； 和contains方法一块记忆
11.(掌握)boolean isEmpty()；判断某个字符串是否为“空字符串” ，底层源代码调用的应该是字符串的length()方法；而不是空指针
12.(掌握)int length()；求字符串的长度，是length()方法；和数组length属性区分开
13.补充面试题：判断数组长度和判断字符串长度不一样
判断数组长度是length属性，判断字符串长度是length()方法
14.(掌握)String replace(CharSequence target, CharSequence replacement)；替换字符串，例如： String str = "abcdexyx".replace("dex","xyz");结果就是：abcxyzyx
15.(掌握)String[] split(String regex)；拆分字符串，把字符串拆分成一个字符串数组
16.(掌握)String substring(int beginIndex)；截取字符串，从当前下标到结束
String substring(int beginIndex, int endIndex)，定义截取的范围，左闭右开
17.(掌握)char[] toCharArray()；将此字符串转换为一个字符数组
18.(掌握)String toLowerCase()；大写转小写
19.(掌握)String toUpperCase()；小写转大写
20.(掌握)String trim()；去除字符串前后空白
21.(掌握) String中只有valueOf方法是静态的，不需要new对象
String s1 = String.valueOf(true)；作用：将"非字符串"转换成"字符串"
这个静态的valueof()方法，参数是一个对象的时候，也会调用toString方法
没有重写toString方法，结果是对象内存地址
22.研究一下print()方法，都会调用valueOf方法，valueOf方法又会调用toString方法
本质上System.out.println()这个方法在输出任何类型数据的时候，都是先转换成字符串在输出到控制台上
package com.bjpowernode.javase; public class StringTest05 { public static void main(String[] args) { //1.(掌握)char charAt(int index) // 返回指定索引的char值 char c = "abcd".charAt(2); System.out.println(c); // c //2.(了解)int compareTo(String anotherString) // 比较两个字符串的大小。一个字符一个字符进行比较 int i = "abc".compareTo("abf"); System.out.println(i); //-3 int j = "abc".compareTo("abc"); System.out.println(j); //0 int k = "abc".compareTo("abac"); System.out.println(k); //2 //3.(掌握)boolean contains(CharSequence s) //看后面字符串是不是前面字符串的子串，contains包含的意思 boolean b = "abcdef".contains("bcd"); System.out.println(b); //true //4.(掌握)boolean endsWith(String suffix) //判断当前字符串是否以某个“字符串”结尾 boolean b1 = "xyyz.txt".endsWith(".txt"); System.out.println(b1); //true //5.(掌握)boolean startsWith(String prefix) //判断当前字符串是否以某个“字符串”开始 boolean bb1 = "xyyz.txt".startsWith("xyy"); System.out.println(bb1); //6.(掌握)boolean equals(Object anObject) //判断两个字符串是否相等，用equals方法 //equals只能看出是否相等；compareTo方法不仅可以看出是否相等，还可以看出谁大谁小 System.out.println("abc".equals("abc"));// true //7.(掌握)boolean equalsIgnoreCase(String anotherString) //判断两个字符串是否相等，忽略大小写 boolean b2 = "aXybbC".equalsIgnoreCase("axybbc"); System.out.println(b2);// true //8.(掌握)byte[] getBytes() //将字符串对象转换成字节数组 byte[] arr = "abcd".getBytes(); for (int ii = 0; ii < arr.length; ii++) { System.out.print(arr[ii]+" "); //97 98 99 100 } //9.(掌握)int indexOf(String str) //判断某个字符串在当前字符串中第一次出现处的索引(下标)。返回对应的下标 int start = "abcdef".indexOf("de"); System.out.println(start); // 3 //10.(掌握) int lastIndexOf(String str) //判断某个字符串在当前字符串中最后一次出现的索引(下标) int end = "abcdefdebdeccc".lastIndexOf("de"); System.out.println(end); // 9 //11.(掌握)boolean isEmpty() //判断某个字符串是否为“空字符串”，底层源代码调用的应该是字符串的length()方法；而不是空指针 boolean b4 = "".isEmpty(); System.out.println(b4);//true,为空为true //12.(掌握)int length() int len = "abc".length(); System.out.println(len); //3 System.out.println("".length()); //0,也能说明是不是空串 //13.补充面试题：判断数组长度和判断字符串长度不一样 // 判断数组长度是length属性，判断字符串长度是length()方法 //14.(掌握)String replace(CharSequence target, CharSequence replacement) //String的父接口就是：CharSequence String str = "abcdexyx".replace("dex","xyz"); System.out.println(str); //abcxyzyx //15.(掌握)String[] split(String regex) //拆分字符串 String[] str1 = "2022-6-27".split("-"); for (int l = 0; l < str1.length; l++) { System.out.println(str1[l]); } //16.(掌握)String substring(int beginIndex) //截取字符串 String str2 = "abcdxyz".substring(4); System.out.println(str2); //xyz //String substring(int beginIndex, int endIndex) //beginIndex起始位置包括；endIndex终止位置不包括 System.out.println("abcdxyz".substring(4,6)); //xy,左闭右开，只包含4、5的值 //17.(掌握)char[] toCharArray() //将此字符串转换为一个新的字符数组 char[] chars= "abcde".toCharArray(); for (int l = 0; l < chars.length; l++) { System.out.println(chars[l]);// a b c d e } //18.(掌握)String toLowerCase() //大写转小写 String str3 = "AaBbCcDD".toLowerCase(); System.out.println(str3); //aabbccdd //19.(掌握)String toUpperCase() //小写转大写 String str4 = "AaBbCcDD".toUpperCase(); System.out.println(str4); //AABBCCDD //20.(掌握)String trim() //去除字符串前后空白 String str5 = " Hello World ".trim(); System.out.println(str5); //21.(掌握) String中只有valueOf方法是静态的，不需要new对象 //作用：将"非字符串"转换成"字符串" String s1 = String.valueOf(true); System.out.println(s1); //字符串"true" String s2 = String.valueOf(123); System.out.println(s2); //字符串"123" //这个静态的valueof()方法，参数是一个对象的时候，也会调用toString方法 String s3 = String.valueOf(new Customer()); System.out.println(s3);//com.bjpowernode.javase.Customer@4554617c //没有重写toString方法，结果是对象内存地址 //22.研究一下print()方法，都会调用valueOf方法，valueOf方法又会调用toString方法 System.out.println(100); System.out.println(3.14); System.out.println(true); Object obj = new Object(); System.out.println(obj);// java.lang.Object@74a14482 //本质上System.out.println()这个方法在输出任何类型数据的时候， // 都是先转换成字符串在输出到控制台上 } } class Customer{ }
🥅StringBuffer类
❤️使用''+"进行字符串拼接带来的问题
思考：我们在实际的开发中，如果需要进行字符串的频繁拼接，会有什么问题？
因为java中的字符串是不可变的，每一次拼接都会产生新字符串。 这样会占用大量的方法区内存。造成内存空间的浪费。例如：String s = "abc"; s += "hello"; 就以上两行代码，就导致在方法区字符串常量池当中创建了3个对象： "abc" "hello" "abchello"
package com.bjpowernode.javase; public class StringBufferTest01 { public static void main(String[] args) { String s = " "; // 这样做会给java的方法区字符串常量池带来很大的压力。 for (int i = 0; i < 10; i++) { //并不是在原来的基础上拼接，而是不断重新创建 s += i; System.out.println(s); } } }
❤️使用StringBuffer进行字符串拼接
1、如果以后需要进行大量字符串的拼接操作，建议使用JDK中自带的：
java.lang.StringBuffer java.lang.StringBuilder2、如何优化StringBuffer的性能？
在创建StringBuffer的时候尽可能给定一个初始化容量。 最好减少底层数组的扩容次数。预估计一下，给一个大一些初始化容量。 关键点：给一个合适的初始化容量。可以提高程序的执行效率。3、StringBuffer()
构造一个没有字符的字符串缓冲区，默认初始容量为16个字符。
StringBuffer(int capacity)
构造一个没有字符的字符串缓冲区，并构造指定的初始容量。
4、StringBuffer底层实际上是一个byte[]数组，往StringBuffer中放字符串，实际上是放到byte数组当中了；StringBuffer的初始化容量是16
5、StringBuffer怎样扩容的？
**利用append()方法进行追加扩容**
package com.bjpowernode.javase; public class StringBufferTest02 { public static void main(String[] args) { // 调用无参创建一个初始化容量为16个byte[] 数组。（字符串缓冲区对象） StringBuffer stringBuffer = new StringBuffer(); // 拼接字符串，以后拼接字符串统一调用 append()方法。append是追加的意思。 stringBuffer.append("a"); stringBuffer.append("bc"); stringBuffer.append(3.14); stringBuffer.append(true); // append方法底层在进行追加的时候，如果byte数组满了，会自动扩容。 stringBuffer.append(100L); //输出，默认会调用toString()方法 System.out.println(stringBuffer); //abc3.14true100 //--------------------------指定初始化容量 // 指定初始化容量的StringBuffer对象（字符串缓冲区对象） StringBuffer sb = new StringBuffer(100); //初始化容量是100 sb.append("hello"); sb.append("world"); sb.append("hello"); sb.append("kitty"); //输出，默认会调用toString()方法 System.out.println(sb); } }
❤️使用StringBuilder进行字符串拼接
StringBuffer和StringBuilder的区别？
（1）StringBuffer中的方法都有synchronized(同步的)关键字修饰。表示StringBuffer在多线程环境下运行是安全的。
（2）StringBuilder中的方法都没有synchronized关键字修饰，表示StringBuilder在多线程环境下运行是不安全的。
（3）效果和用法都是相同的；不过StringBuffer是线程安全的，StringBuilder是非线程安全的。
package com.bjpowernode.javase; public class StringBuilderTest01 { public static void main(String[] args) { // 使用StringBuilder也是可以完成字符串的拼接。 StringBuilder sb = new StringBuilder(); sb.append(100); sb.append(true); sb.append("hello"); sb.append("kitty"); System.out.println(sb); } }
❤️String类和StringBuffer类对比（重点）
1、String为什么是不可变的？
String类中内部是一个byte[]数组，这个byte[]数组**采用了final修饰**，因为数组一旦创建长度不可变。并且被final修饰的引用一旦指向某个对象之后，不可再指向其它对象，**所以String是不可变的！** 所以"abc" 无法变成 "abcd"2、StringBuilder/StringBuffer为什么是可变的呢？
StringBuffer/StringBuilder内部实际上也是一个byte[]数组，这个byte[]数组**没有被final修饰**，StringBuffer/StringBuilder的初始化容量是16，当存满之后会进行自动扩容，底层调用了数组拷贝的方法**System.arraycopy()** 方法进行扩容。**所以StringBuilder/StringBuffer 适合于使用字符串的频繁拼接操作。**
public class StringBufferTest03 { public static void main(String[] args) { // 字符串不可变是什么意思？ // 是说双引号里面的字符串对象一旦创建不可变。 String s = "abc"; //"abc"放到了字符串常量池当中。"abc"不可变。 // s变量没有被final修饰，是可以指向其它对象的。 // 字符串不可变不是说变量s不可变。说的是"abc"这个对象不可变。 s = "xyz";//"xyz"放到了字符串常量池当中。"xyz"不可变。 } }#Java##程序员#
