Menurut String # intern () , internmetode seharusnya mengembalikan String dari kolam String jika String ditemukan di kolam String, jika tidak objek string baru akan ditambahkan dalam kolam String dan referensi dari String ini dikembalikan.

Jadi saya mencoba ini:

String s1 = "Rakesh";
String s2 = "Rakesh";
String s3 = "Rakesh".intern();

if ( s1 == s2 ){
    System.out.println("s1 and s2 are same");  // 1.
}

if ( s1 == s3 ){
    System.out.println("s1 and s3 are same" );  // 2.
}

Saya mengharapkan yang s1 and s3 are sameakan dicetak saat s3 diinternir, dan s1 and s2 are sametidak akan dicetak. Tetapi hasilnya adalah: kedua garis dicetak. Jadi itu berarti, secara konstan konstanta String diinternir. Tetapi jika demikian, mengapa kita perlu internmetode ini? Dengan kata lain kapan kita harus menggunakan metode ini?

Java secara otomatis magang String literal. Ini berarti bahwa dalam banyak kasus, operator == tampaknya berfungsi untuk String dengan cara yang sama seperti yang dilakukannya untuk int atau nilai primitif lainnya.

Karena magang otomatis untuk string literal, intern()metode ini akan digunakan pada Strings yang dibuat dengannew String()

Menggunakan contoh Anda:

String s1 = "Rakesh";
String s2 = "Rakesh";
String s3 = "Rakesh".intern();
String s4 = new String("Rakesh");
String s5 = new String("Rakesh").intern();

if ( s1 == s2 ){
    System.out.println("s1 and s2 are same");  // 1.
}

if ( s1 == s3 ){
    System.out.println("s1 and s3 are same" );  // 2.
}

if ( s1 == s4 ){
    System.out.println("s1 and s4 are same" );  // 3.
}

if ( s1 == s5 ){
    System.out.println("s1 and s5 are same" );  // 4.
}

akan kembali:

s1 and s2 are same
s1 and s3 are same
s1 and s5 are same

Dalam semua kasus selain s4variabel, nilai yang dibuat secara eksplisit menggunakan newoperator dan di mana internmetode tidak digunakan pada hasilnya, itu adalah contoh permanen tunggal yang dikembalikan kumpulan string konstan JVM .

Lihat Teknik Java "String Equality and Interning" untuk informasi lebih lanjut.

Pada proyek baru-baru ini, beberapa struktur data besar diatur dengan data yang dibaca dari database (dan karenanya bukan konstanta String / literal) tetapi dengan sejumlah besar duplikasi. Itu adalah aplikasi perbankan, dan hal-hal seperti nama-nama perusahaan sederhana (mungkin 100 atau 200) muncul di mana-mana. Struktur data sudah besar, dan jika semua nama perusahaan itu adalah objek unik, mereka akan meluap memori. Sebagai gantinya, semua struktur data memiliki referensi ke objek String 100 atau 200 yang sama, sehingga menghemat banyak ruang.

Keuntungan kecil lain dari String yang diinternir adalah yang ==dapat digunakan (berhasil!) Untuk membandingkan String jika semua string yang terlibat dijamin akan diinternir. Terlepas dari sintaks yang lebih ramping, ini juga merupakan peningkatan kinerja. Tetapi seperti yang telah ditunjukkan oleh orang lain, melakukan hal ini berisiko besar menyebabkan kesalahan pemrograman, jadi ini harus dilakukan hanya sebagai ukuran terakhir dari upaya terakhir.

The downside adalah bahwa menginternir String membutuhkan lebih banyak waktu daripada hanya melemparkannya di heap, dan bahwa ruang untuk Strings diinternir mungkin terbatas, tergantung pada implementasi Java. Paling baik dilakukan ketika Anda berhadapan dengan sejumlah string yang diketahui dengan banyak duplikasi.

Saya ingin menambahkan 2 sen untuk menggunakan ==string yang diinternir.

Hal pertama yang String.equalsdilakukan adalah this==object.

