5 questions d'entretien à cordes, moins de 10 % des personnes peuvent toutes y répondre correctement ! (avec réponse)

Jetons un coup d'œil à cet article sur 5 questions d'entretien dans la catégorie Java StringJava String类的 5 道面试题，这五道题，我自己在面试过程中亲身经历过几道题目，本篇就带你了解这些题的答案为什么是这样。

st1和st2是否相等？

public class Demo2_String { 
  public static void main(String[] args) {
    String st1 = "abc";
    String st2 = "abc";
    System.out.println(st1 == st2);
    System.out.println(st1.equals(st2));
  }
}

输出结果：

• 第一行：true
• 第二行：true

分析

先看第一个打印语句，在Java中==这个符号是比较运算符，它可以基本数据类型和引用数据类型是否相等，如果是基本数据类型，==比较的是值是否相等，如果是引用数据类型，==. J'ai personnellement vécu plusieurs de ces cinq questions au cours du processus d'entretien. Cet article vous aidera à comprendre pourquoi les réponses à ces questions sont ainsi.

St1 et st2 sont-ils égaux ?

String st1 = new String(“abc”);

🎜Résultat de sortie : 🎜

• Première ligne : true
• Deuxième ligne : true

🎜 Analyse🎜🎜Premier regard sur la première instruction d'impression, en Java ==Ce symbole est un opérateur de comparaison, qui peut déterminer si le type de données de base et le type de données de référence sont égaux. S'il s'agit d'un type de données de base, == compare si les valeurs sont égales. S'il s'agit d'un type de données de référence , == compare si les adresses mémoire de deux objets sont égaux. 🎜🎜Les chaînes n'appartiennent pas aux 8 types de données de base. Les objets chaîne appartiennent aux types de données de référence, "abc" est attribué à deux objets chaîne st1 et st2 en même temps, pointant vers la même adresse, donc le premier Le résultat de la comparaison == dans une instruction d'impression est vrai Ensuite, nous examinons la comparaison des égaux dans la deuxième instruction print. Nous savons que les égaux sont une méthode de la classe parent Object, et cette méthode égale est réécrite dans la classe String. 🎜🎜🎜

在JDK API 1.6文档中找到String类下的equals方法，点击进去可以看到这么一句话“将此字符串与指定的对象比较。当且仅当该参数不为null，并且是与此对象表示相同字符序列的String 对象时，结果才为 true。” 注意这个相同字符序列，在后面介绍的比较两个数组，列表，字典是否相等，都是这个逻辑去写代码实现。

由于st1和st2的值都是“abc”，两者指向同一个对象，当前字符序列相同，所以第二行打印结果也为true。下面我们来画一个内存图来表示上面的代码，看起来更加有说服力。

内存过程大致如下：

1）运行先编译，然后当前类Demo2_String.class文件加载进入内存的方法区

2）第二步，main方法压入栈内存

3）常量池创建一个“abc”对象，产生一个内存地址

4）然后把“abc”内存地址赋值给main方法里的成员变量st1，这个时候st1根据内存地址，指向了常量池中的“abc”。

5）前面一篇提到，常量池有这个特点，如果发现已经存在，就不在创建重复的对象

6）运行到代码 Stringst2 =”abc”, 由于常量池存在“abc”，所以不会再创建，直接把“abc”内存地址赋值给了st2

7）最后st1和st2都指向了内存中同一个地址，所以两者是完全相同的。

到底创建了几个对象？

String st1 = new String(“abc”);

答案是：在内存中创建两个对象，一个在堆内存，一个在常量池，堆内存对象是常量池对象的一个拷贝副本。

分析

我们下面直接来一个内存图。

当我们看到了new这个关键字，就要想到，new出来的对象都是存储在堆内存。然后我们来解释堆中对象为什么是常量池的对象的拷贝副本。

“abc”属于字符串，字符串属于常量，所以应该在常量池中创建，所以第一个创建的对象就是在常量池里的“abc”。

第二个对象在堆内存为啥是一个拷贝的副本呢，这个就需要在JDK API 1.6找到String(String original)这个构造方法的注释：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。所以，答案就出来了，两个对象。

