Keraguan tentang lokasi penyimpanan rentetan java

Question

Ada soalan seperti ini:

Berapa banyak objek yang dicipta oleh String("aaa") baharu? Jawapannya ialah untuk mencipta satu atau dua Sebabnya ialah jika pembolehubah aaa wujud dalam kawasan malar, hanya satu dicipta dalam timbunan; jika pembolehubah aaa tidak wujud dalam kawasan malar, satu dicipta dalam kawasan malar dan satu dalam timbunan.

Tetapi keputusan ujian sebenar saya tidak konsisten:

String s1 = new String("aaa");
String s2 = "aaa";
System.out.println(s1 == s2); //false

Jika String("aaa") baharu mencipta objek dalam kedua-dua timbunan dan kawasan malar, maka mengapa s2 tidak terus menggunakan semula rujukan kepada kumpulan malar s1?

Tambahan:
Saya dapati bahawa saya tersalah sangka s1 harus menunjuk ke elemen dalam timbunan, dan s2 menunjuk ke elemen dalam kolam malar, jadi betul bahawa kedua-duanya tidak sama new String("aaa") juga mencipta objek dalam kolam malar pada masa yang sama?

Atau String s3 = "aa".concat("a"); Adakah s3 ini menghala ke timbunan atau kolam malar Bolehkah ia menggunakan semula pembolehubah dalam kolam malar?

Answer 1

    String s1 = new String("aaa");
    String s2 = "aaa";
    System.out.println(s1 == s2); //false
    System.out.println(s1.intern() == s2); //true

Apabila contoh String memanggil kaedah intern(), ia akan menyemak sama ada terdapat pemalar rentetan yang sama dalam kumpulan pemalar Jika ya, rujukannya akan dikembalikan Jika tidak, rentetan yang sama dengan str akan ditambahkan pada pemalar pool dan Kembalikan rujukannya Memandangkan s2 sudah berada dalam kumpulan malar, s1.intern() tidak akan menciptanya lagi, tetapi secara langsung merujuk "aaa" yang sama.

Jika ini tidak cukup jelas, mari bereksperimen,

public class Cons {
    public static void main(String[] args) throws InterruptedException {
        String s1 = new String("vv");
    }
}

Kemudian baris arahan

Perhatikan bahawa kolam berterusan mempunyai VV

Answer 2

Soalan 1:

String a = "aaa" akan mencipta objek dalam kolam malar Jika objek yang sama wujud dalam kolam malar, maka akan menghala terus ke objek. Dan String a = new String("aaa"), jika ia wujud dalam kolam malar, ia tidak akan dicipta dalam kolam malar, tetapi hanya dalam timbunan.

String a = new String("aaa");
String b = new String("aaa");
System.out.println(a == b);//比较两者堆中的引用返回false
System.out.println(a.intern() == b.intern());//比较两者常量池中的引用，返回true

Soalan 2:

Cari jawapan daripada kod sumber String s3 = "aa".concat("a"); sebenarnya bersamaan dengan String s3 = new String("aaa"), yang akan mencipta objek dalam timbunan.

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

Answer 3

String tidak mencipta contoh objek String baharu setiap kali ia diberikan nilai? Itulah sebabnya terdapat StringBuilder.

Answer 4

Menurut pemikiran berorientasikan objek, String sendiri mungkin lebih mengetahui sama ada untuk mencipta objek dalam kumpulan tetap pada masa yang sama, ia mempunyai kaedah intern().

Answer 5

Jawapan daripada beberapa yang sebelumnya sudah sangat baik Izinkan saya menambah bahawa apa yang sering kita katakan "memasukkan rentetan ke dalam kolam malar" merujuk kepada meletakkan rujukan rentetan ke dalam kolam malar rentetan (String Pool, yang pada asasnya adalah. jadual hash), rentetan itu sendiri masih diletakkan pada timbunan.

Answer 6

//    new一次就是在堆中创建一个新的对象。不new的话aaa直接在字符串常量中取值;
//    String s2 = "aaa"; 先在内存中寻找aaa，如果有，则将aaa的内存首地址指向了s1，
      如果没有则在堆中中创建一个新的对象。

//    String s1 = new String("aaa");//  
//    不管"aaa"在内存中是否存在，都会在堆中开辟新空间，将字符串"aaa"的内存首地址指向s1。


String a = "aaa";//   aaa在常量池中创建一个对象，将内存首地址指向了a
String b = "aaa";//    直接aaa已经存在的内存首地址指向b。
String c = new String("aaa");// 不管存在与否，在堆中创建1个空间，内存首地址与常量池中的地址完全不同
System.out.println(a==b);// true
System.out.println(a==c);// false