Jadi meskipun ada beberapa perolehan kinerja sangat kecil (Anda tidak memanggil metode), dari sudut pandang pengelola menggunakan ==mimpi buruk, karena beberapa string yang diinternir memiliki kecenderungan untuk menjadi non-magang.

Jadi saya sarankan untuk tidak bergantung pada kasus khusus ==untuk string yang diinternir, tetapi selalu digunakan equalsseperti yang dimaksudkan Gosling.

EDIT: diinternir menjadi tidak diinternir:

V1.0
public class MyClass
{
  private String reference_val;

  ...

  private boolean hasReferenceVal ( final String[] strings )
  {
    for ( String s : strings )
    {
      if ( s == reference_val )
      {
        return true;
      }
    }

    return false;
  }

  private void makeCall ( )
  {
     final String[] interned_strings =  { ... init with interned values ... };

     if ( hasReference( interned_strings ) )
     {
        ...
     }
  }
}

Dalam versi 2.0, pengelola memutuskan untuk mengumumkan kepada hasReferenceValpublik, tanpa menjelaskan lebih lanjut bahwa mereka mengharapkan serangkaian string yang diinternir.

V2.0
public class MyClass
{
  private String reference_val;

  ...

  public boolean hasReferenceVal ( final String[] strings )
  {
    for ( String s : strings )
    {
      if ( s == reference_val )
      {
        return true;
      }
    }

    return false;
  }

  private void makeCall ( )
  {
     final String[] interned_strings =  { ... init with interned values ... };

     if ( hasReference( interned_strings ) )
     {
        ...
     }
  }
}

Sekarang Anda memiliki bug, yang mungkin sangat sulit ditemukan, karena dalam kebanyakan kasus array berisi nilai-nilai literal, dan kadang-kadang string non-literal digunakan. Jika equalsdigunakan alih-alih ==maka hasReferenceValmasih akan terus bekerja. Sekali lagi, peningkatan kinerja sangat kecil, tetapi biaya pemeliharaan tinggi.

String literal dan konstanta diinternir secara default. Artinya, "foo" == "foo"(dinyatakan oleh String literal), tetapi new String("foo") != new String("foo").

Pelajari Java String Intern - sekali untuk semua

String dalam java adalah objek yang tidak bisa diubah oleh desain. Oleh karena itu, dua objek string bahkan dengan nilai yang sama akan menjadi objek yang berbeda secara default. Namun, jika kita ingin menghemat memori, kita dapat mengindikasikan untuk menggunakan memori yang sama dengan konsep yang disebut string intern.

Aturan di bawah ini akan membantu Anda memahami konsep dalam istilah yang jelas:

