blocks|key|1407326|text|在第一种情况下，编译器不能确定str1和str2将具有什么值，因此它不是常量表达式，因此将在运行时计算它。将有三个对象(两个来自字符串文字，一个创建为字符串的串联)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1407327|在第二种情况下，编译器能够计算结果，因此将只有一个对象，就像您编写"JAVAWORLD"一样|1407328|entityMap^0|F|4|K|4|0|X|B|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

In the first case compiler can not be sure what values <code>str1</code> and <code>str2</code> will have, so it is not a constant expression and thus it will be evaluated in runtime. There will be three objects (two from string literals and one created as its concatenation).

In the second case compiler is able to compute result, so there will be just one object, as if you wrote <code>"JAVAWORLD"</code>

blocks|key|3926667|text|在第一种情况下，将创建三个对象，并且所有这些对象都是可访问的，因为您拥有对它们的活动引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3926668|在第二种情况下，如果您正在执行如下操作|3926669|String+str1="JAVA";
String+str2="WORLD";
String+strTest="JAVA"%2B"WORLD";|code-block|syntax|javascript|3926670|然后，将创建三个对象。在这里，当你创建strTest时，"JAVA“将在字符串对象池中，所以它不会为此分配内存，而是直接从池中引用。对于"WORLD“也是如此。然后将在这两个对象的基础上创建一个新对象，并将其分配给strTest。这里的可访问对象将是3。|3926671|但是如果你正在做像这样的事情|3926672|+String+strTest="JAVA"%2B"WORLD";|3926673|这里只有一个你可以访问的对象，那就是"JAVAWORLD“。池中有对"JAVA“和"WORLD”的引用，但您无法直接访问它们。正如@Vivin+Paliath提到的，"JAVA“和"WORLD”将被实例化以形成一个新的对象"JAVAWORLD“。因此，只创建了两个对象。|3926674|有关字符串对象池see+here的详细信息，请参阅|offset|length|3926675|希望这能有所帮助。|3926676|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html^0|0|0|0|0|0|0|0|8|8|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$S|1C|T|1D|1|1E]]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

In first case three objects will get created and all of them will be accessible since you are having live references to them.

In second case if you are doing something like 

<pre><code>String str1="JAVA";
String str2="WORLD";
String strTest="JAVA"+"WORLD";
</code></pre>

Then there will be three objects that will get created. Here "JAVA" will be in String object pool while you are creating strTest so it will not allocate memory for that and it will take direct reference from the pool. Similarly for "WORLD" too. And then a new object will get created out of these two objects and it will be assigned to strTest. The accessible objects here will be 3.

But if you are doing something like 

<pre><code> String strTest="JAVA"+"WORLD";
</code></pre>

Here only ONE object is accessible to you which is "JAVAWORLD". References to "JAVA" and "WORLD" are there in pool but there is no way you can directly access them. As @Vivin Paliath mentioned "JAVA" and "WORLD" will be interned to form a new Object "JAVAWORLD". Hence, only two objects gets created.

For more information related to String object pool <a href="http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html" rel="nofollow">see here</a>

Hope this helps.

