javaSE常用类 —— 字符串类

Posted 2022-09-16 玛丽莲茼蒿

一、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();  //使用默认字符集进行编码，目前是utf-8（IDEA设置的？？
        byte[] gbks = s1.getBytes("gbk");  //使用指定的字符集进行编码
        System.out.println(Arrays.toString(bytes));
        System.out.println(Arrays.toString(gbks));

        /*------------------------*/
        String s2 = new String(bytes);  //使用默认字符集进行解码，目前是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：线程安全的原因在于很多方法是同步的。

StringBuilder：jdk5.0新增的，原因就是String和StringBuffer效率太低，引入了效率高的StringBuilder，但是效率高的代价就是不安全。

2）相同之处：

        底层都是用char[]数组存储

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

见StringBuffer的源码解析。StringBuilder和StringBuffer一样（StringBuilder是后来引入的，只是做了稍微的改动，很多地方和String以及StringBufferd都相同）。

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

如果需要对一个字符串进行频繁的修改，那么选择StringBuffer和StringBuilder，再根据是否需要保证线程安全确定使用二者中的哪一个。

4. 三者的效率比较

三、StringBuilder类

3.1 源码分析

扩容的方法和StringBuffer相同。

3.2 常用方法

和StringBuffer也差不多