Résumé de la relation entre le type de base et les données de type encapsulé, ainsi que le tas et la pile en Java

Le tas de Java est une zone de données d'exécution, à partir de laquelle les objets de classe allouent de l'espace. Ces objets sont créés via des instructions telles que new, newarray, anewarray et multianewarray, et ils ne nécessitent pas que le code du programme soit explicitement composé. de déchets L'avantage du tas est qu'il peut allouer dynamiquement la taille de la mémoire, et la durée de vie n'a pas besoin d'être indiquée au compilateur à l'avance, car il alloue dynamiquement la mémoire au moment de l'exécution, et le garbage collector de Java collectera automatiquement celles qui ne sont plus utilisées. Données. Mais l'inconvénient est qu'en raison de l'allocation dynamique de la mémoire au moment de l'exécution, la vitesse d'accès est plus lente

L'avantage de la pile est que la vitesse d'accès est plus rapide que celle du tas, juste derrière le registre. , et les données de la pile peuvent être partagées. Mais l'inconvénient est que la taille et la durée de vie des données stockées dans la pile doivent être déterminées, et il y a un manque de flexibilité. La pile stocke principalement certains types de variables de base (int, short). , long, byte, float, double, boolean, char) et Object handle

Une particularité très importante de la pile est que les données stockées dans la pile peuvent être partagées. :

int a = 3; 
int b = 3；

Le compilateur traite d'abord int a = 3 ; il créera d'abord une référence à la variable a dans la pile, puis vérifiera s'il y a une valeur de 3 dans la pile. . S'il n'est pas trouvé, il stockera 3 dans, puis pointera a vers 3 ; puis traitera int b = 3 ; Après avoir créé la variable de référence de b, puisqu'il y a déjà une valeur de 3 sur la pile, b est directement pointé vers. 3. De cette façon, a et b pointent tous deux vers 3 en même temps. Si vous définissez à nouveau a=4, le compilateur recherchera à nouveau s'il y a une valeur 4 dans la pile. Sinon, il stockera 4. in et faites un point sur 4 ; s'il existe déjà, il pointera directement a vers cette adresse. Le changement de valeur n'affectera pas la valeur de b.

Il est à noter que ce type de partage de données. est différent du partage des références de deux objets pointant vers un même objet en même temps, car dans ce cas, la modification de a n'affecte pas la valeur de b. Elle n'affectera pas b, elle est effectuée par le compilateur, ce qui est le cas. permet d'économiser de l'espace. Si une variable de référence d'objet modifie l'état interne de cet objet, cela affectera une autre variable de référence d'objet.

Une chaîne de données de type wrapper spéciale peut être créée sous deux formes :


. La première consiste à utiliser new() pour créer un nouvel objet, qui sera stocké dans le tas. Chaque fois qu'il est appelé, un nouvel objet sera créé. consiste d'abord à créer une variable de référence d'objet str de la classe String dans la pile, puis à vérifier si "abc" est stocké dans la pile. Sinon, "abc" est stocké sur la pile et str pointe vers "abc". ". S'il y a déjà "abc", pointez directement str vers "abc".

String str = new String("abc"); 
String str = "abc";

Pour comparer si les valeurs de la classe sont égales, utilisez la méthode equals(). ;Lorsque vous testez si les références de deux classes wrapper pointent vers le même objet, utilisez == L'exemple suivant illustre la théorie ci-dessus.

System.out.println(str1==str2); //true
On peut voir que str1 et str2 pointent vers le même objet.

String str1 = "abc"; 
String str2 = "abc";

Utiliser new, c'est générer différents objets. Générez-en un à la fois.

Par conséquent, si vous utilisez la première méthode pour créer plusieurs chaînes "abc", il n'y a en fait qu'un seul objet dans la mémoire. Cette méthode d'écriture est bénéfique pour économiser de l'espace mémoire, en même temps, elle peut s'améliorer. les performances du programme dans une certaine mesure. Vitesse d'exécution, car la JVM déterminera automatiquement s'il est nécessaire de créer un nouvel objet en fonction de la situation réelle des données dans la pile. Pour le code de String str = new String("abc");, de nouveaux objets sont toujours créés dans le tas, que leurs valeurs de chaîne soient égales ou qu'il soit nécessaire de créer de nouveaux objets, augmentant ainsi la charge sur le programme.

String str1 =new String ("abc"); 
String str2 =new String ("abc"); 
System.out.println(str1==str2); // false

Par contre, attention : Lorsque nous définissons une classe en utilisant un format tel que String str = "abc";, nous supposons toujours que l'objet str de la classe String est créé. Attention aux pièges ! L'objet n'a peut-être pas été créé ! Il peut simplement pointer vers un objet créé précédemment. Ce n'est que grâce à la méthode new() que nous pouvons garantir qu'un nouvel objet est créé à chaque fois.


En raison de la nature immuable de la classe String, lorsque la variable String doit fréquemment modifier sa valeur, vous devriez envisager d'utiliser la classe StringBuffer pour améliorer l'efficacité du programme. Le tas de Java est une zone de données d'exécution à partir de laquelle les objets de classe allouent de l'espace. Ces objets sont créés via des instructions telles que new, newaray, anewarray et multianewarray. Ils ne nécessitent pas de libération explicite du code du programme. , l'avantage du tas est qu'il peut allouer dynamiquement la taille de la mémoire, et la durée de vie n'a pas besoin d'être indiquée au compilateur à l'avance, car il alloue dynamiquement la mémoire au moment de l'exécution, et le garbage collector de Java collectera automatiquement les données qui ne sont pas plus utilisé. L'inconvénient est qu'en raison de l'allocation dynamique de la mémoire au moment de l'exécution, la vitesse d'accès est lente

/************************************************** ************************************************** ********************************************/

1. Types de données en Java : types de données de base et références. Type de données ;

2. Bien que Java n'explique pas comment la mémoire est allouée lorsque le programme est en cours d'exécution, les développeurs ou les apprenants Java divisent généralement la mémoire en trois zones : l'espace de pile, l'espace de tas. , zone de méthode ;

Zone de tas :

a.Tous les objets sont stockés et chaque objet contient des informations sur une classe correspondante (le but de la classe est d'obtenir des instructions d'opération. )

b.jvm只有一个堆区被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身

栈区:

a.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中

b.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。

c.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。

方法区:

a.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。

b.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。字符串常量在方法区分配 ，数组既在栈空间分配数组名称， 又在堆空间分配数组实际的大小。

上面明白之后，接下来我们来分析 String str=new String("abc");

String str 是定义了一个String类型的变量，此时只定义了而没有创建对象，而new Sring（“abc”）到底做了什么？我们可以查看String的源码，发现如下：

public final class String
        implements java.io.Serializable, Comparablef7e83be87db5cd2d9a8a0b8117b38cd4, CharSequence
        {
                /** The value is used for character storage. */
                private final char value[];
                ……

发现她有一个Value的属性，类型是char[]，而此数组又做了什么事情？如果读源码会发现他保存了String对象的值，此时也说明String就是char[]来组织的。

当执行String a="abc";时，JAVA虚拟机会在栈中创建三个char型的值'a'、'b'和'c'，然后在堆中创建一个String对象，它的值（value）是刚才在栈中创建的三个char型值组成的数组{'a','b','c'}对象，而这个新创建的String对象会被添加到字符串池中。

此时就存在了两个对象：一个在堆中；一个在字符串池中。

/**************************************************************************************************************************/

     String str1 = "abc";
   String str2 = new String("abc");

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!