blocks|key|1610589|text|在第一个示例中，您将得到三个String对象。您实际上可以在字节码中看到这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1610590|假设您有以下代码：|1610591|public+class+StrTest+{
++++public+static+void+main(String[]+args)+{
++++++++String+str1+=+"JAVA";
++++++++String+str2+=+"WORLD";

++++++++String+str3+=+str1+%2B+str2;

++++++++String+strTest+=+"JAVA"+%2B+"WORLD";
++++}
}|code-block|syntax|javascript|1610592|得到的字节码是：|1610593|public+class+StrTest+{
++public+StrTest();
++++Code:
+++++++0:+aload_0+++++++
+++++++1:+invokespecial+#1++++++++++++++++++//+Method+java/lang/Object."<init>":()V
+++++++4:+return++++++++

++public+static+void+main(java.lang.String[]);
++++Code:
+++++++0:+ldc+++++++++++#2++++++++++++++++++//+String+JAVA
+++++++2:+astore_1++++++
+++++++3:+ldc+++++++++++#3++++++++++++++++++//+String+WORLD
+++++++5:+astore_2++++++
+++++++6:+new+++++++++++#4++++++++++++++++++//+class+java/lang/StringBuilder
+++++++9:+dup+++++++++++
++++++10:+invokespecial+#5++++++++++++++++++//+Method+java/lang/StringBuilder."<init>":()V
++++++13:+aload_1+++++++
++++++14:+invokevirtual+#6++++++++++++++++++//+Method+java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
++++++17:+aload_2+++++++
++++++18:+invokevirtual+#6++++++++++++++++++//+Method+java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
++++++21:+invokevirtual+#7++++++++++++++++++//+Method+java/lang/StringBuilder.toString:()Ljava/lang/String;
++++++24:+astore_3++++++
++++++25:+ldc+++++++++++#8++++++++++++++++++//+String+JAVAWORLD
++++++27:+astore++++++++4
++++++29:+return++++++++
}|1610594|您可以看到，Java编译器已经在字符串池中为"JAVA"和"WORLD"创建了两个String实例。为了将这两者附加在一起，它创建了一个StringBuilder实例并附加了这些值。之后，它在该实例上调用toString()，这将创建一个内部包含"JAVAWORLD"的新String实例。|1610595|在第二种情况下，您最终只有一个String实例，因为Java编译器足够智能，能够看到您基本上拥有的是一个常量，因此它通过计算该表达式并在包含"JAVAWORLD"的字符串池中创建+one++String实例来执行一些编译时优化。然后将对该实例的引用分配给strTest。|BOLD|1610596|关于字符串"JAVA"、"WORLD"和"JAVAWORLD"，这些基本上都是被套住的字符串。因为字符串在Java中是不可变的，所以您只需要一个对唯一实例的引用，该实例可以在代码中的多个位置重用。这基本上是一种节省内存的方法。|1610597|所以总结一下：|1610598|1610599|案例1:三个String实例:两个在池中，一个是在追加后新建的(还创建了一个StringBuilder实例来追加两个字符串，导致总共4个对象)。|unordered-list-item|1610600|案例2:池中一个实例。|1610601|1610602|entityMap^0|E|6|0|0|0|0|0|M|6|T|7|15|6|1W|D|2U|A|3F|B|3S|6|0|F|6|1Y|B|2N|6|3J|7|2H|5|0|5|6|C|7|K|B|0|0|0|6|6|12|D|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|U]]|D|@]|E|$]]|$1|V|3|W|5|6|7|25|8|@$9|26|A|27|B|C]|$9|28|A|29|B|C]|$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2C|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|2E|8|@$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|13|3|14|5|12|7|2J|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]|$1|16|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]]|17|$]]

In the first example, you will end up with three <code>String</code> objects. You can actually see this in the bytecode.

Assume you have the following code:

<pre><code>public class StrTest {
 public static void main(String[] args) {
 String str1 = "JAVA";
 String str2 = "WORLD";

 String str3 = str1 + str2;

 String strTest = "JAVA" + "WORLD";
 }
}
</code></pre>

The resulting bytecode is:

<pre><code>public class StrTest {
 public StrTest();
 Code:
 0: aload_0 
 1: invokespecial #1 // Method java/lang/Object."&lt;init&gt;":()V
 4: return 

 public static void main(java.lang.String[]);
 Code:
 0: ldc #2 // String JAVA
 2: astore_1 
 3: ldc #3 // String WORLD
 5: astore_2 
 6: new #4 // class java/lang/StringBuilder
 9: dup 
 10: invokespecial #5 // Method java/lang/StringBuilder."&lt;init&gt;":()V
 13: aload_1 
 14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 17: aload_2 
 18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 21: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
 24: astore_3 
 25: ldc #8 // String JAVAWORLD
 27: astore 4
 29: return 
}
</code></pre>

