A piscina constante de Java é geralmente dividida em dois tipos: piscina constante estática e piscina constante de tempo de execução
Pool constante estático: um pool constante no arquivo de classe. O pool constante no arquivo de classe inclui valores literais de string (número), informações de classe e método, ocupando a maior parte do espaço no arquivo de classe.
Pool constante de tempo de execução: depois que a JVM concluir o carregamento da classe, ele carrega o pool constante no arquivo de classe na memória e o salva na área do método. O que geralmente falamos é o pool constante do pool constante de tempo de execução na área de métodos. Outra característica importante de seu pool constante em comparação com o arquivo de classe é sua dinamicidade. O idioma Java não exige que as constantes sejam geradas apenas durante o período de compilação, ou seja, o conteúdo do pool constante no arquivo de classe pode inserir o pool constante de tempo de execução da área de métodos. Durante a corrida, novas constantes também podem ser colocadas na piscina. Esse recurso é mais comumente usado pelos desenvolvedores. O método intern () da classe String.
Contador do programa: é um pipeline para execução do programa, indicando qual comando para executar o próximo.
Pilha de métodos locais: a pilha usada pela JVM para chamar os métodos do sistema operacional.
Pilha de máquinas virtuais: a pilha usada pela JVM para executar o código Java
Máquina virtual Heap: onde os objetos são armazenados e todos os objetos que são novos nos programas Java são armazenados na pilha.
Área do método: armazenar constantes, informações de classe e variáveis estáticas, que podem ser entendidas como o local onde o arquivo de classe é armazenado na memória.
Benefícios do pool constante:
Pools constantes são usados para evitar a criação e destruição frequentes de objetos que afetam o desempenho do sistema e percebem o compartilhamento de objetos.
Por exemplo, um pool constante de cordas é usado para colocar todos os literais de cordas em um pool constante durante o estágio de compilação.
1. Salvar espaço de memória: todas as constantes de cordas com o mesmo valor literal no pool constante são mescladas, ocupando apenas um espaço
2. Salvar o tempo de execução: ao executar comparações de string, == é mais rápido que igual (). Para duas variáveis de referência, basta usar == para determinar se as referências são iguais, para que você possa determinar se os valores reais são iguais.
== Os significados dos tipos de dados básicos e representações de objetos são diferentes.
Para o tipo de dados básico: == Comparação é o valor do tipo de dados básico para objeto: == Comparação é o endereço de memória do objeto na memória
8 Tipos de dados básicos Classes de embalagem e pools constantes
A maioria das classes de wrapper de tipos de dados básicos em Java implementa tecnologias constantes de pool, a saber, byte, curto, inteiro, longo, personagem e booleano.
Número inteiro i1 = 40; número inteiro i2 = 40; System.out.println (i1 == i2); // true
Byte, curto, inteiro, longo, personagem, essas cinco classes de wrapper criam dados de cache do tipo correspondente de [-128, 127] por padrão e armazenam-os no pool constante. Se exceder esse intervalo, um novo objeto ainda será criado.
public static integer valueof (int i) {assert integercache.high> = 127; if (i> = Integercache.low && i <= Integercache.high) retorna Integercache.cache [i + (-integercache.low)]; devolver novo número inteiro (i); }Número inteiro i1 = 400; número inteiro i2 = 400; System.out.println (i1 == i2); // false
2. Os dois tipos de aulas de embalagem de números de ponto flutuante flutuam e duplos não implementam a tecnologia constante de pool.
Duplo d1 = 2,5; duplo d2 = 2,5; System.out.println (d1 == d2); // false
3. Cenários para aplicar piscinas constantes
(1) .Integeri1 = 40; Como o número inteiro é uma classe de invólucro do tipo de dados básico Int e é um objeto, o Java executará operações automáticas de boxe ao compilar e encapsular diretamente o código em integgeri1 = integer.valueof (40), usando objetos no pool constante
(2) .Integeri1 = newinteger (40); Nesse caso, um novo objeto será criado
Número inteiro i1 = 40; número inteiro i2 = novo número inteiro (40); System.out.println (i1 == i2); // false
Nesse caso, o novo número inteiro não executará constantes existentes de referência de boxe automática no pool constante, mas gerará diretamente um novo objeto na pilha.
4. Detalhes inteiros
Número inteiro i1 = 40; Número inteiro i2 = 40; Número inteiro i3 = 0; Número inteiro i4 = novo número inteiro (40); Inteiro i5 = novo número inteiro (40); Inteiro i6 = novo número inteiro (0); Número inteiro i7 = 128; Inteiro I8 = 128; System.out.println ("i1 = i2" + (i1 == i2)); System.out.println ("i1 = i2 + i3" + (i1 == i2 + i3)); System.out.println ("i1 = i4" + (i1 == i4)); System.out.println ("i4 = i5" + (i4 == i5)); System.out.println ("i4 = i5 + i6" + (i4 == i5 + i6)); System.out.println ("40 = i5 + i6" + (40 == i5 + i6)); System.out.println ("i7 = i8" + (i7 == i8));i1 = i2 truei1 = i2+i3 truei1 = i4 falsei4 = i5 falsei4 = i5+i6 true40 = i5+i6 truei7 = i8 false
Explicação: a instrução i4 == i5 + i6, porque o operador + não é aplicável a objetos inteiros. Primeiro, i5 e i6 executam operações automáticas de unboxing e adicionam valores, ou seja, i4 == 40. Em seguida, o objeto inteiro não pode ser comparado diretamente com o valor numérico; portanto, i4 automaticamente as caixas e converte -o para o valor INT 40. Finalmente, essa instrução é convertida em 40 == 40 para comparação numérica.
Classe de string e piscina constante
1.Como criar um objeto de string
String s1 = "abdcd"; string s2 = new String ("abcd"); System.out.println (s1 == S2); // falseExistem diferenças nos métodos de criação dessas duas maneiras diferentes. O primeiro é levar objetos no pool constante, e o segundo é criar novos objetos no espaço da memória da heap.
Basta usar novos objetos será criado na pilha.
2. Expressão de conexão+
(1). Somente novos objetos gerados pela conexão "+" entre os objetos da string criados usando "" contendo texto será adicionado ao pool constante da string.
(2). Para outros formulários, como duas referências de objeto que estão diretamente conectadas através de "+" ou objetos criados através do novo modo, os novos objetos resultantes não serão adicionados ao pool constante de string.
String str1 = "str"; string str2 = "ing"; String str3 = "str" + "ing"; string str4 = str1 + str2; system.out.println (str3 == str4); // false string str5 = "string"; system.out.println (str3 == str5); // true
Public Static Final String A = "AB"; // Constant Apublic Static Final String B = "CD"; // constante bpublic static void main (string [] args) {string s = a + b; // inicializa s com + string de concatenação t = "abcd"; if (s == t) {System.out.println ("s é igual a t, eles são o mesmo objeto"); } else {System.out.println ("S não é igual a t, eles não são o mesmo objeto"); }} s é igual a t, eles são o mesmo objetoA e B são constantes e os valores são fixos; portanto, o valor de S também é fixo, o que é determinado quando a classe é compilada. Em outras palavras: string s = a+b; equivalente a: string s = ”ab”+”cd”;
string final estática pública a; // Constant Apublic Static Final String B; // constante bstatic {a = "ab"; B = "cd"; } public static void main (string [] args) {// inicialize s com + string de concatenação s = a + b; String t = "ABCD"; if (s == t) {System.out.println ("s é igual a t, eles são o mesmo objeto"); } else {System.out.println ("S não é igual a t, eles não são o mesmo objeto"); }} s não é igual a t, eles não são o mesmo objetoEmbora A e B sejam definidos como constantes, nenhum deles é atribuído imediatamente. Antes de calcular o valor de S, quando eles são atribuídos e que valor são atribuídos são variáveis. Portanto, antes que A e B sejam atribuídos, suas propriedades são semelhantes a uma variável. Então S não pode ser determinado durante o período de compilação, mas só pode ser criado em tempo de execução.
3.Strings1 = Newstring ("XYZ"); Quantos objetos foram criados?
Considere a fase de carregamento da classe e a execução real.
(1) O carregamento da classe será realizado apenas uma vez em uma classe. "XYZ" é criado e residiu quando a classe é carregada (se a string "xyz" for residida antes da carga da classe, não há necessidade de criar repetidamente a instância "XYZ" para residir). A string residida é colocada em um pool constante de string compartilhado globalmente.
(2) Quando esse código for executado posteriormente, a instância da string correspondente ao literal "xyz" é fixa e não será criada repetidamente. Portanto, este código copia uma cópia do objeto no pool constante e o coloca na pilha e entrega a referência ao objeto na pilha para S1 para segurar.
Esta afirmação cria 2 objetos.
4.java.lang.string.intern ()
Outra característica importante do pool constante de tempo de execução em comparação com o arquivo constante de arquivo de classe é sua dinamicidade. O idioma Java não exige que as constantes sejam geradas apenas durante o período de compilação, ou seja, o conteúdo do pool constante no arquivo de classe pode entrar na área do método. Novas constantes também podem ser colocadas na piscina durante o tempo de execução. Esse recurso é mais comumente usado pelos desenvolvedores. O método intern () da classe String.
O método intern () de string descobrirá se há uma série de igual igual no pool constante. Se houver, ele retornará uma referência à string. Se não houver, ele adicionará sua própria string ao pool constante.
public static void main (string [] args) {string s1 = new String ("Computer"); String s2 = s1.intern (); String s3 = "computador"; System.out.println ("S1 == S2?" + (S1 == S2)); System.out.println ("S3 == S2?" + (S3 == S2));}s1 == S2? Falses3 == S2? verdadeiro
Resumir
O exposto acima é sobre explorar piscinas constantes de java em profundidade. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la.