Przekazywanie ciągu przez odniesienie w Javie?

Jestem przyzwyczajony do wykonywania następujących czynności w C:

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

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

A wynik to:

foo

Jednak w Javie to nie działa. Zakładam, ponieważ Stringobiekt jest kopiowany, a nie przekazywany przez przywołanie . Myślałem, że ciągi znaków to obiekty, które zawsze są przekazywane przez odniesienie.

Co tu się dzieje?

Masz trzy możliwości:

1. Użyj StringBuilder:

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

2. Utwórz klasę kontenera i przekaż instancję kontenera do swojej metody:

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

3. Utwórz tablicę:

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

Z punktu widzenia wydajności, StringBuilder jest zwykle najlepszą opcją.

W Javie nic nie jest przekazywane przez odniesienie . Wszystko jest przekazywane przez wartość . Odwołania do obiektów są przekazywane według wartości. Dodatkowo ciągi znaków są niezmienne . Więc kiedy dołączasz do przekazanego String, po prostu otrzymasz nowy String. Możesz użyć wartości zwracanej lub zamiast tego przekazać StringBuffer.

Dzieje się tak, że odwołanie jest przekazywane przez wartość, tj. Przekazywana jest kopia odniesienia. Nic w java nie jest przekazywane przez odwołanie, a ponieważ ciąg jest niezmienny, to przypisanie tworzy nowy obiekt ciągu, na który wskazuje teraz kopia odwołania . Oryginalne odniesienie nadal wskazuje na pusty ciąg.

Byłoby to takie samo dla każdego obiektu, tj. Nadanie mu nowej wartości w metodzie. Poniższy przykład po prostu sprawia, że ​​to, co się dzieje, jest bardziej oczywiste, ale konkatenacja łańcucha to tak naprawdę to samo.

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

java.lang.String jest niezmienna.

Nienawidzę wklejania adresów URL, ale https://docs.oracle.com/javase/10/docs/api/java/lang/String.html jest niezbędny do przeczytania i zrozumienia, jeśli jesteś w java-land.

obiekty są przekazywane przez odwołanie, prymitywy są przekazywane przez wartość.

Ciąg nie jest prymitywem, jest obiektem i jest specjalnym przypadkiem obiektu.

Ma to na celu oszczędzanie pamięci. W JVM istnieje pula ciągów. Dla każdego utworzonego łańcucha JVM spróbuje sprawdzić, czy ten sam łańcuch istnieje w puli ciągów i wskaże go, jeśli już istniał.

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

/* WYNIK */

a==b:true
a==c:true
a==d:false
a.equals(d):true
o1==o2:false
passString:true
passString:false

== sprawdza adres pamięci (odniesienie), a .equals sprawdza zawartość (wartość)

Wszystkie argumenty w Javie są przekazywane według wartości. Gdy przekazujesz a Stringdo funkcji, przekazana wartość jest odwołaniem do obiektu String, ale nie możesz zmodyfikować tego odwołania, a bazowy obiekt String jest niezmienny.

Przydzial

zText += foo;

jest równa:

zText = new String(zText + "foo");

Oznacza to, że (lokalnie) ponownie przypisuje parametr zTextjako nowe odniesienie, które wskazuje na nowe miejsce w pamięci, w którym jest nowe, Stringktóre zawiera oryginalną zawartość zTextz "foo"dołączoną.

Oryginalny obiekt nie jest modyfikowany, a main()zmienna lokalna metody zTextnadal wskazuje na oryginalny (pusty) ciąg.

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

wydruki:

Original value:
Local value: foo
Final value:

Jeśli chcesz zmodyfikować ciąg, możesz, zgodnie z opisem, StringBuilderlub jakiś kontener (tablicę lub AtomicReferenceniestandardową klasę kontenera), który zapewnia dodatkowy poziom niezależności wskaźnika. Alternatywnie, po prostu zwróć nową wartość i przypisz ją:

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

wydruki:

Original value:
Local value: foo
Final value: foo

Jest to prawdopodobnie najbardziej podobne do Javy rozwiązanie w ogólnym przypadku - zobacz Efektywny element Java „Korzystna niezmienność”.

Jak już wspomniano, StringBuilderczęsto zapewnia lepszą wydajność - jeśli masz dużo do zrobienia, szczególnie wewnątrz pętli, użyj StringBuilder.