1. Kelas string mempertahankan kolam-internal yang awalnya kosong. Kumpulan ini harus menjamin mengandung objek string dengan hanya nilai unik.
2. Semua literal string yang memiliki nilai yang sama harus dianggap objek memori-lokasi yang sama karena mereka tidak memiliki gagasan pembedaan. Oleh karena itu, semua literal dengan nilai yang sama akan membuat satu entri di intern-pool dan akan merujuk ke lokasi memori yang sama.
3. Penggabungan dua atau lebih literal juga merupakan literal. (Oleh karena itu aturan # 2 akan berlaku untuk mereka)
4. Setiap string yang dibuat sebagai objek (yaitu dengan metode lain kecuali sebagai literal) akan memiliki lokasi memori yang berbeda dan tidak akan membuat entri apa pun di kolam-internal
5. Penggabungan literal dengan non-literal akan membuat non-literal. Dengan demikian, objek yang dihasilkan akan memiliki lokasi memori baru dan TIDAK akan membuat entri di kolam-internal.
6. Menjalankan metode intern pada objek string, baik menciptakan objek baru yang memasuki kolam-intern atau mengembalikan objek yang ada dari kumpulan yang memiliki nilai yang sama. Doa pada objek apa pun yang tidak ada di intern-pool, TIDAK memindahkan objek ke pool. Ini lebih tepatnya menciptakan objek lain yang memasuki kolam.

Contoh:

String s1=new String (“abc”);
String s2=new String (“abc”);
If (s1==s2)  //would return false  by rule #4
If (“abc” == “a”+”bc” )  //would return true by rules #2 and #3
If (“abc” == s1 )  //would return false  by rules #1,2 and #4
If (“abc” == s1.intern() )  //would return true  by rules #1,2,4 and #6
If ( s1 == s2.intern() )      //wound return false by rules #1,4, and #6

Catatan: Kasus motivasi untuk string magang tidak dibahas di sini. Namun, menghemat memori pasti akan menjadi salah satu tujuan utama.

Anda harus melihat dua periode waktu yaitu waktu kompilasi dan waktu runtime. sebagai contoh:

//example 1 
"test" == "test" // --> true 
"test" == "te" + "st" // --> true

//example 2 
"test" == "!test".substring(1) // --> false
"test" == "!test".substring(1).intern() // --> true

di satu sisi, dalam contoh 1, kami menemukan hasilnya semua kembali benar, karena dalam waktu kompilasi, jvm akan menempatkan "tes" ke kumpulan string literal, jika jvm menemukan "tes" ada, maka itu akan menggunakan yang sudah ada, dalam contoh 1, string "test" semuanya menunjuk ke alamat memori yang sama, jadi contoh 1 akan mengembalikan true. di sisi lain, dalam contoh 2, metode substring () mengeksekusi dalam waktu runtime, dalam kasus "test" == "! test" .substring (1), pool akan membuat dua objek string, " test "and"! test ", jadi mereka adalah objek referensi yang berbeda, jadi case ini akan mengembalikan false, dalam kasus" test "=="! test ".substring (1) .intern (), metode intern ( ) akan menempatkan ""! test ".substring (1)" ke kumpulan string literal,

http://en.wikipedia.org/wiki/String_interning

string interning adalah metode menyimpan hanya satu salinan dari masing-masing nilai string yang berbeda, yang harus tidak berubah. Interning string membuat beberapa tugas pemrosesan string lebih hemat waktu atau ruang dengan biaya yang membutuhkan lebih banyak waktu ketika string dibuat atau diinternir. Nilai-nilai yang berbeda disimpan dalam kumpulan string intern.

Interned Strings menghindari Strings duplikat. Interning menghemat RAM dengan mengorbankan lebih banyak waktu CPU untuk mendeteksi dan mengganti string duplikat. Hanya ada satu salinan dari setiap String yang telah diinternir, tidak peduli berapa banyak referensi yang menunjukkannya. Karena String tidak dapat diubah, jika dua metode berbeda secara kebetulan menggunakan String yang sama, mereka dapat berbagi salinan String yang sama. Proses konversi Strings digandakan ke yang dibagikan disebut interning.String.intern () memberi Anda alamat String master kanonik. Anda dapat membandingkan string yang diinternir dengan == sederhana (yang membandingkan pointer) dan bukan sama denganyang membandingkan karakter String satu per satu. Karena String tidak dapat diubah, proses intern bebas untuk lebih menghemat ruang, misalnya, dengan tidak membuat String literal terpisah untuk "pot" ketika ada sebagai substring dari beberapa literal lain seperti "hippopotamus".

Untuk melihat lebih banyak http://mindprod.com/jgloss/interned.html

String s1 = "Anish";
        String s2 = "Anish";

        String s3 = new String("Anish");

        /*
         * When the intern method is invoked, if the pool already contains a
         * string equal to this String object as determined by the
         * method, then the string from the pool is
         * returned. Otherwise, this String object is added to the
         * pool and a reference to this String object is returned.
         */
        String s4 = new String("Anish").intern();
        if (s1 == s2) {
            System.out.println("s1 and s2 are same");
        }

        if (s1 == s3) {
            System.out.println("s1 and s3 are same");
        }

        if (s1 == s4) {
            System.out.println("s1 and s4 are same");
        }

KELUARAN

s1 and s2 are same
s1 and s4 are same

String p1 = "example";
String p2 = "example";
String p3 = "example".intern();
String p4 = p2.intern();
String p5 = new String(p3);
String p6 = new String("example");
String p7 = p6.intern();

if (p1 == p2)
    System.out.println("p1 and p2 are the same");
if (p1 == p3)
    System.out.println("p1 and p3 are the same");
if (p1 == p4)
    System.out.println("p1 and p4 are the same");
if (p1 == p5)
    System.out.println("p1 and p5 are the same");
if (p1 == p6)
    System.out.println("p1 and p6 are the same");
if (p1 == p6.intern())
    System.out.println("p1 and p6 are the same when intern is used");
if (p1 == p7)
    System.out.println("p1 and p7 are the same");

Ketika dua string dibuat secara independen, intern()memungkinkan Anda untuk membandingkannya dan itu juga membantu Anda dalam membuat referensi di kumpulan string jika referensi itu tidak ada sebelumnya.

Ketika Anda menggunakan String s = new String(hi), java membuat instance baru dari string, tetapi ketika Anda menggunakan String s = "hi", java memeriksa apakah ada instance kata "hi" dalam kode atau tidak dan jika ada, itu hanya mengembalikan referensi.

Karena membandingkan string didasarkan pada referensi, intern()membantu Anda membuat referensi dan memungkinkan Anda untuk membandingkan konten string.

Ketika Anda menggunakan intern()dalam kode, itu membersihkan ruang yang digunakan oleh string yang merujuk ke objek yang sama dan hanya mengembalikan referensi dari objek yang sama yang sudah ada dalam memori.

Tetapi dalam hal p5 saat Anda menggunakan:

String p5 = new String(p3);

Hanya isi p3 yang disalin dan p5 dibuat baru. Jadi tidak diinternir .

Jadi hasilnya adalah:

p1 and p2 are the same
p1 and p3 are the same
p1 and p4 are the same
p1 and p6 are the same when intern is used
p1 and p7 are the same

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    String s1 = "test";
    String s2 = new String("test");
    System.out.println(s1==s2);              //false
    System.out.println(s1==s2.intern());    //true --> because this time compiler is checking from string constant pool.
}

