5-String-Interviewfragen, weniger als 10 % der Leute können sie alle richtig beantworten! (mit Antwort)

Werfen wir einen Blick auf diesen Artikel über 5 Interviewfragen in der Kategorie 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中==这个符号是比较运算符，它可以基本数据类型和引用数据类型是否相等，如果是基本数据类型，==比较的是值是否相等，如果是引用数据类型，==. Ich habe persönlich mehrere dieser fünf Fragen während des Interviewprozesses erlebt. Dieser Artikel wird Ihnen helfen zu verstehen, warum die Antworten auf diese Fragen so sind.

Sind st1 und st2 gleich?

String st1 = new String(“abc”);

🎜Ausgabeergebnis: 🎜

• Erste Zeile: true
• Zweite Zeile: true

🎜 Analyse🎜🎜Erster Blick auf die erste Druckanweisung in Java ==Dieses Symbol ist ein Vergleichsoperator, der bestimmen kann, ob der Basisdatentyp und der Referenzdatentyp gleich sind. Wenn es sich um einen Basisdatentyp handelt, == vergleicht, ob die Werte gleich sind. Wenn es sich um Referenzdatentypen handelt, == vergleicht, ob die Speicheradressen von zwei Objekte sind gleich. 🎜🎜Strings gehören nicht zu den 8 Grunddatentypen. Oben wird „abc“ gleichzeitig den beiden String-Objekten st1 und st2 zugewiesen, die auf dieselbe Adresse verweisen 1. Das Ausgabeergebnis des ==-Vergleichs in einer print-Anweisung ist wahr Dann schauen wir uns den Vergleich von „equals“ in der zweiten print-Anweisung an. Wir wissen, dass „equals“ eine Methode der übergeordneten Klasse „Object“ ist und diese „equals“-Methode in der String-Klasse überschrieben wird. 🎜🎜🎜

在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

Die erste Antwort oben ist falsch, die zweite ist wahr und die zweite ist wahr. Wir können es leicht verstehen, weil einer der Vergleiche „abc“ ist und der andere „abc“ ist, der durch Spleißen erhalten wird, also der Gleichheitsvergleich , das ist die Ausgabe wahr, wir verstehen es sehr gut.

Warum das erste Urteil falsch ist, sind wir verwirrt. In ähnlicher Weise erklären wir im Folgenden anhand von API-Kommentaren und Speicherdiagrammen, warum dies nicht gleich ist.

Öffnen Sie zunächst die Einführung von String in JDK API 1.6 und suchen Sie den Satz im Bild unten.

Der entscheidende Punkt ist der Satz im roten Kreis. Wir wissen, dass alle Daten und Zeichenfolgen der Pluszeichen-Operation (+) unterzogen werden und das Endergebnis eine gespleißte neue Zeichenfolge ist. Was genau bewirkt die +-Operation? Empfohlen zum Lesen.

Der obige Kommentar erklärt, dass das Prinzip dieses Spleißens darin besteht, dass die StringBuilder- oder StringBuffer-Klasse und die darin enthaltene Append-Methode das Spleißen implementieren und dann toString () aufrufen, um das gespleißte Objekt in ein String-Objekt umzuwandeln und schließlich die Adresse zuzuweisen des String-Objekts in eine Variable. Basierend auf diesem Verständnis zeichnen wir ein Speicherdiagramm zur Analyse.

Über den Speicherprozess

1) Der Konstantenpool erstellt das „ab“-Objekt und weist es st1 zu, sodass st1 auf „ab“ zeigt

2) Der Konstantenpool erstellt das „abc“-Objekt und weist es zu zu st2, also zeigt st2 auf „abc“

3) Da hier die + Spleißmethode verwendet wird, besteht der dritte Schritt darin, die Append-Methode der StringBuffer-Klasse zu verwenden, um „abc“ zu erhalten Beachten Sie, dass es sich nicht um ein String-Objekt handelt.

4) Die toString-Methode von Object wird aufgerufen, um das StringBuffer-Objekt in ein String-Objekt zu ersetzen.

5) Weisen Sie st3 das String-Objekt (0x0022) zu.🎜🎜Das ==-Beurteilungsergebnis von st3 und st2 ist also nicht gleich, da die Speicheradressen der beiden Objekte unterschiedlich sind. 🎜

Zusammenfassung

Diese Interviewfrage erfordert die Beherrschung einiger Anmerkungen und Prinzipien in der JDK-API sowie der Speicherdiagrammanalyse, um die richtigen Ergebnisse zu erhalten. Ich gebe zu, dass mir das Zeichnen des Speicherdiagramms geholfen hat, das zu verstehen Antwort. Warum ist das so?

Das obige ist der detaillierte Inhalt von5-String-Interviewfragen, weniger als 10 % der Leute können sie alle richtig beantworten! (mit Antwort). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!