Ale spróbuj przekazać niezmienne, Stringsa nie zmienne, StringBuildersjeśli możesz - Twój kod będzie łatwiejszy do odczytania i łatwiejszy w utrzymaniu. Rozważ utworzenie parametrów finali skonfigurowanie środowiska IDE, aby ostrzegało Cię, gdy ponownie przypisujesz parametr metody do nowej wartości.

Ciąg jest niezmiennym obiektem w Javie. Możesz użyć klasy StringBuilder, aby wykonać zadanie, które próbujesz wykonać, w następujący sposób:

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

Inną opcją jest utworzenie klasy z ciągiem jako zmienną zakresu (zdecydowanie odradzane) w następujący sposób:

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

Odpowiedź jest prosta. W java ciągi znaków są niezmienne. Stąd przypomina to użycie modyfikatora „final” (lub „const” w C / C ++). Tak więc raz przypisany nie możesz go zmienić tak, jak to zrobiłeś.

Można zmienić których wartość, do której ciąg punktów, ale nie można zmienić rzeczywistej wartości, do których ten ciąg jest obecnie wskazującego.

To znaczy. String s1 = "hey". Możesz zrobić s1 = "woah", i to jest całkowicie w porządku, ale tak naprawdę nie możesz zmienić podstawowej wartości ciągu (w tym przypadku: "hey") na coś innego po przypisaniu go za pomocą plusEquals itp. (Tj. s1 += " whatup != "hey whatup").

Aby to zrobić, użyj klas StringBuilder lub StringBuffer lub innych zmiennych kontenerów, a następnie po prostu wywołaj .toString (), aby przekonwertować obiekt z powrotem na łańcuch.

Uwaga: Ciągi znaków są często używane jako klucze mieszające, dlatego jest to jeden z powodów, dla których są one niezmienne.

String to specjalna klasa w Javie. Jest bezpieczny dla wątków, co oznacza „Po utworzeniu instancji String zawartość instancji String nigdy się nie zmieni”.

Oto, co się dzieje

 zText += "foo";

Najpierw kompilator Java pobierze wartość instancji zText String, a następnie utworzy nową instancję String, której wartością jest zText z dołączonym „foo”. Więc wiesz, dlaczego instancja, na którą wskazuje zText, nie uległa zmianie. To zupełnie nowa instancja. W rzeczywistości nawet String „foo” jest nową instancją String. Tak więc dla tej instrukcji Java utworzy dwie instancje typu String, jedna to „foo”, a druga to wartość z zText append „foo”. Zasada jest prosta: wartość instancji String nigdy nie zostanie zmieniona.

W przypadku metody fillString możesz użyć StringBuffer jako parametru lub zmienić go w ten sposób:

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

W Javie ciągi znaków są niezmienne .

To działa przy użyciu 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");
}
}

Jeszcze lepiej użyj 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");
}
}

Ciąg jest niezmienny w java. nie można modyfikować / zmieniać istniejącego literału ciągu / obiektu.

String s = "Witaj"; s = s + "cześć";

W tym przypadku poprzednie odniesienie s zostało zastąpione nowym odniesieniem s wskazującym na wartość „HelloHi”.

Jednak w celu wprowadzenia zmienności mamy StringBuilder i StringBuffer.

StringBuilder s = new StringBuilder (); s.append ("Cześć");

spowoduje to dodanie nowej wartości „Cześć” do tego samego odniesienia. //

Aaron Digulla ma jak dotąd najlepszą odpowiedź. Odmianą jego drugiej opcji jest użycie klasy opakowania lub kontenera MutableObject biblioteki commons lang w wersji 3+:

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

zapisujesz deklarację klasy kontenera. Wadą jest zależność od wspólnej biblioteki lang. Ale biblioteka ma sporo przydatnych funkcji i prawie każdy większy projekt, nad którym pracowałem, używał jej.

Aby przekazać obiekt (w tym String) przez odwołanie w java, można przekazać go jako element członkowski otaczającego adaptera. Oto rozwiązanie z generycznym:

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

Dla bardziej ciekawych

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

Teraz, uruchamiając powyższy kod, możesz zobaczyć, jak hashcodeszmienia się adres za pomocą zmiennej String s. nowy obiekt jest przydzielany do zmiennej s w funkcji, changetogdy zmienia się s