blocks|key|1828395|text|java.lang.String是不可变的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1828396|我讨厌粘贴URL，但是如果你在java环境中，https://docs.oracle.com/javase/10/docs/api/java/lang/String.html对于你阅读和理解是必不可少的。|offset|length|1828397|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/10/docs/api/java/lang/String.html^0|0|N|1S|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

java.lang.String is immutable.

I hate pasting URLs but <a href="https://docs.oracle.com/javase/10/docs/api/java/lang/String.html" rel="nofollow noreferrer" title="String Documentation">https://docs.oracle.com/javase/10/docs/api/java/lang/String.html</a> is essential for you to read and understand if you're in java-land.

blocks|key|2042397|text|字符串在Java中是immutable。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2042398|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Immutable_object^0|A|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Strings are <a href="http://en.wikipedia.org/wiki/Immutable_object" rel="nofollow noreferrer">immutable</a> in Java.

blocks|key|2042507|text|发生的情况是通过值传递引用，即传递引用的副本。java中的任何东西都不是通过引用传递的，因为字符串是不可变的，所以赋值创建了一个新的字符串对象，引用的副本现在指向该对象。原始引用仍然指向空字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2042508|这对于任何对象都是一样的，即在方法中将其设置为新值。下面的例子让事情变得更加明显，但是连接一个字符串实际上是一回事。|2042509|void+foo(+object+o+)
{
++++o+=+new+Object(+);++//+original+reference+still+points+to+old+value+on+the+heap
}|code-block|syntax|javascript|2042510|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

What is happening is that the reference is passed by value, i.e., a copy of the reference is passed. Nothing in java is passed by reference, and since a string is immutable, that assignment creates a new string object that the copy of the reference now points to. The original reference still points to the empty string.

This would be the same for any object, i.e., setting it to a new value in a method. The example below just makes what is going on more obvious, but concatenating a string is really the same thing.

<pre><code>void foo( object o )
{
 o = new Object( ); // original reference still points to old value on the heap
}
</code></pre>

blocks|key|1828878|text|Java中的所有参数都是通过值传递的。当您将String传递给函数时，传递的值是对String对象的引用，但是您不能修改该引用，并且底层的String对象是不可变的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1828879|作业|1828880|zText+%2B=+foo;|code-block|syntax|javascript|1828881|等同于：|1828882|zText+=+new+String(zText+%2B+"foo");|1828883|也就是说，它(在本地)将参数zText重新分配为一个新的引用，该引用指向一个新的内存位置，其中是一个新的String，其中包含zText的原始内容，并附加了"foo"。|1828884|原始对象不会被修改，并且main()方法的局部变量zText仍然指向原始(空)字符串。|1828885|class+StringFiller+{
++static+void+fillString(String+zText)+{
++++zText+%2B=+"foo";
++++System.out.println("Local+value:+"+%2B+zText);
++}

++public+static+void+main(String[]+args)+{
++++String+zText+=+"";
++++System.out.println("Original+value:+"+%2B+zText);
++++fillString(zText);
++++System.out.println("Final+value:+"+%2B+zText);
++}
}|1828886|打印：|1828887|Original+value:
Local+value:+foo
Final+value:|1828888|如果你想修改这个字符串，你可以使用StringBuilder或者其他一些容器(一个数组或者一个AtomicReference或者一个自定义容器类)来提供一个额外级别的指针间接性。或者，只需返回新值并对其赋值：|1828889|class+StringFiller2+{
++static+String+fillString(String+zText)+{
++++zText+%2B=+"foo";
++++System.out.println("Local+value:+"+%2B+zText);
++++return+zText;
++}

++public+static+void+main(String[]+args)+{
++++String+zText+=+"";
++++System.out.println("Original+value:+"+%2B+zText);
++++zText+=+fillString(zText);
++++System.out.println("Final+value:+"+%2B+zText);
++}
}|1828890|1828891|Original+value:
Local+value:+foo
Final+value:+foo|1828892|在一般情况下，这可能是最类似于Java的解决方案--请参阅有效的Java项目“偏好不变性”。|1828893|正如前面提到的，StringBuilder通常会给您带来更好的性能--如果您有很多附加操作要做，尤其是在循环中，那么可以使用StringBuilder。|1828894|但是，如果可以的话，尝试传递不变的Strings而不是可变的StringBuilders+--您的代码将更容易阅读和维护。考虑将参数设置为final，并将集成开发环境配置为在将方法参数重新赋值为新值时发出警告。|1828895|entityMap^0|M|6|0|0|0|0|0|E|5|1G|6|1R|5|26|5|0|C|6|P|5|0|0|0|0|H|D|1B|F|0|0|0|0|0|8|D|1Q|D|0|H|7|U|E|1X|5|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1I|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1K|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|U|3|V|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|21|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|22|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|23|8|@$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@]|E|$]]|$1|12|3|13|5|J|7|28|8|@]|D|@]|E|$K|L]]|$1|14|3|X|5|6|7|29|8|@]|D|@]|E|$]]|$1|15|3|16|5|J|7|2A|8|@]|D|@]|E|$K|L]]|$1|17|3|18|5|6|7|2B|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|2H|8|@$9|2I|A|2J|B|C]|$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2O|8|@]|D|@]|E|$]]]|1E|$]]

