我习惯在C做以下事情：
void main() {
String zText = "";
fillString(zText);
printf(zText);
}
void fillString(String zText) {
zText += "foo";
}
输出是：
foo
但是，在 Java 中，这似乎不起作用。我假设是因为String 对象是复制，而不是通过引用传递。我认为字符串是对象，总是通过引用传递。
这是怎么回事？
【问题讨论】：
标签： java string pass-by-reference
对于好奇的人
class Testt {
static void Display(String s , String varname){
System.out.println(varname + " variable data = "+ s + " :: address hashmap = " + s.hashCode());
}
static void changeto(String s , String t){
System.out.println("entered function");
Display(s , "s");
s = t ;
Display(s,"s");
System.out.println("exiting function");
}
public static void main(String args[]){
String s = "hi" ;
Display(s,"s");
changeto(s,"bye");
Display(s,"s");
}
}
现在通过运行上面的代码，您可以看到地址
hashcodes如何随字符串变量 s 变化。 当 s 改变时，一个新对象被分配给函数changeto中的变量 s
【讨论】：
String 是 Java 中的一个特殊类。它是线程安全的，这意味着“一旦创建了 String 实例，String 实例的内容就永远不会改变”。
这是怎么回事
zText += "foo";
首先，Java 编译器将获取 zText String 实例的值，然后创建一个新的 String 实例，其值为 zText 附加“foo”。所以你知道为什么 zText 指向的实例没有改变。这完全是一个新的例子。事实上，甚至 String "foo" 也是一个新的 String 实例。所以，对于这条语句，Java会创建两个String实例，一个是“foo”，另一个是zText的值追加“foo”。 规则很简单：String 实例的值永远不会改变。
对于方法fillString，你可以使用StringBuffer作为参数，也可以这样改变：
String fillString(String zText) {
return zText += "foo";
}
【讨论】：
您有三个选择：
使用 StringBuilder：
StringBuilder zText = new StringBuilder ();
void fillString(StringBuilder zText) { zText.append ("foo"); }
创建一个容器类并将容器的一个实例传递给您的方法：
public class Container { public String data; }
void fillString(Container c) { c.data += "foo"; }
创建一个数组：
new String[] zText = new String[1];
zText[0] = "";
void fillString(String[] zText) { zText[0] += "foo"; }
从性能的角度来看，StringBuilder 通常是最好的选择。
【讨论】：
StringBuilder 比 s += "..." 更快，因为它不会每次都分配新的 String 对象。事实上，当你编写像s = "Hello " + name 这样的Java 代码时，编译器会生成一个字节码，它会创建一个StringBuilder 并调用append() 两次。
Java 中的所有参数都是按值传递的。当您将 String 传递给函数时，传递的值是对 String 对象的引用，但您不能修改该引用，并且底层 String 对象是不可变的。
任务
zText += foo;
相当于：
zText = new String(zText + "foo");
也就是说，它（本地）将参数zText重新分配为新的引用，它指向一个新的内存位置，其中是一个新的String，其中包含zText和"foo"的原始内容附加。
原始对象没有被修改，main()方法的局部变量zText仍然指向原始（空）字符串。
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);
}
}
打印：
Original value:
Local value: foo
Final value:
如果您想修改字符串，您可以使用StringBuilder 或其他容器（数组或AtomicReference 或自定义容器类），为您提供额外的指针间接级别。或者，只需返回新值并分配它：
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);
}
}
打印：
Original value:
Local value: foo
Final value: foo
这可能是一般情况下最类似于 Java 的解决方案 - 请参阅 Effective Java 项“支持不变性”。
不过，如前所述，StringBuilder 通常会为您提供更好的性能 - 如果您有很多附加操作要做，尤其是在循环内，请使用 StringBuilder。
但是如果可以的话，尝试传递不可变的Strings 而不是可变的StringBuilders——你的代码会更容易阅读和维护。考虑将您的参数设置为final，并配置您的 IDE，以便在您将方法参数重新分配给新值时发出警告。
【讨论】：
为了在 java 中通过引用传递对象（包括字符串），您可以将其作为周围适配器的成员传递。一个泛型的解决方案在这里：
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() + "foo");
}
public static void main(String args[])
{
final ByRef<String> zText = new ByRef<String>(new String(""));
fillString(zText);
System.out.println(zText.get());
}
}
【讨论】：
java.lang.String 是不可变的。
我讨厌粘贴 URL，但 https://docs.oracle.com/javase/10/docs/api/java/lang/String.html 对于您在 Java 领域阅读和理解是必不可少的。
【讨论】：
字符串在java中是不可变的。您不能修改/更改现有的字符串文字/对象。
字符串 s="你好"; s=s+"你好";
这里之前的引用 s 被新的引用 s 替换，指向值 "HelloHi"。
然而，为了带来可变性，我们有 StringBuilder 和 StringBuffer。
StringBuilder s=new StringBuilder(); s.append("你好");
这会将新值“Hi”附加到相同的引用。 //
【讨论】：
对象通过引用传递，基元通过值传递。
String 不是原始的，它是一个对象，它是对象的一个特例。
这是为了节省内存。在JVM中，有一个字符串池。对于创建的每个字符串，JVM 都会尝试查看字符串池中是否存在相同的字符串，如果已经存在则指向它。
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));
}
}
/* 输出 */
a==b:true
a==c:true
a==d:false
a.equals(d):true
o1==o2:false
passString:true
passString:false
== 正在检查内存地址（引用），.equals 正在检查内容（值）
【讨论】：
答案很简单。在java中字符串是不可变的。因此，它就像使用“final”修饰符（或 C/C++ 中的“const”）。因此，一旦分配，您就无法像以前那样更改它。
您可以更改字符串指向的 which 值，但不能更改该字符串当前指向的实际值。
即。 String s1 = "hey"。您可以设置s1 = "woah"，这完全没问题，但是一旦使用 plusEquals 等（即@ 987654323@)。
为此，请使用 StringBuilder 或 StringBuffer 类或其他可变容器，然后只需调用 .toString() 将对象转换回字符串。
注意：字符串通常用作哈希键，因此这是它们不可变的部分原因。
【讨论】：
= 永远不会影响它曾经指向的对象，无论类如何。
在 Java 中 没有任何东西是通过引用传递的。一切都按价值传递。对象引用按值传递。此外，字符串是不可变的。因此，当您附加到传递的字符串时，您只会得到一个新的字符串。你可以使用返回值，或者传递一个 StringBuffer。
【讨论】：
到目前为止，Aaron Digulla 给出了最好的答案。他的第二个选项的一个变体是使用 commons lang 库版本 3+ 的包装器或容器类 MutableObject：
void fillString(MutableObject<String> c) { c.setValue(c.getValue() + "foo"); }
你保存容器类的声明。缺点是依赖于 commons lang lib。但是这个 lib 有很多有用的功能，我从事的几乎所有大型项目都使用它。
【讨论】：
String 是 Java 中的不可变对象。您可以使用 StringBuilder 类来完成您想要完成的工作，如下所示：
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");
}
另一种选择是使用 String 作为范围变量创建一个类（强烈建议不要这样做），如下所示：
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";
}
【讨论】：
这个作品使用 StringBuffer
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");
}
}
更好地使用 StringBuilder
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");
}
}
【讨论】：
发生的情况是引用是按值传递的，即传递了引用的副本。 java 中没有任何内容是通过引用传递的，并且由于字符串是不可变的，因此该赋值会创建一个新的字符串对象，引用的副本现在指向该对象。原来的引用仍然指向空字符串。
这对于任何对象都是一样的，即在方法中将其设置为新值。下面的例子只是让事情变得更明显，但连接一个字符串实际上是一回事。
void foo( object o )
{
o = new Object( ); // original reference still points to old value on the heap
}
【讨论】：
Java 中的字符串是immutable。
【讨论】：