Passare una stringa per riferimento in Java?

Sono abituato a fare quanto segue in C:

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

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

E l'output è:

foo

Tuttavia, in Java, questo non sembra funzionare. Presumo perché l' Stringoggetto viene copiato anziché passato per riferimento . Ho pensato che le stringhe fossero oggetti, che sono sempre passati per riferimento.

Che cosa sta succedendo qui?

Hai tre opzioni:

1. Usa uno StringBuilder:

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

2. Crea una classe contenitore e passa un'istanza del contenitore al tuo metodo:

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

3. Crea un array:

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

Dal punto di vista delle prestazioni, StringBuilder è di solito l'opzione migliore.

In Java nulla viene passato per riferimento . Tutto è passato per valore . I riferimenti agli oggetti vengono passati per valore. Inoltre, le stringhe sono immutabili . Quindi quando aggiungi alla stringa passata ottieni solo una nuova stringa. È possibile utilizzare un valore restituito o passare invece StringBuffer.

Ciò che sta accadendo è che il riferimento viene passato per valore, ovvero viene passata una copia del riferimento. Nulla in java viene passato per riferimento e poiché una stringa è immutabile, tale assegnazione crea un nuovo oggetto stringa a cui ora punta la copia del riferimento . Il riferimento originale punta ancora alla stringa vuota.

Questo sarebbe lo stesso per qualsiasi oggetto, ovvero impostandolo su un nuovo valore in un metodo. L'esempio seguente rende più ovvio ciò che sta succedendo, ma concatenare una stringa è davvero la stessa cosa.

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

java.lang.String è immutabile.

Odio incollare gli URL ma https://docs.oracle.com/javase/10/docs/api/java/lang/String.html è essenziale per leggere e capire se sei in java-land.

gli oggetti vengono passati per riferimento, le primitive vengono passate per valore.

La stringa non è una primitiva, è un oggetto ed è un caso speciale di oggetto.

Questo è a scopo di risparmio di memoria. In JVM, c'è un pool di stringhe. Per ogni stringa creata, JVM proverà a vedere se esiste la stessa stringa nel pool di stringhe e indicherà se ce n'era già una.

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

/* PRODUZIONE */

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

== sta controllando l'indirizzo di memoria (riferimento) e .equals sta controllando il contenuto (valore)

Tutti gli argomenti in Java vengono passati per valore. Quando si passa Stringa una funzione, il valore che viene passato è un riferimento a un oggetto String, ma non è possibile modificarlo e l'oggetto String sottostante è immutabile.

L'incarico

zText += foo;

è equivalente a:

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

Cioè, (localmente) riassegna il parametro zTextcome un nuovo riferimento, che punta a una nuova posizione di memoria, in cui è un nuovoString che contiene il contenuto originale di zTextcon "foo"allegato.

L'oggetto originale non viene modificato e la main()variabile locale del metodo zTextpunta ancora alla stringa originale (vuota).

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

stampe:

Original value:
Local value: foo
Final value:

Se si desidera modificare la stringa, è possibile utilizzare come indicato StringBuilder oppure un contenitore (un array o una AtomicReferenceo una classe di contenitore personalizzata) che fornisce un ulteriore livello di indirizzamento del puntatore. In alternativa, è sufficiente restituire il nuovo valore e assegnarlo:

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

stampe:

Original value:
Local value: foo
Final value: foo

Questa è probabilmente la soluzione più simile a Java nel caso generale - vedi il elemento Java efficace "Favorisci l'immutabilità".

Come notato, però, StringBuilder spesso ti darà prestazioni migliori - se hai molto da aggiungere, in particolare all'interno di un ciclo, usa StringBuilder.

Ma se possibile, cerca di passare da immutabile Stringspiuttosto che mutabile StringBuilders: il tuo codice sarà più facile da leggere e più gestibile. Prendi in considerazione la possibilità di impostare i parametri finale configurare l'IDE per avvisarti quando riassegni un parametro di metodo a un nuovo valore.

String è un oggetto immutabile in Java. È possibile utilizzare la classe StringBuilder per eseguire il lavoro che si sta tentando di eseguire, come segue:

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

Un'altra opzione è quella di creare una classe con una stringa come variabile di ambito (altamente sconsigliata) come segue:

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

La risposta è semplice Nelle stringhe Java sono immutabili. Quindi è come usare il modificatore 'final' (o 'const' in C / C ++). Quindi, una volta assegnato, non puoi cambiarlo come hai fatto tu.

È possibile modificare il quale il valore a cui punta uno stringa, ma non è possibile modificare il valore effettivo a cui questa stringa sta puntando.

Vale a dire. String s1 = "hey". Puoi fare s1 = "woah", e questo è del tutto ok, ma non puoi effettivamente cambiare il valore sottostante della stringa (in questo caso: "hey") in qualcos'altro una volta assegnato usando plusEquals, ecc. (Es. s1 += " whatup != "hey whatup").

Per fare ciò, usa le classi StringBuilder o StringBuffer o altri contenitori mutabili, quindi chiama .toString () per riconvertire l'oggetto in una stringa.

nota: le stringhe vengono spesso utilizzate come chiavi hash, quindi fa parte del motivo per cui sono immutabili.

String è una classe speciale in Java. È Thread Safe che significa "Una volta creata un'istanza String, il contenuto dell'istanza String non verrà mai modificato".

Ecco cosa sta succedendo

 zText += "foo";

Innanzitutto, il compilatore Java otterrà il valore dell'istanza String zText, quindi creerà una nuova istanza String il cui valore è zText aggiungendo "pippo". Quindi sai perché l'istanza a cui punta zText non è cambiata. È totalmente una nuova istanza. In effetti, anche String "pippo" è una nuova istanza di String. Quindi, per questa affermazione, Java creerà due istanze String, una è "pippo", un'altra è il valore di zText append "pippo". La regola è semplice: il valore dell'istanza String non verrà mai modificato.

Per il metodo fillString, puoi utilizzare StringBuffer come parametro oppure puoi modificarlo in questo modo:

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

Le stringhe sono immutabili in Java.

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

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

String è immutabile in Java. non è possibile modificare / cambiare una stringa / oggetto letterale esistente.

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

Qui i riferimenti precedenti sono sostituiti dai nuovi riferimenti che puntano al valore "HelloHi".

Tuttavia, per apportare mutabilità abbiamo StringBuilder e StringBuffer.

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

questo aggiunge il nuovo valore "Ciao" agli stessi riferimenti. //

Aaron Digulla ha finora la risposta migliore. Una variante della sua seconda opzione consiste nell'utilizzare la classe wrapper o container MutableObject della libreria lang commons versione 3+:

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

si salva la dichiarazione della classe contenitore. Lo svantaggio è una dipendenza dalla lingua comune. Ma la lib ha molte funzioni utili e quasi tutti i progetti più grandi su cui ho lavorato l'hanno usata.

Per passare un oggetto (incluso String) per riferimento in Java, è possibile passarlo come membro di un adattatore circostante. Una soluzione con un generico è qui:

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

Per qualcuno che è più curioso

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

Ora eseguendo questo codice sopra puoi vedere come hashcodescambia l' indirizzo con la variabile String s. un nuovo oggetto viene assegnato alla variabile s in funzione changetoquando s viene modificato