All arguments in Java are passed by value. When you pass a <code>String</code> to a function, the value that's passed is a reference to a String object, but you can't modify that reference, and the underlying String object is immutable.

The assignment

<pre><code>zText += foo;
</code></pre>

is equivalent to:

<pre><code>zText = new String(zText + "foo");
</code></pre>

That is, it (locally) reassigns the parameter <code>zText</code> as a new reference, which points to a new memory location, in which is a new <code>String</code> that contains the original contents of <code>zText</code> with <code>"foo"</code> appended.

The original object is not modified, and the <code>main()</code> method's local variable <code>zText</code> still points to the original (empty) string.

<pre><code>class StringFiller {
 static void fillString(String zText) {
 zText += "foo";
 System.out.println("Local value: " + zText);
 }

 public static void main(String[] args) {
 String zText = "";
 System.out.println("Original value: " + zText);
 fillString(zText);
 System.out.println("Final value: " + zText);
 }
}
</code></pre>

prints:

<pre><code>Original value:
Local value: foo
Final value:
</code></pre>

If you want to modify the string, you can as noted use <code>StringBuilder</code> or else some container (an array or an <code>AtomicReference</code> or a custom container class) that gives you an additional level of pointer indirection. Alternatively, just return the new value and assign it:

<pre><code>class StringFiller2 {
 static String fillString(String zText) {
 zText += "foo";
 System.out.println("Local value: " + zText);
 return zText;
 }

 public static void main(String[] args) {
 String zText = "";
 System.out.println("Original value: " + zText);
 zText = fillString(zText);
 System.out.println("Final value: " + zText);
 }
}
</code></pre>

prints:

<pre><code>Original value:
Local value: foo
Final value: foo
</code></pre>

This is probably the most Java-like solution in the general case -- see the Effective Java item "Favor immutability."

As noted, though, <code>StringBuilder</code> will often give you better performance -- if you have a lot of appending to do, particularly inside a loop, use <code>StringBuilder</code>.

But try to pass around immutable <code>Strings</code> rather than mutable <code>StringBuilders</code> if you can -- your code will be easier to read and more maintainable. Consider making your parameters <code>final</code>, and configuring your IDE to warn you when you reassign a method parameter to a new value.

blocks|key|1829069|text|String是Java中的一个特殊类。它是线程安全的，这意味着“一旦创建了String实例，String实例的内容就永远不会改变”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829070|下面是我们要做的事情|1829071|+zText+%2B=+"foo";|code-block|syntax|javascript|1829072|首先，Java编译器将获取zText+String实例的值，然后创建一个新的String实例，该实例的值为zText，并附加"foo“。这样您就知道了为什么zText指向的实例不会改变。这是一个全新的实例。事实上，字符串"foo“也是一个新的字符串实例。因此，对于这条语句，Java将创建两个String实例，一个是"foo"，另一个是zText追加"foo“的值。规则很简单:+String实例的值永远不会改变。|1829073|对于fillString方法，您可以使用StringBuffer作为参数，也可以像这样更改它：|1829074|String+fillString(String+zText)+{
++++return+zText+%2B=+"foo";
}|1829075|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

String is a special class in Java. It is Thread Safe which means "Once a String instance is created, the content of the String instance will never changed ".

