Os primitivos Java entram na pilha ou na pilha?

Eu apenas sei que os não-primitivos (os objects) vão para o heap e os methods vão para a pilha, mas e as variables ​​primitivas?

–atualizar

Com base nas respostas, eu poderia dizer que o heap pode ter uma nova pilha e heap para um determinado object? Dado que o object terá variables ​​primitivas e de referência ..?

Primitivos definidos localmente estariam na pilha. No entanto, se um primitivo fosse definido como parte de uma instância de um object, esse primitivo estaria no heap.

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. } } 

Com relação à atualização:

Objetos não possuem sua própria pilha. No meu exemplo, HeapClass seria parte de cada instância do HeapClass . Sempre que uma instância de HeapClass é alocada (por exemplo, new HeapClass() ), todas as variables ​​de membro de HeapClass são adicionadas ao heap. Assim, como as instâncias de HeapClass estão sendo alocadas no heap, int y estaria no heap como parte de uma instância de HeapClass .

No entanto, todas as variables ​​primitivas declaradas no corpo de qualquer método estariam na pilha.

Como você pode ver no exemplo acima, o int x está na pilha porque é declarado em um corpo do método – não como um membro de uma class.

Todas as variables ​​locais (incluindo argumentos do método) vão para a pilha; objects e todos os seus campos são armazenados no heap. Variáveis ​​são sempre primitivas ou referências a objects.

As implementações Java podem, na verdade, armazenar objects no heap de tal forma que ele ainda esteja em conformidade com a especificação. Da mesma forma, as variables ​​locais podem ser armazenadas em registradores ou tornarem-se indistintas por meio da otimização.

primitivos podem ser encontrados em ambos os lugares.

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

exceto que você não deveria se importar a menos que esteja construindo uma JVM. Um otimizador realmente inteligente pode decidir que, como o Foo que f aponta para nunca escapa de Main, e nunca é passado para outra function, é seguro alocá-lo na pilha.

Com relação à atualização:

A pilha e o heap não são distinguidos pelo que está armazenado neles, mas sim pelas operações fornecidas para eles. A pilha permite que você aloque uma parte da memory de uma maneira LIFO, você não pode desalocar uma peça até que todas as partes mais novas tenham sido desalocadas. Isso convenientemente se alinha com a forma como uma pilha de chamadas é usada. Você pode colocar qualquer coisa na pilha, desde que esteja tudo bem quando a sua function retornar. Essa é uma otimização, já que é muito rápido alocar e desalocar de uma pilha, uma vez que ela suporta apenas o uso dessa maneira. Pode-se armazenar todas as variables ​​locais para uma function no heap em uma implementação, se desejado. O heap é mais flexível e, consequentemente, mais caro de usar. Não seria correto dizer que um object tem uma pilha e um heap, como eu disse, o que distingue a pilha do heap não é o que está nele, mas as operações disponíveis.

Os valores primitivos são alocados na pilha, a menos que sejam campos de um object e, nesse caso, eles vão para o heap. A pilha é usada para avaliação e execução, portanto, não faz sentido dizer que objects com campos primitivos têm uma pilha – ela ainda é considerada parte do heap. Até mesmo os objects Stack são alocados no heap.

Eu acho que isso ajudaria: (internos da JVM)

Internals da JVM