Melewati sebuah String dengan Referensi di Jawa?

Saya terbiasa melakukan hal berikut dalam C:

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

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

Dan hasilnya adalah:

foo

Namun, di Jawa, ini sepertinya tidak berhasil. Saya berasumsi karena Stringobjek disalin alih-alih dilewatkan oleh referensi . Saya pikir String adalah objek, yang selalu dilewati dengan referensi.

Apa yang terjadi disini?

Anda memiliki tiga opsi:

1. Gunakan StringBuilder:

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

2. Buat kelas wadah dan berikan instance wadah ke metode Anda:

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

3. Buat sebuah array:

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

Dari sudut pandang kinerja, StringBuilder biasanya merupakan pilihan terbaik.

Di Jawa tidak ada yang dilewatkan dengan referensi . Semuanya dilewatkan dengan nilai . Referensi objek dilewatkan oleh nilai. Selain itu, String tidak dapat diubah . Jadi ketika Anda menambahkan ke String yang diteruskan Anda hanya mendapatkan String baru. Anda bisa menggunakan nilai balik, atau meneruskan StringBuffer sebagai gantinya.

Apa yang terjadi adalah bahwa referensi dilewatkan oleh nilai, yaitu, salinan referensi dilewatkan. Tidak ada dalam java yang dilewatkan oleh referensi, dan karena sebuah string tidak dapat diubah, tugas itu menciptakan objek string baru yang ditunjuk oleh salinan referensi tersebut . Referensi asli masih menunjuk ke string kosong.

Ini akan sama untuk objek apa pun, yaitu, menetapkannya ke nilai baru dalam suatu metode. Contoh di bawah ini hanya membuat apa yang sedang terjadi menjadi lebih jelas, tetapi menggabungkan string adalah hal yang sama.

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

java.lang.String tidak dapat diubah.

Saya benci menempel URL tetapi https://docs.oracle.com/javase/10/docs/api/java/lang/String.html sangat penting bagi Anda untuk membaca dan memahami jika Anda berada di java-land.

objek dilewatkan dengan referensi, primitif dilewatkan oleh nilai.

String bukan primitif, itu adalah objek, dan itu adalah kasus khusus objek.

Ini untuk tujuan penghematan memori. Di JVM, ada kumpulan string. Untuk setiap string yang dibuat, JVM akan mencoba untuk melihat apakah string yang sama ada di kumpulan string, dan arahkan ke sana jika sudah ada.

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

/ * OUTPUT * /

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

== memeriksa alamat memori (referensi), dan .equals memeriksa isi (nilai)

Semua argumen di Jawa diteruskan oleh nilai. Saat Anda melewatkan Stringfungsi, nilai yang diteruskan adalah referensi ke objek String, tetapi Anda tidak bisa mengubah referensi itu, dan objek String yang mendasarinya tidak berubah.

Tugas

zText += foo;

setara dengan:

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

Artinya, itu (secara lokal) menetapkan kembali parameter zTextsebagai referensi baru, yang menunjuk ke lokasi memori baru, di mana ini adalah yang baru Stringyang berisi konten asli zTextdengan "foo"ditambahkan.

Objek asli tidak dimodifikasi, dan main()variabel lokal metode zTextmasih menunjuk ke string asli (kosong).

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

cetakan:

Original value:
Local value: foo
Final value:

Jika Anda ingin memodifikasi string, Anda dapat menggunakan StringBuilderatau mencatat beberapa wadah (array atau AtomicReferencekelas kontainer kustom) yang memberi Anda tingkat tipuan pointer tambahan. Atau, kembalikan nilai baru dan berikan:

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

cetakan:

Original value:
Local value: foo
Final value: foo

Ini mungkin solusi yang paling mirip-Java dalam kasus umum - lihat item Java yang Efektif "Fungsikan ketidakmampuan."

Seperti yang disebutkan, StringBuilderakan sering memberi Anda kinerja yang lebih baik - jika Anda memiliki banyak penambahan yang harus dilakukan, khususnya di dalam satu loop, gunakan StringBuilder.

