javaSE常用类（一）—— 字符串类

玛丽莲茼蒿

已于 2024-08-20 16:11:50 修改

阅读量327

点赞数

分类专栏： JavaSE 文章标签： jvm

于 2022-07-12 21:42:41 首次发布

本文链接：https://blog.csdn.net/qq_44886213/article/details/125739632

版权

JavaSE 专栏收录该内容

38 篇文章 6 订阅

订阅专栏

本文详细介绍了Java中的String类，包括其不可变性、常用方法和面试题。分析了String的源码，揭示了final关键字和字符数组在内存中的存储。此外，还探讨了StringBuffer的可变性和扩容机制，以及与String和StringBuilder的异同。内容涵盖字符串拼接、比较、截取、替换等操作，并提供了面试常见问题解答。

摘要由CSDN通过智能技术生成

一、Sting类

1.1 类的源码分析

1.1.1 string类总结（考点总结）

1.2.3 compareTo——比较两个字符串对象的大小

1.2.4 substring方法

1.2.5 indexOf 和 lastIndexOf方法

1.2.6 String和基本数据类型、包装类之间的转换

1.2.7 String与char []之间的转换

1.2.8 String与byte[]之间的转换——String的编码与解码（IO流会用到）

1.3 面试题

3. 值传递和引用传递问题

4. 什么情况下indexOf（str）和lastIndexOf（str）返回的值相同？

二、StringBuffer类

2.1 源码分析

1. 依据源码说明为什么StringBuffer是可变长的

2.2 常用方法

2.2.1 delete（int start,int end）

2.2.2 replace

2.3 面试题

1. String、StringBuffer和StringBuilder的异同

2. 三个类底层都是用char[]存储，为什么String不可变其他两个可变？

3. 如何选择使用String、StringBuffer还是StringBuilder？

三、StringBuilder类

3.1 源码分析

3.2 常用方法

Java只有一个包可以不用导直接用，核心包java.lang包

一、Sting类

java中只有String类可以不用new就能创建对象，但不要误以为它是基本数据类型。string是引用数据类型。

String s = "hello,July 12th";

1.1 类的源码分析

1.1.1 string类总结（考点总结）

1. 在String类这里第一次接触到被final修饰的类，意思是“String类已经被作者写的很完美了，具备你想要的任何功能，不需要再继承然后自己改”。

2. String在类的内部用final char value[]字符数组去存储，由于被final修饰，具有不可变性，对字符串进行任何的修改都必须重新造一个字符串，不能在原有的基础上改。不可变性的一些体现：

1）当对字符串重新赋值时，需要重新指定内存区域，不能使用（覆盖）原有value的内存区域，因为value是final的。

2）对字符串进行拼接操作时（s1 = s1+"hello"），也需要重新指定内存区域赋值。

3）对字符串中字符进行replace替换操作时（s1.replace(a变b)），也需要重新指定内存区域赋值。

3. String内部对接口的实现

1）实现了Serializable接口：表示字符串时支持序列化的（对象字符流化，便于网络传输）。

2）实现了Comparable接口：表示String对象可以比较大小

4. string的定义：用new和用字面量定义不一样。

1.1.2 字面量定义及不可变性的解释

1. 字面量定义string对象

首先我们来看，不用new的方式定义string变量。这种类似于基本数据类型的赋值方法叫做“字面量”

发现，字符串的值可以被改变。这时候会有疑问，string类不是具有不可变性吗？

因为通过“字面量”定义的对象，并没有在堆区创建（没有new），而是存储在字符串常量池中。

2. 字面量的内存模型

我们再尝试用“字面量”定义一个String对象s2，比较s1和s2的地址，发现是一样的。

String s1="abc";  //字面量的定义方式
String s2="abc";

System.out.println(s1==s2); //比较s1和s2的地址值，输出true

PS: “对象==对象” 比较的是两个对象的地址是否相同

因为字符串常量池是不会存储两个相同的字符串的，所以s1和s2指向相同的地址（相同的内存/同一个字符串）。其内存模型如下（以字符串常量池在方法区为例）：

3. 不可变性的体现——对字符串重新赋值

我们对s1进行重新赋值

