Analyse des Java-String-Quellcodes und eine detaillierte Einführung, warum Sting unveränderlich ist

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);

Das gedruckte Ergebnis ist:

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:

Ein Unterschied zwischen Java und C++ besteht darin, dass es in Java nicht möglich ist, das Objekt selbst direkt zu bedienen Objekte Auf alle wird durch eine Referenz verwiesen, und diese Referenz muss verwendet werden, um auf das Objekt selbst zuzugreifen, einschließlich des Abrufens des Werts von Mitgliedsvariablen, des Änderns der Mitgliedsvariablen des Objekts, des Aufrufens der Methoden des Objekts usw. In C++ gibt es drei Dinge: Referenzen, Objekte und Zeiger, die alle auf Objekte zugreifen können. Tatsächlich sind Referenzen in Java und Zeiger in C++ konzeptionell ähnlich. Sie sind die Adresswerte von im Speicher gespeicherten Objekten. In Java können Referenzen jedoch nicht wie Addition und Subtraktion verwendet werden werden wie Zeiger in C++ ausgeführt.

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 0

In JDK1.7 hat die String-Klasse einige Änderungen vorgenommen, hauptsächlich It Ändert das Verhalten der Teilstring-Methode bei der Ausführung, was nicht mit dem Thema dieses Artikels zusammenhängt. In JDK1.7 gibt es nur zwei Hauptmitgliedsvariablen der String-Klasse:

public 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

Wie aus dem obigen Code ersichtlich ist, ist String in Java A Die Klasse ist eigentlich eine Kapselung eines Zeichenarrays. In JDK6 ist value ein von String gekapseltes Array, offset ist die Startposition von String im Wertearray und count ist die Anzahl der von String belegten Zeichen. In JDK7 gibt es nur eine Wertvariable, dh alle Zeichen im Wert gehören zum String-Objekt. Diese Änderung hat keinen Einfluss auf die Diskussion dieses Artikels. Darüber hinaus gibt es eine Hash-Mitgliedsvariable, die einen Cache des Hash-Werts des String-Objekts darstellt. Diese Mitgliedsvariable ist für die Diskussion dieses Artikels ebenfalls irrelevant. In Java sind Arrays auch Objekte (siehe meinen vorherigen Artikel „Eigenschaften von Arrays in Java“). Der Wert ist also nur eine Referenz, die auf ein echtes Array-Objekt verweist. Tatsächlich sollte nach der Ausführung des Codes String s = „ABCabc“; das tatsächliche Speicherlayout wie folgt aussehen:

Die drei Variablen Wert, Offset und Anzahl sind alle privat und es werden keine öffentlichen Methoden wie setValue, setOffset und setCount zum Ändern dieser Werte bereitgestellt, sodass String nicht außerhalb der String-Klasse geändert werden kann. Das heißt, nach der Initialisierung kann es nicht mehr geändert werden und auf diese drei Mitglieder kann außerhalb der String-Klasse nicht zugegriffen werden. Darüber hinaus sind die drei Variablen Wert, Offset und Anzahl alle endgültig, was bedeutet, dass diese drei Werte innerhalb der String-Klasse nach der Initialisierung nicht mehr geändert werden können. Daher kann das String-Objekt als unveränderlich betrachtet werden.

Dann gibt es in String offensichtlich einige Methoden, deren Aufruf den geänderten Wert erhalten kann. Zu diesen Methoden gehören Teilzeichenfolge, Ersetzen, ErsetzenAll, ToLowerCase usw. Zum Beispiel der folgende Code:

String a = "ABCabc"; 
System.out.println("a = " + a); 
a = a.replace('A', 'a'); 
System.out.println("a = " + a);

Das gedruckte Ergebnis ist:

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中文网（www.php.cn）！