Tetapi cobalah untuk melewati kekekalan Stringsalih-alih bisa berubah StringBuildersjika Anda bisa - kode Anda akan lebih mudah dibaca dan lebih bisa dipelihara. Pertimbangkan membuat parameter Anda final, dan mengkonfigurasi IDE Anda untuk memperingatkan Anda ketika Anda menetapkan kembali parameter metode ke nilai baru.

String adalah objek abadi di Jawa. Anda bisa menggunakan kelas StringBuilder untuk melakukan pekerjaan yang ingin Anda capai, sebagai berikut:

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

Pilihan lain adalah membuat kelas dengan String sebagai variabel lingkup (sangat tidak disarankan) sebagai berikut:

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

Jawabannya sederhana. Dalam string java tidak berubah. Maka itu seperti menggunakan 'final' modifier (atau 'const' di C / C ++). Jadi, setelah ditugaskan, Anda tidak dapat mengubahnya seperti yang Anda lakukan.

Anda dapat mengubah yang nilai yang string poin, tetapi Anda tidak dapat mengubah nilai aktual yang string ini saat ini menunjuk.

Yaitu. String s1 = "hey". Anda dapat membuat s1 = "woah", dan itu sama sekali tidak apa-apa, tetapi Anda tidak dapat benar-benar mengubah nilai yang mendasari string (dalam hal ini: "hei") menjadi sesuatu yang lain setelah ditugaskan menggunakan plusEquals, dll. (Mis. s1 += " whatup != "hey whatup").

Untuk melakukan itu, gunakan kelas StringBuilder atau StringBuffer atau wadah yang bisa berubah, lalu panggil saja .toString () untuk mengubah objek kembali menjadi string.

Catatan: String sering digunakan sebagai kunci hash karena itu bagian dari alasan mengapa mereka tidak dapat diubah.

String adalah kelas khusus di Jawa. Ini adalah Thread Safe yang berarti "Setelah instance String dibuat, konten instance String tidak akan pernah berubah".

Inilah yang sedang terjadi

 zText += "foo";

Pertama, kompiler Java akan mendapatkan nilai instance String zText, kemudian membuat instance String baru yang nilainya zText menambahkan "foo". Jadi, Anda tahu mengapa instance yang zText tunjuk tidak berubah. Ini benar-benar contoh baru. Bahkan, bahkan String "foo" adalah turunan String baru. Jadi, untuk pernyataan ini, Java akan membuat dua instance String, satu adalah "foo", yang lain adalah nilai zText menambahkan "foo". Aturannya sederhana: Nilai instance String tidak akan pernah berubah.

Untuk metode fillString, Anda dapat menggunakan StringBuffer sebagai parameter, atau Anda dapat mengubahnya seperti ini:

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

String tidak dapat diubah di Jawa.

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

Bahkan lebih baik gunakan 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 tidak dapat diubah dalam java. Anda tidak dapat memodifikasi / mengubah, string literal / objek yang ada.

String s = "Hello"; s = s + "hai";

Di sini referensi sebelumnya diganti oleh referensi baru yang menunjuk ke nilai "HelloHi".

Namun, untuk menghadirkan mutabilitas, kami memiliki StringBuilder dan StringBuffer.

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

ini menambahkan nilai baru "Hai" ke referensi yang sama. //

Aaron Digulla memiliki jawaban terbaik sejauh ini. Variasi dari opsi keduanya adalah menggunakan kelas pembungkus atau wadah MutableObject dari commons lang library versi 3+:

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

Anda menyimpan deklarasi kelas kontainer. Kekurangannya adalah ketergantungan pada comm lun lib. Tetapi lib memiliki cukup banyak fungsi yang berguna dan hampir semua proyek besar yang saya kerjakan menggunakannya.

Untuk melewati objek (termasuk String) dengan referensi di java, Anda mungkin meneruskannya sebagai anggota adaptor di sekitarnya. Solusi dengan obat generik ada di sini:

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

Untuk seseorang yang lebih penasaran

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

Sekarang dengan menjalankan kode di atas Anda dapat melihat bagaimana alamat hashcodesberubah dengan variabel String s. objek baru dialokasikan ke variabel s dalam fungsi changetoketika s diubah