java 基本数据类型各种情况下在内存中存储位置？

Question

问题：

如何理解《Java编程思想-第四版》P23 中，这个变量直接存储“值”，并置于堆栈中，因此更加高效
一句中的 “堆栈” 两字，到底是堆还是栈？情况如下：

class demo {
    private int var1; // 字段1
    private Integer var2; // 字段2

    public static void main(String[] args) {
        int var3 = 0; // 变量1

        demo obj1 = new demo(); // 实例1
    }
}

我的理解

参考《Java编程思想-第四版》P23 和 《深入理解Java虚拟机：JVM高级特性与最佳实践 第2版》P39-P43，对于该 demo

• 实例1：存储在堆内存中

• 变量1：存储在方法栈中

• 实例1中的字段1：存储在堆中

• 实例1中的字段2：存储在堆中

如果是存储在堆中的话，何来高效一说？

Answer 1

Kami tidak boleh secara umumnya mengatakan bahawa semua jenis data asas diletakkan pada tindanan! Apabila terdapat jenis asas dalam contoh kelas, jenis asas diletakkan pada timbunan!

Answer 2

Memori dibahagikan kepada timbunan dan timbunan, anda sudah tahu ini.

Memori timbunan kepunyaan JVM, dan ingatan tindanan adalah kepunyaan kaedah Apabila kaedah tamat, ingatan tindanan hilang.

Apabila program menjalankan fungsi utama, terdapat memori timbunan dan ingatan tindanan utama

int var3 = 0;
Var3 ini diletakkan dalam memori tindanan fungsi utama dan merupakan nilai.

Selepas itu
demo obj1 = new demo();
Terdapat pembolehubah rujukan dalam ingatan tindanan fungsi utama, obj1, yang menunjuk kepada tika baharu dalam ingatan timbunan.

Mari lihat contoh ini dalam ingatan timbunan. Ia mempunyai 2 medan, yang kedua-duanya disimpan dalam timbunan.

Apabila fungsi utama tamat, jika terdapat utas lain berjalan, JVM belum lagi tamat Pada masa ini, memori tindanan fungsi utama dikosongkan, var3 tiada lagi dan pembolehubah rujukan obj1 tiada. lebih lama di sana, tetapi timbunan Contoh dalam ingatan masih wujud, dan jika tiada pembolehubah rujukan lain menunjuk kepadanya, ia akan dikosongkan kemudian.

Answer 3

是翻译错误，原文中用的是tindanan，即栈，而不是堆栈。以下是原文>：

Kes khas: jenis primitif

Satu kumpulan jenis, yang anda akan gunakan agak kerap dalam pengaturcaraan anda, mendapat layanan istimewa. Anda boleh menganggap ini sebagai jenis "primitif". Sebab untuk rawatan istimewa ialah untuk mencipta objek dengan pembolehubah baharu—terutamanya pembolehubah yang kecil dan ringkas—tidak begitu cekap, kerana baharu meletakkan objek pada timbunan. Untuk jenis ini Java kembali pada pendekatan yang diambil oleh C dan C++. Iaitu, daripada mencipta pembolehubah dengan menggunakan baharu, pembolehubah "automatik" dicipta yang bukan rujukan. Pembolehubah memegang nilai secara terus, dan ia diletakkan pada

tindanan, jadi ia lebih cekap.

Answer 4

p22, timbunan merujuk kepada timbunan dan timbunan merujuk kepada timbunan