Here is what is going on for

<pre><code> zText += "foo";
</code></pre>

First, Java compiler will get the value of zText String instance, then create a new String instance whose value is zText appending "foo". So you know why the instance that zText point to does not changed. It is totally a new instance. In fact, even String "foo" is a new String instance. So, for this statement, Java will create two String instance, one is "foo", another is the value of zText append "foo". 
The rule is simple: The value of String instance will never be changed.

For method fillString, you can use a StringBuffer as parameter, or you can change it like this:

<pre><code>String fillString(String zText) {
 return zText += "foo";
}
</code></pre>

blocks|key|2043273|text|对象是通过引用传递的，基元是通过值传递的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2043274|字符串不是一个原语，它是一个对象，它是对象的一个特例。|2043275|这是为了节省内存。在JVM中，有一个字符串池。对于创建的每个字符串，JVM将尝试查看字符串池中是否存在相同的字符串，如果已经存在，则指向该字符串。|2043276|public+class+TestString
{
++++private+static+String+a+=+"hello+world";
++++private+static+String+b+=+"hello+world";
++++private+static+String+c+=+"hello+"+%2B+"world";
++++private+static+String+d+=+new+String("hello+world");

++++private+static+Object+o1+=+new+Object();
++++private+static+Object+o2+=+new+Object();

++++public+static+void+main(String[]+args)
++++{
++++++++System.out.println("a==b:"%2B(a+==+b));
++++++++System.out.println("a==c:"%2B(a+==+c));
++++++++System.out.println("a==d:"%2B(a+==+d));
++++++++System.out.println("a.equals(d):"%2B(a.equals(d)));
++++++++System.out.println("o1==o2:"%2B(o1+==+o2));

++++++++passString(a);
++++++++passString(d);
++++}

++++public+static+void+passString(String+s)
++++{
++++++++System.out.println("passString:"%2B(a+==+s));
++++}
}|code-block|syntax|javascript|2043277|/*输出*/|2043278|a==b:true
a==c:true
a==d:false
a.equals(d):true
o1==o2:false
passString:true
passString:false|2043279|==正在检查内存地址(引用)，而.equals正在检查内容(值)|2043280|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

objects are passed by reference, primitives are passed by value.

String is not a primitive, it is an object, and it is a special case of object. 

This is for memory-saving purpose. In JVM, there is a string pool. For every string created, JVM will try to see if the same string exist in the string pool, and point to it if there were already one.

<pre><code>public class TestString
{
 private static String a = "hello world";
 private static String b = "hello world";
 private static String c = "hello " + "world";
 private static String d = new String("hello world");

 private static Object o1 = new Object();
 private static Object o2 = new Object();

 public static void main(String[] args)
 {
 System.out.println("a==b:"+(a == b));
 System.out.println("a==c:"+(a == c));
 System.out.println("a==d:"+(a == d));
 System.out.println("a.equals(d):"+(a.equals(d)));
 System.out.println("o1==o2:"+(o1 == o2));

 passString(a);
 passString(d);
 }

 public static void passString(String s)
 {
 System.out.println("passString:"+(a == s));
 }
}
</code></pre>

/* OUTPUT */

<pre><code>a==b:true
a==c:true
a==d:false
a.equals(d):true
o1==o2:false
passString:true
passString:false
</code></pre>

the == is checking for memory address (reference), and the .equals is checking for contents (value)

blocks|key|2043360|text|这项工作使用StringBuffer|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2043361|public+class+test+{
+public+static+void+main(String[]+args)+{
+StringBuffer+zText+=+new+StringBuffer("");
++++fillString(zText);
++++System.out.println(zText.toString());
+}
++static+void+fillString(StringBuffer+zText)+{
++++zText+.append("foo");
}
}|code-block|syntax|javascript|2043362|更好地使用StringBuilder|2043363|public+class+test+{
+public+static+void+main(String[]+args)+{
+StringBuilder+zText+=+new+StringBuilder("");
++++fillString(zText);
++++System.out.println(zText.toString());
+}
++static+void+fillString(StringBuilder+zText)+{
++++zText+.append("foo");
}
}|2043364|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This works use StringBuffer