结论：当对字符串重新赋值时，需要重新指定内存区域，不能使用（覆盖）原有value的内存区域，因为value是final的。

4.不可变性的体现——对字符串进行拼接

String s1 = "July"
String s2 = "July"
s1 = s1 + "13th";

结论：对字符串进行拼接操作时（s1 = s1+"13th"），需要在字符串常量池中为“July13th”重新指定内存区域（如果直接在July上面改的话，s2的值就不对了）。

5.不可变性的体现——字符串调用replace函数

String s1 = "Today finish HPV vaccine";
String s2 = "Today finish HPV vaccine";

s1.repalce("i","I"); //将s1中的i字符替换成I

结论：对字符串中字符进行replace替换操作时（s1.replace(a变b)），需要在字符串常量池中为修改后的字符串重新指定内存区域（同理，如果直接在原字符串上改，s2的值就不对了）。

1.2 常用方法

1.2.1 构造方法

主要是下面几种：

1. String s1 = "hello" 和String s1 = new String("hello")的区别

1）单独定义String类

引用s1和s2保存的地址值在方法区，并且是同一个；引用s2和s3保存的地址值在堆区，无论字符串是否相同，地址值都不同。

2）类中以“字面量”形式定义String属性

String类的属性name存储的是字符串常量的地址

3）类中以new的方式定义String属性

p1.name和p2.name存储的是两个不同的堆区地址，所以输出false。看一下内存模型就容易理解了：

1.2.2 String的拼接

只需要记住结论就好：

1）常量与常量的拼接结果在常量池

2）只要有一个变量(无论是string变量还是int变量)，结果就在堆中

3）如果调用intern函数，那么一定在常量池中

以s3和s5为例，给出其内存模型，s3存储的地址在常量池中，s5存储的地址在堆中。

再看用intern函数返回的

1.2.3 compareTo——比较两个字符串对象的大小

来看一下这个函数源码的逻辑

1）在下面例子中，返回的是两字符串第一个不同字符“c-e”和“e-c”的大小

    String s1 = new String("abc");
    String s2 =new String("abe");
    System.out.println(s1.compareTo(s2));   //-2
    System.out.println(s2.compareTo(s1));  //2

2）如果s1包含在s2中，那么返回s1.length-s2.length

    String s1 = new String("abc");
    String s2 =new String("abcdefg");
    System.out.println(s1.compareTo(s2));  //-4

1.2.4 substring方法

注意，当substring函数有两个参数的时候，是一个左闭右开区间[2,5)，并且右边可以写字符串结束符“\0”的下标。

    String s1 = new String("今天入伏了");
    String s2 = s1.substring(2);
    System.out.println(s2);  //入伏了

    s2 = s1.substring(2,5);  //[2,5)
    System.out.println(s2);  //入伏了

1.2.5 indexOf 和 lastIndexOf方法

注意，lastIndexOf两个参数时，第二个参数代表“从此处开始反向搜索”

        String s1 = new String("aabbaabb");
        System.out.println(s1.indexOf("aa"));  //0
        System.out.println(s1.indexOf("cc"));  //-1

        System.out.println(s1.indexOf("aa", 2)); //4

        System.out.println(s1.lastIndexOf("aa"));  //4
        
        //从下标为7开始往前找
        System.out.println(s1.lastIndexOf("bb", 7)); //6

1.2.6 String和基本数据类型、包装类之间的转换

1）String-->基本数据类型、包装类：调用包装类的 parseXxx(str)函数

2）基本数据类型、包装类-->String：调用String的 valueOf(xxx)函数

1.2.7 String与char []之间的转换

1）String-->char [] ：调用String的toCharArray

2）char[]--> String：调用String的构造器

1.2.8 String与byte[]之间的转换——String的编码与解码（IO流会用到）

        String s1 ="july16抓紧时间";
        byte[] bytes = s1.getBytes();  //使用默认字符集进行编码，、IDEA默认是utf-8
        byte[] gbks = s1.getBytes("gbk");  //使用指定的字符集进行编码
        System.out.println(Arrays.toString(bytes));
        System.out.println(Arrays.toString(gbks));

        /*------------------------*/
        String s2 = new String(bytes);  //使用默认字符集进行解码，IDEA默认是utf-8
        String s3 = new String(gbks);  //解码和编码不一致，出现乱码
        System.out.println(s2);
        System.out.println(s3);
        s3=new String(gbks,"gbk");  //解码和编码保持一致
        System.out.println(s3);

