目录
1.2.8 String与byte[]之间的转换——String的编码与解码(IO流会用到)
4. 什么情况下indexOf(str)和lastIndexOf(str)返回的值相同?
2.2.1 delete(int start,int end)
1. String、StringBuffer和StringBuilder的异同
2. 三个类底层都是用char[]存储,为什么String不可变其他两个可变?
3. 如何选择使用String、StringBuffer还是StringBuilder?
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:线程安全的原因在于很多方法是同步的。
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也差不多