<pre><code>public class test {
 public static void main(String[] args) {
 StringBuffer zText = new StringBuffer("");
 fillString(zText);
 System.out.println(zText.toString());
 }
 static void fillString(StringBuffer zText) {
 zText .append("foo");
}
}
</code></pre>

Even better use StringBuilder

<pre><code>public class test {
 public static void main(String[] args) {
 StringBuilder zText = new StringBuilder("");
 fillString(zText);
 System.out.println(zText.toString());
 }
 static void fillString(StringBuilder zText) {
 zText .append("foo");
}
}
</code></pre>

blocks|key|2043418|text|字符串在Java中是一个不可变的对象。您可以使用StringBuilder类来完成您试图完成的工作，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2043419|public+static+void+main(String[]+args)
{
++++StringBuilder+sb+=+new+StringBuilder("hello,+world!");
++++System.out.println(sb);
++++foo(sb);
++++System.out.println(sb);

}

public+static+void+foo(StringBuilder+str)
{
++++str.delete(0,+str.length());
++++str.append("String+has+been+modified");
}|code-block|syntax|javascript|2043420|另一种选择是创建一个以字符串作为作用域变量的类(非常不鼓励)，如下所示：|2043421|class+MyString
{
++++public+String+value;
}

public+static+void+main(String[]+args)
{
++++MyString+ms+=+new+MyString();
++++ms.value+=+"Hello,+World!";

}

public+static+void+foo(MyString+str)
{
++++str.value+=+"String+has+been+modified";
}|2043422|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

String is an immutable object in Java. You can use the StringBuilder class to do the job you're trying to accomplish, as follows:

<pre><code>public static void main(String[] args)
{
 StringBuilder sb = new StringBuilder("hello, world!");
 System.out.println(sb);
 foo(sb);
 System.out.println(sb);

}

public static void foo(StringBuilder str)
{
 str.delete(0, str.length());
 str.append("String has been modified");
}
</code></pre>

Another option is to create a class with a String as a scope variable (highly discouraged) as follows:

<pre><code>class MyString
{
 public String value;
}

public static void main(String[] args)
{
 MyString ms = new MyString();
 ms.value = "Hello, World!";

}

public static void foo(MyString str)
{
 str.value = "String has been modified";
}
</code></pre>

blocks|key|1829621|text|答案很简单。在java中，字符串是不可变的。因此，它类似于使用'final‘修饰符(或C/C%2B%2B中的'const’)。所以，一旦被分配，你就不能像以前那样改变它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829622|您可以更改字符串所指向的值，但不能更改此字符串当前所指向的实际值。|1829623|即。String+s1+=+"hey"。你可以做s1+=+"woah"，这完全没问题，但是一旦字符串使用plusEquals赋值，你就不能将它的底层值(在本例中是：“嘿”)改成其他值，等等。s1+%2B=+"+whatup+!=+"hey+whatup")。|offset|length|style|CODE|1829624|为此，使用StringBuilder或StringBuffer类或其他可变容器，然后只需调用.toString()将对象转换回字符串。|1829625|注意:字符串通常用作散列键，因此这是它们不可变的部分原因。|1829626|entityMap^0|0|0|2|H|O|B|2N|U|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@$F|S|G|T|H|I]|$F|U|G|V|H|I]|$F|W|G|X|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|O|$]]

The answer is simple. In java strings are immutable. Hence its like using 'final' modifier (or 'const' in C/C++). So, once assigned, you cannot change it like the way you did.

You can change which value to which a string points, but you can NOT change the actual value to which this string is currently pointing.