注意utf-8是边长编码，英文和数字只占一个字节，字符占3个字节

1.3 面试题

1. String s = new String ("abc")方式创建对象，在内存中创建了几个对象？

答：2个。一个是堆空间中new出来的String类对象，一个是char[]数组在常量池中（注意数组也是引用数据类型！）

如果“abc”在常量池中已经存在了，那么只创建了new出来的一个String类对象

2. 字符串拼接的地址问题

只要有变量参与就在堆里，第一个例子不仅因为出现了变量s，i也是。

PS: 这个图画的比较简单，堆中应该存储的是常量池的地址，这里直接用字符串表示了。

3. 值传递和引用传递问题

之前学习的时候，结论是这样的：

基本数据类型传递的是里面的数据，引用数据类型传递的是地址值；

其中，当多个引用（地址）指向同一实体时，所有的引用（地址）都能操纵这个实体，具有不变性的String除外

这里change的参数都是引用数据类型，按理说可以对实体进行改变，但是具有不变性的string除外。

4. 什么情况下indexOf（str）和lastIndexOf（str）返回的值相同？

情况 1）存在唯一的一个str

情况 2) 不存在str，都返回-1

PS: 别忽律了情况2）

二、StringBuffer类

2.1 源码分析

1. 依据源码说明为什么StringBuffer是可变长的

1）我们知道String类的字符串底层是用final char[] value这样一个被final修饰的字符数组去存储的，而StringBuffer类的底层数组char[] value并没有被final修饰。

2）这里还有一个问题，创建了一个StringBuffer（“abc”）对象以后，底层按理说应该相应地创建一个大小为3的数组char[] value= new char [3]，并且这个value数组的长度是固定的。那么如何实现变长呢？看其构造器源码，我们发现，创建一个空的StringBuffer时，默认value数组长度为16，

创建一个有初始值的StringBuffer，value的长度在初始长度的基础上+16。

这样就实现了StringBuffer的可变长。详细说明如下：

String str = new String();//相当于 char[] value =new char[0]
String str1 = new String("abc");//相当于 char[] value = new char[]{'a','b','c'}

StringBuffer sb1 = new StringBuffer(); //相当于 char[] value=new char [16];
                                                                    //长度为16
System.out.println(sb1.length());  //输出0，而不是16
sb1.append('a'); //相当于 value[0]='a'
sb1.append('b'); //相当于 value[1]='b'
sb1.append('c'); //相当于 value[2]='c'
System.out.println(sb1.length());//输出3，而不是16

3）现在还有一个问题，如果我们后来加入的字符串长度超过16了怎么办？这就涉及到了底层char[] value数组的“扩容问题”。还要看StringBuffer.append方法的源码，一步一步点进去。发现最底层是这样扩容的：“重新创建一个数组value，大小为原来长度的两倍+2，把原来数组中的值一个个复制到新数组里”

4）此时又出现了新问题，每一次扩容都需要重新new一个value数组，然后再进行拷贝操作，这会降低代码的效率。如何避免呢？

创建StringBuffer的时候我们推荐使用下面这个有参构造函数，指定value的大小（因为项目是自己写的，这个字符串以后会变成多长程序员心中大概有数），这样就会减少扩容的次数。

2.2 常用方法

记忆：

2.2.1 delete（int start,int end）

注意左闭右开区间[start,end)

2.2.2 replace

注意左闭右开区间

2.3 面试题

1. String、StringBuffer和StringBuilder的异同

1）不同之处：

还有一点编码上的不同之处，由于String类具有不可变性，每次对String类进行操作以后都需要重新创建一个String对象去接收它，比如String str2 = str1.repalce("a","b")；而StringBuffer和StringBuilder直接在本身的基础上改动就行。所以区别在于，StringBuffer和StringBuilder一般不需要返回值。

StringBuffer：线程安全的原因在于很多方法是同步的。