blocks|key|295233|text|所有局部变量(包括方法参数)都放在堆栈中；对象及其所有字段都存储在堆中。变量始终是基本类型或对对象的引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295234|Java实现可能实际上将对象存储在堆上，以使其仍然符合规范。类似地，局部变量可以存储在寄存器中，或者通过优化而变得模糊不清。|295235|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

All local variables (including method arguments) go on the stack; objects and all their fields are stored in the heap. Variables are always primitives or references to objects.

Java implementations may actually store objects on the heap in such a way that it still complies with the specification. Similarly local variables may be stored in registers or become indistinct through optimisation.

blocks|key|300405|text|在这两个地方都可以找到原语。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300406|class+Foo
{
+++public+int+x;
+++public+static+void+Main()
+++{
++++++int+y+=+3;+//+y+is+on+the+stack
++++++Foo+f+=+new+Foo();++//+f.x+is+probably+on+the+heap
+++}+
}|code-block|syntax|javascript|300407|除非您正在构建一个JVM，否则您不应该真正关心它。一个真正聪明的优化器可能会决定，因为f指向的Foo永远不会转义Main，并且永远不会传递给另一个函数，所以在堆栈上分配它是安全的。|300408|关于更新：|300409|堆栈和堆的区别不在于存储在其中的内容，而在于为它们提供的操作。堆栈允许你以后进先出的方式分配一块内存，你不能释放一块内存，直到所有比它更年轻的内存块也被释放。这很方便地与调用堆栈的使用方式一致。你可以把任何东西放在堆栈上，只要当你的函数返回时，那个东西消失了就行了。这是一种优化，因为它从堆栈中分配和释放非常快，因为它只支持以这种方式使用。如果需要的话，可以在实现中存储堆中函数的所有局部变量。堆更灵活，因此使用成本也更高。正如我所说的，说一个对象有一个堆栈和一个堆是不准确的，堆栈与堆的区别不是它里面有什么，而是可用的操作。|300410|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

primitives can be found in both places.

<pre><code>class Foo
{
 public int x;
 public static void Main()
 {
 int y = 3; // y is on the stack
 Foo f = new Foo(); // f.x is probably on the heap
 } 
}
</code></pre>

except you shouldn't really care unless you're building a JVM. A really clever optimizer might decide that since the Foo that f points to never escapes Main, and is never passed to another function that it is safe to allocate it on the stack.

With regards to the update:

The stack and the heap aren't distinguished by what is stored in them, but rather the operations provided for them. The stack allows you to allocate a piece of memory in a LIFO fashion, you can't deallocate a piece until all the pieces younger than it have also been deallocated. This conveniently aligns with how a call stack is used. You can put anything on the stack as long as it is ok for that thing to go away when your function returns. This is an optimization, as it is very quick to allocate and deallocate from a stack since it only supports being used in this manner. One could store all the local variables for a function on the heap in an implementation if one wanted to. The heap is more flexible, and consequently more expensive to use. It would not be accurate to say that an object has a stack and a heap, as I said, what distinguishes the stack from the heap is not what is in it, but the available operations.

blocks|key|298301|text|本地定义的原语将位于堆栈上。但是，如果将原语定义为对象实例的一部分，则该原语将位于堆中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|298302|public+class+Test+{
++++private+static+class+HeapClass+{
++++++++public+int+y;+//+When+an+instance+of+HeapClass+is+allocated,+this+will+be+on+the+heap.
++++}
++++public+static+void+main(String[]+args)+{
++++++++int+x=1;+//+This+is+on+the+stack.
++++}
}|code-block|syntax|javascript|298303|关于更新：|298304|对象没有自己的堆栈。在我的示例中，int+y实际上是每个HeapClass实例的一部分。无论何时分配HeapClass的实例(例如new+Test.HeapClass())，HeapClass的所有成员变量都会添加到堆中。因此，由于HeapClass的实例是在堆上分配的，因此int+y将作为HeapClass实例的一部分在堆上。|offset|length|style|CODE|298305|但是，在任何方法的主体中声明的所有原始变量在堆栈上都是。|BOLD|298306|正如您在上面的示例中看到的，int+x之所以在堆栈上，是因为它是在方法体中声明的--而不是作为类的成员。|298307|entityMap^0|0|0|0|H|5|S|9|1T|K|38|9|3U|5|42|9|0|R|1|0|0|1G|E|5|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Y|8|@$K|Z|L|10|M|N]|$K|11|L|12|M|N]|$K|13|L|14|M|N]|$K|15|L|16|M|N]|$K|17|L|18|M|N]|$K|19|L|1A|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@$K|1C|L|1D|M|Q]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1E|8|@$K|1F|L|1G|M|Q]|$K|1H|L|1I|M|N]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|U|$]]

Primitives defined locally would be on the stack. However if a primitive were defined as part of an instance of an object, that primitive would be on the heap.

<pre><code>public class Test {
 private static class HeapClass {
 public int y; // When an instance of HeapClass is allocated, this will be on the heap.
 }
 public static void main(String[] args) {
 int x=1; // This is on the stack.
 }
}
</code></pre>

With regards to the update:

Objects do not have their own stack. In my example, <code>int y</code> would actually be part of each instance of <code>HeapClass</code>. Whenever an instance of HeapClass is allocated (e.g. <code>new Test.HeapClass()</code>), all member variables of HeapClass are added to the heap. Thus, since instances of <code>HeapClass</code> are being allocated on the heap, <code>int y</code> would be on the heap as part of an instance of <code>HeapClass</code>.

However, all primitive variables declared in the body of any method would be on the stack.

As you can see in the above example, <code>int x</code> is on the stack because it is declared in a method body--not as a member of a class.

blocks|key|3023946|text|原始值是在堆栈上分配的，除非它们是对象的字段，在这种情况下，它们会放在堆上。堆栈是用来计算和执行的，所以说具有原语字段的对象有堆栈是没有意义的-它仍然被认为是堆的一部分。甚至Stack对象也是在堆上分配的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3023947|entityMap^0|2F|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Primitive values are allocated on the stack unless they are fields of an object, in which case they go on the heap. The stack is used for evaluation and execution, so no it doesn't make sense to say that objects with primitive fields have a stack—it is still considered to be part of the heap. Even <code>Stack</code> objects are allocated on the heap.

I just know that the non-primitives (the objects) go on the heap, and methods go on the stack, but what about the primitive variables?

--update

Based on the answers, I could say the heap can have a new stack and heap for a given object? Given that the object will have primitive and reference variables..?

Do Java primitives go on the Stack or the Heap?

对象存储

Java

我只知道非原语(对象)放在堆上，方法放在堆栈上，但是原生变量呢？--更新根据答案，我可以说堆可以有一个新的堆栈和给定对象的堆？假设对象将具有基元变量和引用变量..？

问Java原语是放在栈上还是堆上？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java原语是放在栈上还是堆上？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java原语是放在栈上还是堆上？
EN