Ie. <code>String s1 = "hey"</code>. You can make <code>s1 = "woah"</code>, and that's totally ok, but you can't actually change the underlying value of the string (in this case: "hey") to be something else once its assigned using plusEquals, etc. (ie. <code>s1 += " whatup != "hey whatup"</code>).

To do that, use the StringBuilder or StringBuffer classes or other mutable containers, then just call .toString() to convert the object back to a string. 

note: Strings are often used as hash keys hence that's part of the reason why they are immutable.

blocks|key|1829710|text|到目前为止，Aaron+Digulla有最好的答案。他的第二个选择的变体是使用commons+lang库版本3%2B的包装器或容器类MutableObject：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829711|void+fillString(MutableObject<String>+c)+{+c.setValue(c.getValue()+%2B+"foo");+}|code-block|syntax|javascript|1829712|保存容器类的声明。缺点是对commons+lang库的依赖。但是lib有很多有用的功能，几乎所有我做过的更大的项目都使用它。|1829713|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Aaron Digulla has the best answer so far. A variation of his second option is to use the wrapper or container class MutableObject of the commons lang library version 3+:

<pre><code>void fillString(MutableObject&lt;String&gt; c) { c.setValue(c.getValue() + "foo"); }
</code></pre>

you save the declaration of the container class. The drawback is a dependency to the commons lang lib. But the lib has quite a lot of useful function and almost any larger project i have worked on used it.

blocks|key|1829821|text|字符串在java中是不可变的。您不能修改/更改现有的字符串文字/对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829822|String+s=“你好”；s=s%2B"hi"；|1829823|这里，前一个引用s被指向值"HelloHi“的新引用s替换。|1829824|然而，为了带来可变性，我们有StringBuilder和StringBuffer。|1829825|StringBuilder+s=new+StringBuilder()；s.append("Hi")；|1829826|这会将新值"Hi“附加到相同的引用。//|1829827|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

String is immutable in java. you cannot modify/change, an existing string literal/object. 

String s="Hello";
s=s+"hi";

Here the previous reference s is replaced by the new refernce s pointing to value "HelloHi".

However, for bringing mutability we have StringBuilder and StringBuffer. 

StringBuilder s=new StringBuilder();
s.append("Hi");

this appends the new value "Hi" to the same refernce s.
//

blocks|key|2043852|text|为了在java中通过引用传递对象(包括字符串)，您可以将其作为周围适配器的成员进行传递。下面是一个带有泛型的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2043853|import+java.io.Serializable;

public+class+ByRef<T+extends+Object>+implements+Serializable
{
++++private+static+final+long+serialVersionUID+=+6310102145974374589L;

++++T+v;

++++public+ByRef(T+v)
++++{
++++++++this.v+=+v;
++++}

++++public+ByRef()
++++{
++++++++v+=+null;
++++}

++++public+void+set(T+nv)
++++{
++++++++v+=+nv;
++++}

++++public+T+get()
++++{
++++++++return+v;
++++}

//+------------------------------------------------------------------

++++static+void+fillString(ByRef<String>+zText)
++++{
++++++++zText.set(zText.get()+%2B+"foo");
++++}

++++public+static+void+main(String+args[])
++++{
++++++++final+ByRef<String>+zText+=+new+ByRef<String>(new+String(""));
++++++++fillString(zText);
++++++++System.out.println(zText.get());
++++}
}|code-block|syntax|javascript|2043854|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For passing an object (including String) by reference in java, you might pass it as member of a surrounding adapter. A solution with a generic is here:

<pre><code>import java.io.Serializable;

public class ByRef&lt;T extends Object&gt; implements Serializable
{
 private static final long serialVersionUID = 6310102145974374589L;

 T v;

 public ByRef(T v)
 {
 this.v = v;
 }

 public ByRef()
 {
 v = null;
 }

 public void set(T nv)
 {
 v = nv;
 }

 public T get()
 {
 return v;
 }

// ------------------------------------------------------------------

 static void fillString(ByRef&lt;String&gt; zText)
 {
 zText.set(zText.get() + "foo");
 }

 public static void main(String args[])
 {
 final ByRef&lt;String&gt; zText = new ByRef&lt;String&gt;(new String(""));
 fillString(zText);
 System.out.println(zText.get());
 }
}
</code></pre>

I am used to doing the following in <code>C</code>:

<pre><code>void main() {
 String zText = "";
 fillString(zText);
 printf(zText);
}

void fillString(String zText) {
 zText += "foo";
}
</code></pre>

And the output is:

<pre><code>foo
</code></pre>

However, in Java, this does not seem to work. I assume because the <code>String</code> object is copied instead of passed by referenced. I thought Strings were objects, which are always passed by reference. 

What is going on here?

Passing a String by Reference in Java?

集成开发环境

编译器

容器

Java

我习惯于在C中执行以下操作void main() {    String zText = "";    fillString(zText);    printf(zText);}void fillString(String zText) {    zText += "foo";}输出结果为：foo然而，在Java中，这...

问在Java中通过引用传递字符串？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中通过引用传递字符串？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中通过引用传递字符串？
EN