st1和st2是否相等？

package string;
public class Demo2_String {
   public static void main(String[] args) {
     String st1 = new String("abc");
     String st2 = "abc";
     System.out.println(st1 == st2);
     System.out.println(st1.equals(st2));
   }
}

答案：false 和 true 由于有前面两道题目内存分析的经验和理论，所以，我能快速得出上面的答案。

==比较的st1和st2对象的内存地址，由于st1指向的是堆内存的地址，st2看到“abc”已经在常量池存在，就不会再新建，所以st2指向了常量池的内存地址，所以==判断结果输出false，两者不相等。

第二个equals比较，比较是两个字符串序列是否相等，由于就一个“abc”，所以完全相等。

内存图如下

st1和st2是否相等？

public class Demo2_String { 
   public static void main(String[] args) {
     String st1 = "a" + "b" + "c";
     String st2 = "abc";
     System.out.println(st1 == st2);
     System.out.println(st1.equals(st2));
   }
}

答案是：true 和 true 分析：“a”,”b”,”c”三个本来就是字符串常量，进行+符号拼接之后变成了“abc”，“abc”本身就是字符串常量（Java中有常量优化机制），所以常量池立马会创建一个“abc”的字符串常量对象，在进行st2=”abc”,这个时候，常量池存在“abc”，所以不再创建。所以，不管比较内存地址还是比较字符串序列，都相等。

判断一下st2和st3是否相等

public class Demo2_String {
 
   public static void main(String[] args) {
     String st1 = "ab";
     String st2 = "abc";
     String st3 = st1 + "c";
     System.out.println(st2 == st3);
     System.out.println(st2.equals(st3));
   }
}

答案：

• falsefalse
• true

true

analyse

La première réponse ci-dessus est fausse, la seconde est vraie et la seconde est vraie. Nous pouvons le comprendre facilement, car l'une des comparaisons est "abc", et l'autre est "abc" obtenue par épissage, donc la comparaison est égale. , c'est le résultat vrai, on le comprend très bien.

Alors pourquoi le premier jugement est faux, nous sommes confus. De même, ci-dessous, nous utilisons des commentaires API et des diagrammes de mémoire pour expliquer pourquoi ce n'est pas égal.

Tout d'abord, ouvrez l'introduction de String dans l'API JDK 1.6 et recherchez la phrase dans l'image ci-dessous.

Le point clé est la phrase dans le cercle rouge. Nous savons que toutes les données et chaînes sont soumises à l'opération du signe plus (+), et le résultat final est une nouvelle chaîne épissée. À quoi sert exactement l’opération + ? Lecture recommandée.

Le commentaire ci-dessus explique que le principe de cet épissage est que la classe StringBuilder ou StringBuffer et la méthode append à l'intérieur implémentent l'épissage, puis appellent toString() pour convertir l'objet épissé en un objet chaîne, et enfin attribuer l'adresse de l'objet chaîne à une variable. Sur la base de cette compréhension, dessinons un diagramme de mémoire pour analyse.

À propos du processus de mémoire

1) Le pool constant crée l'objet "ab" et l'assigne à st1, donc st1 pointe vers "ab"

2) Le pool constant crée l'objet "abc" et l'assigne vers st2, donc st2 pointe vers "abc"

3) Puisque la méthode d'épissage + est utilisée ici, la troisième étape consiste à utiliser la méthode append de la classe StringBuffer pour obtenir "abc". Notez qu’il ne s’agit pas d’un objet String.

4) La méthode toString de Object est appelée pour remplacer l'objet StringBuffer par un objet String.

5) Attribuez l'objet String (0x0022) à st3🎜🎜Ainsi, le résultat du jugement == de st3 et st2 n'est pas égal car les adresses mémoire des deux objets sont différentes. 🎜

Résumé

Cette question d'entretien nécessite de maîtriser certaines annotations et principes de l'API JDK, ainsi que l'analyse du graphe mémoire, afin d'obtenir les bons résultats. J'avoue que dessiner le graphe mémoire m'a aidé à comprendre le. réponse. Pourquoi est-ce.

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!