You can see that the Java compiler has created two <code>String</code> instances for <code>"JAVA"</code> and <code>"WORLD"</code> in the string pool. To append these two together, it created a <code>StringBuilder</code> instance and appended the values. After that, it calls <code>toString()</code> on that instance, which creates a new <code>String</code> instance with <code>"JAVAWORLD"</code> inside it.

In the second case, you only end up with one <code>String</code> instance because the Java compiler is smart enough to see that what you basically have is a constant, and so it performs some compile-time optimization by evaluating that expression and creating one <code>String</code> instance in the string pool that contains <code>"JAVAWORLD"</code>. The reference to that instance is then assigned to <code>strTest</code>.

With regard to the strings <code>"JAVA"</code>, <code>"WORLD"</code>, and <code>"JAVAWORLD"</code>, these are basically interned strings. Since strings are immutable in Java, you only need one reference to a unique instance which can be reused in multiple locations in the code. This is basically a way to save memory.

So to sum up:

<ul>
<li>Case 1: Three <code>String</code> instances: two in the pool, one newly-constructed after appending (a <code>StringBuilder</code> instance was also created to append the two strings, leading to 4 objects total).</li>
<li>Case 2: One instance in the pool.</li>
</ul>

blocks|key|1610648|text|String+str1="JAVA";
String+str2="WORLD";

String+strTest="JAVA"%2B"WORLD";|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1610649|这三行中的每一行都将创建一个String对象。但是，如果代码被多次生成，那么它将始终是同一个对象。此外，每个String对象将包含一个char[]对象，因此从技术上讲，它是每行2个对象。|unstyled|offset|length|style|CODE|1610650|1610651|String+str3=str1%2Bstr2;|1610652|假设javac不能对此进行优化，它将编译为|1610653|String+str3+=+new+StringBuilder(str1).append(str2).toString();|1610654|因此，它不仅会创建一个字符串，还会创建一个在代码中无法访问的StringBuilder。因此，在最坏的情况下，会创建4个对象:+String、StringBuilder和to+char数组(因为它必须在append期间调整大小)|1610655|entityMap^0|0|1V|6|0|0|0|2|5|0|0|2T|6|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|W|8|@$G|X|H|Y|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|N|3|O|5|F|7|11|8|@$G|12|H|13|I|J]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|R|3|S|5|F|7|15|8|@$G|16|H|17|I|J]]|9|@]|A|$]]|$1|T|3|-4|5|F|7|18|8|@]|9|@]|A|$]]]|U|$]]

<pre><code>String str1="JAVA";
String str2="WORLD";

String strTest="JAVA"+"WORLD";
</code></pre>

Each of the three lines will result in the creation of one String object. But it will always be the same object if the code is resulted multiple times. Also, each String object will contain a <code>char[]</code> object, so technically, it's 2 objects per line.

<hr>

<pre><code>String str3=str1+str2;
</code></pre>

Assuming this cannot be optimized by the <code>javac</code>, it will compiled as

<pre><code>String str3 = new StringBuilder(str1).append(str2).toString();
</code></pre>

so, it will not only create a String, but also a StringBuilder which is not accessible in the code. Thus, in worst case 4 objects are created: String, StringBuilder and to char arrays (because it has to be resized during <code>append</code>)

<pre><code>class StringTest1
{
public static final void main(String... a)
{
 String str1="JAVA";
 String str2="WORLD";

 String str3=str1+str2;
}
}
</code></pre>

How many objects will be created in this process?
I think 3 objects will be created.

<pre><code>class StringTest2
{
public static final void main(String... a)
{

 String strTest="JAVA"+"WORLD";
}
}
</code></pre>

How many objects will be created in this process?How many objects are accessible?
somebody told me that "JAVA"+"WORLD" is an expression and it would not stored in string pool.

Confusion in String concept

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

class StringTest1{public static final void main(String... a){    String str1="JAVA";    String str2="WORLD";    String str3=str1+str2;}}在此过程中将创建多少个对象？我想会创建3个对象。...

问字符串概念中的混淆
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问字符串概念中的混淆EN