Metode string intern () digunakan untuk membuat salinan tepat dari objek string heap dalam kumpulan string konstan. Objek string dalam kumpulan string konstan secara otomatis diinternir tetapi objek string dalam tumpukan tidak. Penggunaan utama pembuatan intern adalah untuk menghemat ruang memori dan untuk melakukan perbandingan objek string yang lebih cepat.

Sumber: Apa itu string intern di java?

Seperti yang Anda katakan, intern()metode string pertama akan menemukan dari kumpulan String, jika ditemukan, maka itu akan mengembalikan objek yang menunjuk ke sana, atau akan menambahkan String baru ke dalam kumpulan.

    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Hello".intern();
    String s4 = new String("Hello");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//true
    System.out.println(s1 == s4.intern());//true

The s1dan s2dua objek menunjuk ke String kolam renang "Hello", dan menggunakan "Hello".intern()akan menemukan bahwa s1dan s2. Jadi "s1 == s3"mengembalikan true, serta ke s3.intern().

Dengan menggunakan referensi objek tumpukan jika kita ingin mendapatkan referensi objek konstan string yang sesuai , maka kita harus menggunakan intern ()

String s1 = new String("Rakesh");
String s2 = s1.intern();
String s3 = "Rakesh";

System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // true

Tampilan Bergambar

Langkah 1: Obyek dengan data 'Rakesh' dibuat di heap dan string konstan pool. Juga s1 selalu menunjuk ke objek tumpukan.

Langkah 2: Dengan menggunakan referensi objek heap s1, kami mencoba untuk mendapatkan string yang sesuai dengan referensi objek konstan s2, menggunakan intern ()

Langkah 3: Secara sengaja membuat objek dengan data 'Rakesh' di kumpulan string konstan, dirujuk dengan nama s3

Sebagai "==" operator dimaksudkan untuk perbandingan referensi.

Mendapatkan false untuk s1 == s2

Menjadi kenyataan untuk s2 == s3

Semoga bantuan ini !!