Java에서 참조로 문자열 전달?

나는 다음을 수행하는 데 익숙하다 C.

void main() {
    String zText = "";
    fillString(zText);
    printf(zText);
}

void fillString(String zText) {
    zText += "foo";
}

그리고 출력은 다음과 같습니다

foo

그러나 Java에서는 작동하지 않는 것 같습니다. String객체는 reference에 의해 전달되는 대신 복사 되기 때문에 가정합니다 . Strings는 객체이며 항상 참조로 전달된다고 생각했습니다.

무슨 일이야?

세 가지 옵션이 있습니다.

1. StringBuilder를 사용하십시오.

   StringBuilder zText = new StringBuilder ();
   void fillString(StringBuilder zText) { zText.append ("foo"); }

2. 컨테이너 클래스를 만들고 컨테이너 인스턴스를 메소드에 전달하십시오.

   public class Container { public String data; }
   void fillString(Container c) { c.data += "foo"; }

3. 배열을 만듭니다.

   new String[] zText = new String[1];
   zText[0] = "";
   
   void fillString(String[] zText) { zText[0] += "foo"; }

성능 관점에서 StringBuilder가 일반적으로 가장 좋은 옵션입니다.

Java에서는 아무것도 참조로 전달되지 않습니다 . 모든 것이 value에 의해 전달됩니다 . 객체 참조는 값으로 전달됩니다. 또한 문자열은 변경할 수 없습니다 . 따라서 전달 된 문자열에 추가하면 새 문자열이 생깁니다. 반환 값을 사용하거나 대신 StringBuffer를 전달할 수 있습니다.

일어나고있는 것은 참조가 값으로 전달된다는 것입니다. 즉, 참조 의 사본 이 전달됩니다. java의 어떤 것도 참조로 전달되지 않으며 문자열은 변경할 수 없으므로 해당 지정은 참조 사본이 가리키는 새 문자열 객체를 만듭니다 . 원래 참조는 여전히 빈 문자열을 가리 킵니다.

이것은 어떤 객체에서도 동일합니다. 즉, 메소드에서 새로운 값으로 설정합니다. 아래 예제는 진행 상황을보다 명확하게하지만 문자열 연결은 실제로 동일합니다.

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

java.lang.String은 변경할 수 없습니다.

URL을 붙여 넣는 것이 싫지만 https://docs.oracle.com/javase/10/docs/api/java/lang/String.html 은 자바 사이트에 있는지 읽고 이해하는 데 필수적입니다.

객체는 참조로 전달되고 프리미티브는 값으로 전달됩니다.

문자열은 프리미티브가 아니며 객체이며 특수한 경우입니다.

이것은 메모리 절약을위한 것입니다. 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의 모든 인수는 값으로 전달됩니다. a 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와 유사한 솔루션 일 것입니다. 효과적인 Java 항목 "Favor immutability"를 참조하십시오 .

그러나 언급했듯이, StringBuilder종종 루프 내부에서 할 일이 많으면을 사용하여 성능을 향상시킬 수 있습니다 StringBuilder.

그러나 Strings가능 StringBuilders하다면 변경 불가능한 것이 아니라 변경 불가능한 것을 전달 하십시오. 코드를보다 쉽게 ​​읽고 유지 관리 할 수 ​​있습니다. final메소드 매개 변수를 새 값으로 재 할당 할 때 경고하도록 매개 변수 작성 및 IDE 구성을 고려하십시오 .

문자열은 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");
}

또 다른 옵션은 다음과 같이 문자열을 범위 변수로 사용하지 않는 클래스를 만드는 것입니다.

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";
}

대답은 간단합니다. 자바에서 문자열은 변경할 수 없습니다. 따라서 'final'수정 자 (또는 C / C ++에서 'const')를 사용하는 것과 같습니다. 따라서 일단 할당되면 자신이 한 것처럼 변경할 수 없습니다.

당신은 변경할 수 있습니다 값에 문자열 점을, 그러나 당신은이 문자열이 현재 지적되는 실제 값을 변경할 수 없습니다.

즉. String s1 = "hey". 당신은 만들 수 있고 s1 = "woah", 그것은 괜찮습니다.하지만 실제로 문자열의 기본 값 (이 경우 "hey")을 plusEquals 등 (예 :)을 사용하여 할당 된 다른 것으로 변경할 수는 없습니다 s1 += " whatup != "hey whatup".

이를 위해서는 StringBuilder 또는 StringBuffer 클래스 또는 기타 변경 가능한 컨테이너를 사용한 다음 .toString ()을 호출하여 객체를 다시 문자열로 변환하십시오.

참고 : 문자열은 종종 해시 키로 사용되므로 불변 인 이유의 일부입니다.

문자열은 Java의 특수 클래스입니다. "Shell Safe"는 "String 인스턴스가 생성되면 String 인스턴스의 내용은 절대 변경되지 않습니다"를 의미합니다.

여기에 무슨 일이 일어나고 있는지

 zText += "foo";

먼저, Java 컴파일러는 zText String 인스턴스의 값을 가져온 다음 "foo"를 추가하는 zText 값을 갖는 새로운 String 인스턴스를 작성합니다. zText가 가리키는 인스턴스가 변경되지 않은 이유를 알 수 있습니다. 완전히 새로운 인스턴스입니다. 실제로 String "foo"조차도 새로운 String 인스턴스입니다. 따라서이 명령문에 대해 Java는 두 개의 String 인스턴스를 작성합니다. 하나는 "foo"이고 다른 하나는 zText append "foo"의 값입니다. 규칙은 간단합니다. String 인스턴스의 값은 절대 변경되지 않습니다.

fillString 메소드의 경우 StringBuffer를 매개 변수로 사용하거나 다음과 같이 변경할 수 있습니다.

String fillString(String zText) {
    return zText += "foo";
}

Java에서는 문자열을 변경할 수 없습니다 .

이것은 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에서는 문자열을 변경할 수 없습니다. 기존 문자열 리터럴 / 객체는 수정 / 변경할 수 없습니다.

문자열 s = "Hello"; s = s + "hi";

여기서 이전 참조는 "HelloHi"값을 가리키는 새 참조로 대체됩니다.

그러나 가변성을 가져 오기 위해 StringBuilder와 StringBuffer가 있습니다.

StringBuilder s = 새로운 StringBuilder (); s.append ( "Hi");

이것은 새로운 값 "Hi"를 동일한 참조에 추가합니다. //

Aaron Digulla는 지금까지 가장 좋은 답변을 받았습니다. 그의 두 번째 옵션의 변형은 commons lang 라이브러리 버전 3 이상의 래퍼 또는 컨테이너 클래스 MutableObject를 사용하는 것입니다.

void fillString(MutableObject<String> c) { c.setValue(c.getValue() + "foo"); }

컨테이너 클래스의 선언을 저장합니다. 단점은 commons lang lib에 대한 종속성입니다. 그러나 lib에는 많은 유용한 기능이 있으며 내가 작업 한 거의 모든 큰 프로젝트가 그것을 사용했습니다.

Java에서 참조로 오브젝트 (String 포함)를 전달하기 위해 주변 어댑터의 구성원으로 전달할 수 있습니다. 제네릭 솔루션은 다음과 같습니다.

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());
    }
}

더 호기심이 많은 사람을 위해

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");
    }
}

이제 위의 코드를 실행하면 hashcodesString 변수 s로 주소가 어떻게 변경 되는지 확인할 수 있습니다 . changetos가 변경되면 함수의 변수 s에 새 객체가 할당됩니다.