本文探讨了 Java 中 String 类为何被设计为 final 类，分析了 String 的不可变性带来的安全性和线程安全性，以及如何支持字符串常量池。
转发自：https://blog.youkuaiyun.com/u013905744/article/details/52414111
大神链接：在java中String类为什么要设计成final？ - 程序员 - 知乎
我进行了重新排版，并且更换了其中的一个例子，让我们更好理解。
String很多实用的特性，比如说“不可变性”，是工程师精心设计的艺术品！艺术品易碎！用final就是拒绝继承，防止世界被熊孩子破坏，维护世界和平！
1. 什么是不可变？
String不可变很简单，如下图，给一个已有字符串“abcd”第二次赋值成“abcedl”，不是在原内存地址上修改数据，而是重新指向一个新对象，新地址。
2. String为什么不可变？
翻开JDK源码，java.lang.String类起手前三行，是这样写的：
- public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
- /** String本质是个char数组. 而且用final关键字修饰.*/
- private final char value[];
- …
- …
- }
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** String本质是个char数组. 而且用final关键字修饰.*/
private final char value[];
...
...
}
首先String类是用final关键字修饰，这说明String不可继承。再看下面，String类的主力成员字段value是个char[ ]数组，而且是用final修饰的。final修饰的字段创建以后就不可改变。
有的人以为故事就这样完了，其实没有。因为虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。Array的数据结构看下图
也就是说Array变量只是stack上的一个引用，数组的本体结构在heap堆。String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。看下面这个例子，
- final int[] value={1,2,3}
- int[] another={4,5,6};
- value=another; //编译器报错，final不可变
final int[] value={1,2,3}
int[] another={4,5,6};
value=another; //编译器报错，final不可变
value用final修饰，编译器不允许我把value指向堆区另一个地址。但如果我直接对数组元素动手，分分钟搞定。
- final int[] value={1,2,3};
- value[2]=100; //这时候数组里已经是{1,2,100}
final int[] value={1,2,3};
value[2]=100; //这时候数组里已经是{1,2,100}
或者更粗暴的反射直接改，也是可以的。
- final int[] array={1,2,3};
- Array.set(array,2,100); //数组也被改成{1,2,100}
final int[] array={1,2,3};
Array.set(array,2,100); //数组也被改成{1,2,100}
所以String是不可变，关键是因为SUN公司的工程师，在后面所有String的方法里很小心的没有去动Array里的元素，没有暴露内部成员字段。
private final char value[]这一句里，private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承，避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。
3. 不可变有什么好处？
这个最简单的原因，就是为了安全。
示例1
- package _12_01字符串;
- public class 为什么String要设计成不可变类你 {
- public static void main(String[] args) {
- String a, b, c;
- a = ”test”;
- b = a;
- c = b;
- String processA = processA(a);
- String processB = processB(b);
- String processC = processC(c);
- System.out.println(processA);
- System.out.println(processB);
- System.out.println(processC);
- }
- static String processA(String str){
- return str + “A”;
- }
- static String processB(String str){
- return str + “B”;
- }
- static String processC(String str){
- return str + “C”;
- }
- }
- //OUTPUT
- // testA
- //testB
- //testC
package _12_01字符串;
public class 为什么String要设计成不可变类你 {
public static void main(String[] args) {
String a, b, c;
a = "test";
b = a;
c = b;
String processA = processA(a);
String processB = processB(b);
String processC = processC(c);
System.out.println(processA);
System.out.println(processB);
System.out.println(processC);
}
static String processA(String str){
return str + "A";
}
static String processB(String str){
return str + "B";
}
static String processC(String str){
return str + "C";
}
}
//OUTPUT
// testA
//testB
//testC
当String支持非可变性的时候，它们的值很好确定，不管调用哪个方法，都互不影响。
如果String是可变的，就可能如下例，我们使用StringBuffer来模拟String是可变的
- package _12_01字符串;
- public class 为什么String要设计成不可变类2 {
- public static void main(String[] args) {
- StringBuffer a, b, c;
- a = new StringBuffer(“test”);
- b = a;
- c = b;
- String processA = processA(a);
- String processB = processB(b);
- String processC = processC(c);
- System.out.println(processA);
- System.out.println(processB);
- System.out.println(processC);
- }
- static String processA(StringBuffer str){
- return str.append(“A”).toString();
- }
- static String processB(StringBuffer str){
- return str.append(“B”).toString();
- }
- static String processC(StringBuffer str){
- return str.append(“C”).toString();
- }
- }
- //OUTPUT
- // testA
- //testAB
- //testABC
package _12_01字符串;
public class 为什么String要设计成不可变类2 {
public static void main(String[] args) {
StringBuffer a, b, c;
a = new StringBuffer("test");
b = a;
c = b;
String processA = processA(a);
String processB = processB(b);
String processC = processC(c);
System.out.println(processA);
System.out.println(processB);
System.out.println(processC);
}
static String processA(StringBuffer str){
return str.append("A").toString();
}
static String processB(StringBuffer str){
return str.append("B").toString();
}
static String processC(StringBuffer str){
return str.append("C").toString();
}
}
//OUTPUT
// testA
//testAB
//testABC
能看出b=a,c=b;程序员的本意是希望变量是不变的。所以String不可变的安全性就体现在这里。实际上StringBuffer的作用就是起到了String的可变配套类角色。
示例2
再看下面这个HashSet用StringBuilder做元素的场景，问题就更严重了，而且更隐蔽。
- class Test{
- public static void main(String[] args){
- HashSet<StringBuilder> hs=new HashSet<StringBuilder>();
- StringBuilder sb1=new StringBuilder(“aaa”);
- StringBuilder sb2=new StringBuilder(“aaabbb”);
- hs.add(sb1);
- hs.add(sb2); //这时候HashSet里是{“aaa”,”aaabbb”}
- StringBuilder sb3=sb1;
- sb3.append(”bbb”); //这时候HashSet里是{“aaabbb”,”aaabbb”}
- System.out.println(hs);
- }
- }
- //Output:
- //[aaabbb, aaabbb]
class Test{
public static void main(String[] args){
HashSet<StringBuilder> hs=new HashSet<StringBuilder>();
StringBuilder sb1=new StringBuilder("aaa");
StringBuilder sb2=new StringBuilder("aaabbb");
hs.add(sb1);
hs.add(sb2); //这时候HashSet里是{"aaa","aaabbb"}
StringBuilder sb3=sb1;
sb3.append("bbb"); //这时候HashSet里是{"aaabbb","aaabbb"}
System.out.println(hs);
}
}
//Output:
//[aaabbb, aaabbb]
不可变性支持线程安全
还有一个大家都知道，就是在并发场景下，多个线程同时读一个资源，是不会引发竟态条件的。只有对资源做写操作才有危险。不可变对象不能被写，所以线程安全。
不可变性支持字符串常量池
最后别忘了 String 另外一个字符串常量池的属性。像下面这样字符串 one 和 two 都用字面量 “something” 赋值。它们其实都指向同一个内存地址。- String one = “someString”;
- String two = ”someString”;
String one = "someString";
String two = "someString";
这样在大量使用字符串的情况下，可以节省内存空间，提高效率。但之所以能实现这个特性，String的不可变性是最基本的一个必要条件。要是内存里字符串内容能改来改去，这么做就完全没有意义了。
总的来说：
1、由于String类不能被继承，所以就不会没修改，这就避免了因为继承引起的安全隐患，如果不设置为final，String类在Java中是经常用到的，如果能够重写、修改，那Java的优点之一，安全性将大打折扣。
2、String每次出现时都用final来修饰，这无疑会降低程序的执行效率，所以干脆直接将其设为final一提高效率。
扫一扫
1436
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
