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）中

• str1 在堆内存上创建新的 String 对象，由于是直接赋值的方式，该 String 对象被加入 JVM 的"对象池"中，而后 str2，str3 再通过直接赋值的方式访问相同的字符串对象"hello"，访问到的都是"对象池"中由 str1 创建的那个 String 对象，此时三个引用指向的是同一个 String 对象，因此"=="的结果都为 true。

4.2 通过 new 构造方法（）实例化 String 对象

通过构造方法创建字符串对象是在堆内存

• 由于"hello"(字符串字面值常量/String 的匿名对象)也是一个 String 对象，因此，JVM 会现在堆内存空间上创建一个"hello"字符串，再将这个字符串复制一份并由 str 指向，这就导致出现了垃圾空间，会被 JVM 自动回收，并且如果采用构造方法的话，也不会将该字符串对象加入到 JVM 的"字符串常量池"中，导致字符串共享问题。

为了解决"字符串共享"问题，可以使用 String 类的intern方法将以构造方法方式创建的String对象手动加入到"字符串常量池"中。(采用构造方法方式实例化时默认不会将该 String 对象入池)

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 类图

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 三者之间的区别

四、常见面试点

=======

（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

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开：qq.cn.hn/FTe 免费领取

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。当拼接的字符串超过缓冲区的容量时，会触发缓冲区的扩容机制，即缓冲区加倍。

缓冲区频繁的扩容会降低拼接的性能，所以如果能提前预估最终字符串的长度，则建议在创建可变字符串对象时，放弃使用默认的容量，可以指定缓冲区的容量为预估的字符串的长度。