Analyse du code source de la chaîne Java

Analyse du code source de la chaîne Java

Qu'est-ce qu'un objet immuable ?

Comme nous le savons tous, en Java, la classe String est immuable. Alors, que sont exactement les objets immuables ? Vous pouvez y penser de cette façon : si un objet ne peut pas changer d'état après sa création, alors l'objet est immuable. L'état ne peut pas être modifié, ce qui signifie que les variables membres au sein de l'objet ne peuvent pas être modifiées, y compris les valeurs des types de données de base. Les variables des types référence ne peuvent pas pointer vers d'autres objets, et l'état des objets pointés par les types référence ne peut pas. être changé.

Distinguer les objets et les références d'objets

Pour les débutants en Java, il y a toujours des doutes sur le fait que String soit un objet immuable. Regardez le code suivant :

String s = "ABCabc"; 
System.out.println("s = " + s); 
 
s = "123456"; 
System.out.println("s = " + s);

Le résultat imprimé est :

s = ABCabc
s = 123456

Créez d'abord un objet String s, puis laissez la valeur de s être "ABCabc", puis laissez la valeur de s être "123456". Comme le montrent les résultats imprimés, la valeur de s a effectivement changé. Alors pourquoi dites-vous encore que les objets String sont immuables ? En fait, il y a ici un malentendu : s est simplement une référence à un objet String, pas à l'objet lui-même. L'objet est une zone mémoire dans la mémoire. Plus il y a de variables membres, plus l'espace occupé par cette zone mémoire est grand. Une référence n'est qu'une donnée de 4 octets qui stocke l'adresse de l'objet vers lequel elle pointe. L'objet est accessible via cette adresse.

En d'autres termes, s est juste une référence, qui pointe vers un objet spécifique. Lorsque s="123456"; après l'exécution de ce code, un nouvel objet "123456" est créé et la référence s re. -pointe vers l'objet cœur, et l'objet d'origine "ABCabc" existe toujours dans la mémoire et n'a pas changé. La structure de la mémoire est la suivante :

Une différence entre Java et C est qu'il est impossible d'exploiter directement l'objet lui-même en Java All. objets Ils sont tous pointés par une référence, et cette référence doit être utilisée pour accéder à l'objet lui-même, notamment obtenir la valeur des variables membres, modifier les variables membres de l'objet, appeler les méthodes de l'objet, etc. En C, il y a trois choses : les références, les objets et les pointeurs, qui peuvent tous trois accéder aux objets. En fait, les références en Java sont conceptuellement similaires aux pointeurs en C. Ce sont toutes deux les valeurs d'adresse des objets stockés en mémoire. Cependant, en Java, les références ont perdu une partie de leur flexibilité. Par exemple, les références en Java ne peuvent pas être utilisées. comme Ajouter et soustraire comme des pointeurs en C.

Pourquoi les objets String sont-ils immuables ?

Pour comprendre l'immuabilité de String, jetez d'abord un œil aux variables membres de la classe String. Dans JDK1.6, les variables membres de String incluent les éléments suivants :

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

Dans JDK1.7, la classe String a apporté quelques modifications, principalement It modifie le comportement de la méthode substring lors de son exécution, ce qui n'est pas lié au sujet de cet article. Il n'y a que deux variables membres principales de la classe String dans JDK1.7 :

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

Comme le montre le code ci-dessus, String en Java A la classe est en fait une encapsulation d’un tableau de caractères. Dans JDK6, value est un tableau encapsulé par String, offset est la position de départ de String dans le tableau de valeurs et count est le nombre de caractères occupés par String. Dans JDK7, il n'y a qu'une seule variable de valeur, c'est-à-dire que tous les caractères de la valeur appartiennent à l'objet String. Ce changement n’affecte pas la discussion de cet article. De plus, il existe une variable membre de hachage, qui est un cache de la valeur de hachage de l'objet String. Cette variable membre n'est pas non plus pertinente pour la discussion de cet article. En Java, les tableaux sont aussi des objets (veuillez vous référer à mon article précédent Caractéristiques des tableaux en Java). La valeur est donc simplement une référence qui pointe vers un véritable objet tableau. En fait, après avoir exécuté le code String s = "ABCabc";, la véritable disposition de la mémoire devrait ressembler à ceci :

Les trois variables value, offset et count sont toutes privées, et aucune méthode publique telle que setValue, setOffset et setCount n'est fournie pour modifier ces valeurs, donc String ne peut pas être modifié en dehors de la classe String. C'est-à-dire qu'une fois initialisé, il ne peut plus être modifié et ces trois membres ne sont pas accessibles en dehors de la classe String. De plus, les trois variables value, offset et count sont toutes définitives, ce qui signifie qu'au sein de la classe String, une fois ces trois valeurs initialisées, elles ne peuvent plus être modifiées. L'objet String peut donc être considéré comme immuable.

Ensuite, dans String, il existe évidemment des méthodes, et les appeler peut obtenir la valeur modifiée. Ces méthodes incluent substring, replace, replaceAll, toLowerCase, etc. Par exemple, le code suivant :

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

Le résultat imprimé est :

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源码分析相关文章请关注PHP中文网！