Dieser Artikel stellt hauptsächlich die Java-String-Quellcode-Analyse vor und stellt relevante Informationen darüber vor, warum Sting unveränderlich ist. Freunde in Not können sich auf
Java-String-Quellcode-Analyse
Was ist ein unveränderliches Objekt? Wie wir alle wissen, ist die String-Klasse in Java unveränderlich. Was genau sind also unveränderliche Objekte? Man kann es sich so vorstellen: Wenn ein Objekt seinen Zustand nach seiner Erstellung nicht ändern kann, dann ist das Objekt unveränderlich. Der Status kann nicht geändert werden, was bedeutet, dass die Mitgliedsvariablen innerhalb des Objekts nicht geändert werden können, einschließlich der Werte grundlegender Datentypen. Variablen von Referenztypen können nicht auf andere Objekte verweisen und der Status von Objekten, auf die durch Referenztypen verwiesen wird geändert werden.Unterscheiden Sie zwischen Objekten und Objektreferenzen
Für Java-Anfänger gibt es immer Zweifel daran, dass String ein unveränderliches Objekt ist. Schauen Sie sich den folgenden Code an:
String s = "ABCabc";
System.out.println("s = " + s);
s = "123456";
System.out.println("s = " + s);s = ABCabc s = 123456
Erstellen Sie zuerst ein String-Objekt s, lassen Sie dann den Wert von s „ABCabc“ und dann den Wert von s „123456“ sein. Wie aus den gedruckten Ergebnissen hervorgeht, hat sich der Wert von s tatsächlich geändert. Warum sagen Sie immer noch, dass String-Objekte unveränderlich sind? Tatsächlich liegt hier ein Missverständnis vor: s ist nur eine Referenz auf ein String-Objekt, nicht das Objekt selbst. Das Objekt ist ein Speicherbereich im Speicher. Je mehr Mitgliedsvariablen, desto größer ist der Platz, den dieser Speicherbereich einnimmt. Eine Referenz ist lediglich ein 4-Byte-Datenelement, das die Adresse des Objekts speichert, auf das es verweist. Über diese Adresse kann auf das Objekt zugegriffen werden. Mit anderen Worten, s ist nur eine Referenz, die auf ein bestimmtes Objekt verweist. Wenn s="123456" ausgeführt wird, wird ein neues Objekt „123456“ erstellt und die Referenz s re -zeigt auf das Herzobjekt, und das ursprüngliche Objekt „ABCabc“ ist noch im Speicher vorhanden und hat sich nicht geändert. Die Speicherstruktur ist wie folgt:
Warum sind String-Objekte unveränderlich?
Um die Unveränderlichkeit von String zu verstehen, werfen Sie zunächst einen Blick auf die Mitgliedsvariablen in der String-Klasse. In JDK1.6 lauten die Mitgliedsvariablen von String wie folgt:public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
/** The value is used for character storage. */
private final char value[];
/** The offset is the first index of the storage that is used. */
private final int offset;
/** The count is the number of characters in the String. */
private final int count;
/** Cache the hash code for the string */
private int hash; // Default to 0public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
String a = "ABCabc";
System.out.println("a = " + a);
a = a.replace('A', 'a');
System.out.println("a = " + a);a = ABCabc a = aBCabc
那么a的值看似改变了，其实也是同样的误区。再次说明， a只是一个引用， 不是真正的字符串对象，在调用a.replace('A', 'a')时， 方法内部创建了一个新的String对象，并把这个心的对象重新赋给了引用a。String中replace方法的源码可以说明问题：
读者可以自己查看其他方法，都是在方法内部重新创建新的String对象，并且返回这个新的对象，原来的对象是不会被改变的。这也是为什么像replace， substring，toLowerCase等方法都存在返回值的原因。也是为什么像下面这样调用不会改变对象的值：
String ss = "123456";
System.out.println("ss = " + ss);
ss.replace('1', '0');
System.out.println("ss = " + ss);打印结果：
ss = 123456 ss = 123456
String对象真的不可变吗？
从上文可知String的成员变量是private final 的，也就是初始化之后不可改变。那么在这几个成员中， value比较特殊，因为他是一个引用变量，而不是真正的对象。value是final修饰的，也就是说final不能再指向其他数组对象，那么我能改变value指向的数组吗？ 比如将数组中的某个位置上的字符变为下划线“_”。 至少在我们自己写的普通代码中不能够做到，因为我们根本不能够访问到这个value引用，更不能通过这个引用去修改数组。
那么用什么方式可以访问私有成员呢？ 没错，用反射， 可以反射出String对象中的value属性， 进而改变通过获得的value引用改变数组的结构。下面是实例代码：
public static void testReflection() throws Exception {
//创建字符串"Hello World"， 并赋给引用s
String s = "Hello World";
System.out.println("s = " + s); //Hello World
//获取String类中的value字段
Field valueFieldOfString = String.class.getDeclaredField("value");
//改变value属性的访问权限
valueFieldOfString.setAccessible(true);
//获取s对象上的value属性的值
char[] value = (char[]) valueFieldOfString.get(s);
//改变value所引用的数组中的第5个字符
value[5] = '_';
System.out.println("s = " + s); //Hello_World
}打印结果为：
s = Hello World s = Hello_World
在这个过程中，s始终引用的同一个String对象，但是再反射前后，这个String对象发生了变化， 也就是说，通过反射是可以修改所谓的“不可变”对象的。但是一般我们不这么做。这个反射的实例还可以说明一个问题：如果一个对象，他组合的其他对象的状态是可以改变的，那么这个对象很可能不是不可变对象。例如一个Car对象，它组合了一个Wheel对象，虽然这个Wheel对象声明成了private final 的，但是这个Wheel对象内部的状态可以改变， 那么就不能很好的保证Car对象不可变。
以上就是Java String源码分析并介绍Sting 为什么不可变的详细介绍的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！
