Spring 常用 API:Spring 类及相关面试点,rabbitmq 分布式事务实现原理
3.String 的构造方法
String( ) 初始化一个新创建的 String 对象,使其表示一个空字符序列。
String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。
String(byte[] bytes, Charset charset) 通过使用指定的 charset 解码指定的 byte 数组,构造一个新的 String。
String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组,构造一个新的 String。
String(byte[] bytes, int offset, int length, Charset charset) 通过使用指定的 charset 解码指定的 byte 子数组,构造一个新的 String。
String(byte[] bytes, int offset, int length, String charsetName) 通过使用指定的字符集解码指定的 byte 子数组,构造一个新的 String。
String(byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组,构造一个新的 String。
String(char[] value) 分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。
String(char[] value, int offset, int count) 分配一个新的 String,它包含取自字符数组参数一个子数组的字符。
String(int[] codePoints, int offset, int count) 分配一个新的 String,它包含 Unicode 代码点数组参数一个子数组的字符。
String(String original) 初始化一个新创建的 String 对象,使其表示一个与参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的副本。
String(StringBuffer buffer) 分配一个新的字符串,它包含字符串缓冲区参数中当前包含的字符序列。
String(StringBuilder builder) 分配一个新的字符串,它包含字符串生成器参数中当前包含的字符序列。
4.String 类实例化和内存解析
4.1 直接赋值法实例化 String 对象
直接赋值方式创建对象是在方法区的常量池
需要注意的是,字符串常量池的位置在 JDK 1.7 有所变化:
JDK 1.7 之前,字符串常量池存在于常量存储(Constant storage)中
JDK 1.7 之后,字符串常量池存在于堆内存(Heap)中
![](https://static001.geekbang.org/infoq/8a/8a1da2ac037d65da24f40e7c43101b12.png)
![](https://static001.geekbang.org/infoq/c8/c845397e32e1adb609f9c10f352142d1.png)
str1 在堆内存上创建新的 String 对象,由于是直接赋值的方式,该 String 对象被加入 JVM 的"对象池"中,而后 str2,str3 再通过直接赋值的方式访问相同的字符串对象"hello",访问到的都是"对象池"中由 str1 创建的那个 String 对象,此时三个引用指向的是同一个 String 对象,因此"=="的结果都为 true。
4.2 通过 new 构造方法()实例化 String 对象
通过构造方法创建字符串对象是在堆内存
![](https://static001.geekbang.org/infoq/7e/7e23534a0daad632d5a1aeb1bba1e247.png)
由于"hello"(字符串字面值常量/String 的匿名对象)也是一个 String 对象,因此,JVM 会现在堆内存空间上创建一个"hello"字符串,再将这个字符串复制一份并由 str 指向,这就导致出现了垃圾空间,会被 JVM 自动回收,并且如果采用构造方法的话,也不会将该字符串对象加入到 JVM 的"字符串常量池"中,导致字符串共享问题。
为了解决"字符串共享"问题,可以使用 String 类的
intern
方法将以构造方法方式创建的String对象手动加入到"字符串常量池"中
。(采用构造方法方式实例化时默认不会将该 String 对象入池)
![](https://static001.geekbang.org/infoq/d8/d816802d771c5864780275fde135dc8c.png)
4.3 总结
直接赋值方法:只会开辟一块堆内存空间,并且该字符串对象可以自动保存在对象池中以供下次使用。
new 构造()方法:会开辟两块堆内存空间,其中一块成为垃圾空间,默认不会自动保存在对象池中,可以使用 intern()方法手工入池。
总结:使用构造方法实例化对象,即便是使用了 intern()方法手动入池,但仍无法解决垃圾空间的问题,因此,一般采用
直接赋值
的方式创建 String 对象。
4.4 避免空指向
“==” 在对字符串比较的时候,对比的是内存地址; equals()方法比较的是字符串内容。
equals()方法通过接受参数,可以避免空指向。
String str = null;
if(str.equals("hello")){//此时会出现空指向异常
...
}
if("hello".equals(str)){//此时 equals 会处理 null 值,可以避免空指向异常
...
}
复制代码
二、String 类的常用方法
==============
获取操作
int length() 获取字符串的长度;
char charAt(int index) 获取指定索引处的字符;
int indexOf(String str) 获取字符串 str 在字符串对象中出现的位置索引,返回 str 的第一个字符的索引位置;
String substring(int start) 从索引 start 处开始截取字符串,一直到结尾;
String substring(int start, int end) 从索引 start(包括 start)开始截取字符串,到 end(不包括 end)结束。
判断操作
boolean equals(Object obj) 比较字符串的内容是否相同(区分大小写);
boolean equalsIgnoreCase(String str) 比较字符串的内容是否相同(忽略大小写);
boolean startsWith(String str) 判断字符对象是否以指定的 str 开头;
boolean endsWith(String str) 判断字符对象是否以指定的 str 结尾;
boolean contans(CharSequence cs) 判断此字符串是否包含指定的字符序列;
boolean isEmpty() 当前仅当字符串长度为 0 是返回 true;
转换操作
char[] toCharArray() 把字符串转换为一个字符数组;
String toLowerCase() 把字符串转换为小写字符;
String toUpperCase() 把字符串转换为大写字符;
String valueOf(int i) 将 int 型数转换为字符串;
截取和分割操作
String[] split(String regex) 根据参数 regex 将原来的字符串分割为若干个字符串;
String substring(int beginIndex) 截取从索引 beginIndex 后的所有字符;
String substring(beginIndex,endIndex) 截取从 beginIndex 到 endIndex 索引之间的字符;
其他方法
String trim() 去除字符串两端空格;
String replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的;
boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式 ;
三、String 类、StringBuffer 类,StringBuilder 类
======================================
1. StringBuffer 和 StringBuilder 类图
![](https://static001.geekbang.org/infoq/f7/f707b29293392680c876849d6c777551.png)
1.1 可变的 StringBuffer 和 StringBuilder
相同点:
StringBuffer
?和?StringBulider
?都代表可变的字符串对象,都继承于?AbstractStringBuilder
这个共同的父类;StringBuffer
?和?StringBulider
?非常类似,提供相关功能的方法也一样;
异同点:
StringBuffer 是线程安全的;多线程环境下经常变动的字符串用 StringBuffer;方法都使用了
synchronized
?关键字进行同步。StringBuilderr 是非线程安全的;单线程经常变动的字符串用 StringBuilder;方法没有用
synchronized
?关键字进行同步。
1.2 不可变的 String 和可变的 StringBuffer
String 类是不可变类,即一旦一个 String 对象被创建以后,包含在这个对象中的字符序列是不可改变的,直至这个对象被销毁。
StringBuffer 对象则代表一个字符序列可变的字符串,当一个 StringBuffer 被创建以后,通过 StringBuffer 提供的 append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过 StringBuffer 生成了最终想要的字符串,就可以调用它的 toString()方法将其转换为一个 String 对象。
1.3 三者之间的区别
![](https://static001.geekbang.org/infoq/f5/f536a5d55dc2e91a420afa1b4b474b2d.png)
四、常见面试点
=======
(1)String 可以被继承吗?
不能被继承,因为 String 类有 final 修饰符,而 final 修饰的类是不能被继承的。
(2)String 为什么设计成不可变,是如何保证不可变的?
在 Java 中,String 类被设计为不可变类,主要表现在它保存字符串的成员变量是 final 的。
Java 9 之前字符串采用 char[]数组来保存字符,即 private final char[] value ;
Java 9 做了改进,采用 byte[]数组来保存字符,即 private final byte[] value ;
如何保证不可变的?
在 java 中考虑到各种因素,需要综合到内存,数据结构以及安全的方面的考虑。
字符串常量池的需要:
当字符串不可变时,字符串常量池才有意义。字符串常量池的出现,可以减少创建相同字面量的字符串,让不同的引用指向池中同一个字符串,为运行时节约很多的堆内存。若字符串可变,字符串常量池失去意义,基于常量池的 String.intern() 方法也失效,每次创建新的字符串将在堆内开辟出新的空间,占据更多的内存。
运行 String 对象缓存 HashCode:
字符串作为基础的数据结构,大量地应用在一些集合容器之中,尤其是一些散列集合,在散列集合中,存放元素都要根据对象的 hashCode() 方法来确定元素的位置。由于字符串 hashcode 属性不会变更,保证了唯一性,使得类似 HashMap、HashSet 等容器才能实现相应的缓存功能。由于 St
ring 的不可变,避免重复计算 hashcode ,只要使用缓存的 hashcode 即可,这样一来大大提高了在散列集合中使用 String 对象的性能。
线程安全性:
在多线程中,只有不变的对象和值是线程安全的,可以在多个线程中共享数据。由于 String 天然的不可变,当一个线程”修改“了字符串的值,只会产生一个新的字符串对象,不会对其他线程的访问产生副作用,访问的都是同样的字符串数据,不需要任何同步操作。
信息安全:
由于字符串无论在任何 Java 系统中都广泛使用,会用来存储敏感信息,如账号,密码,网络路径,文件处理等场景里,保证字符串 String 类的安全性就尤为重要了,如果字符串是可变的,容易被篡改,那我们就无法保证使用字符串进行操作时,它是安全的,很有可能出现 SQL 注入,访问危险文件等操作。
(3)说一说你对字符串拼接的理解!
1.采用“+” 运算符拼接字符串时:
如果拼接的都是字符串是直接常量,则在编译时编译器会将其直接优化为一个完整的字符串,和你直接写一个完整的字符串是一样的,所以效率非常的高。
如果拼接的字符串中包含变量,则在编译时编译器采用 StringBuilder 对其进行优化,即自动创建 StringBuilder 实例并调用其 append()方法,将这些字符串拼接在一起,效率也很高。但如果这个拼接操作是在循环中进行的,那么每次循环编译器都会创建一个 StringBuilder 实例,再去拼接字符串,相当于执行了 new StringBuilder().append(str) ,此时效率很低。
String chenmo = "沉默";
String wanger = "王二";
System.out.println(chenmo + wanger);
复制代码
2.采用 StringBuilder/StringBuffer 拼接字符串时:
StringBuilder/StringBuffer 都有字符串缓冲区,缓冲区的容量在创建对象时确定,并且默认为 16。当拼接的字符串超过缓冲区的容量时,会触发缓冲区的扩容机制,即缓冲区加倍。
缓冲区频繁的扩容会降低拼接的性能,所以如果能提前预估最终字符串的长度,则建议在创建可变字符串对象时,放弃使用默认的容量,可以指定缓冲区的容量为预估的字符串的长度。
评论