-
s = new String("xyz"); Quantos objetos String são criados dois objetos, um é "xyx" e o outro é o objeto de referência apontando para "xyx".
String s="Hello";int i=3; s=i+s; Esta expressão está correta? Porque string é uma classe! Abordagem correta: s+="3" ou s+='3' ou s+=(char)i;
Apresentaremos outra maneira de criar objetos String - texto entre aspas. Este método é exclusivo de String e é muito diferente do novo método.
Há um pool de strings na Máquina Virtual JAVA (JVM), que armazena muitos objetos String e pode ser compartilhado, melhorando a eficiência. String a="abc";, quando esta linha de código é executada, a máquina virtual JAVA primeiro pesquisa o conjunto de strings para ver se tal objeto com o valor "abc" já existe. A base para julgamento é String class equals(Object). obj) O valor de retorno do método. Se houver, nenhum novo objeto será criado e uma referência ao objeto existente será retornada diretamente; caso contrário, o objeto será criado primeiro, depois adicionado ao conjunto de strings e então sua referência será retornada;
Criação de objetos string: Devido ao uso extensivo de objetos string [é um objeto, de modo geral, os objetos sempre alocam memória no heap], em Java, a fim de economizar espaço de memória e tempo de execução [como ao comparar strings, == é melhor que equals()], todos os literais de string são colocados em um pool de literais durante a fase de compilação, e o pool de literais de tempo de execução torna-se parte do pool de constantes. A vantagem do pool literal é que todas as mesmas constantes de string no pool são mescladas e ocupam apenas um espaço. Sabemos que para duas variáveis de referência, utilize == para determinar se seus valores [referências] são iguais, ou seja, apontam para o mesmo objeto:
Agora observe a instrução String s = new String("abc"); Aqui, o próprio "abc" é um objeto no pool e, quando new String() é executado em tempo de execução, uma cópia do objeto no pool é colocada. na pilha e entregue a referência deste objeto na pilha para s. ok, esta instrução cria 2 objetos String.
String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //Instrução que não será executada}
//Quantos objetos String foram criados [Três, um no pool e dois no heap. ]
Somente novos objetos gerados pela conexão "+" entre objetos String criados usando aspas para incluir texto serão adicionados ao pool de strings. Para todas as expressões de conexão "+" que contêm novos objetos criados no novo método (incluindo nulo), os novos objetos que elas geram não serão adicionados ao conjunto de strings.
1.== significa que eles são referenciados no mesmo objeto e equals() significa que os valores são iguais.
String str1 = "abc"; o objeto referenciado está na pilha (ou pool de String).
String str1 =new String ("abc"); O objeto referenciado está na memória/heap.
2.String str1 = "string";
String str3 = "str";
String str4 = "ing";
String str2 = str3+str4; no heap, porque a função do sinal + é retornar outro objeto String recém-criado em vez de procurar o valor da string na pilha. Se for String str2 = "str"+"ing" então o resultado final está na pilha. str1==str2 é verdadeiro.
Mas há uma situação que exige a nossa atenção. Por favor, veja o código abaixo:
classe pública StringStaticTest {
public static final String A = "ab" // constante A;
public static final String B = "cd" // constante B;
public static void main(String[] args) {
String s = A + B; // Inicialize s conectando as duas constantes com +
String t = "abcd";
se (s == t) {
System.out.println("s é igual a t, são o mesmo objeto");
} outro {
System.out.println("s não é igual a t, eles não são o mesmo objeto");
}
}
}
O resultado da execução deste código é o seguinte:
s é igual a t, eles são o mesmo objeto
A razão é que no exemplo acima, A e B são constantes e seus valores são fixos, portanto o valor de s também é fixo e foi determinado quando a classe é compilada. Ou seja: String s=A+B é equivalente a: String s="ab"+"cd";
Deixe-me mudar um pouco o exemplo acima e ver o que acontece:
classe pública StringStaticTest {
public static final String A; // constante A;
public static final String B // constante B;
estático {
A = “ab”;
B = “cd”;
}
public static void main(String[] args) {
// Inicializa s conectando as duas constantes com +
Sequência s = A + B;
String t = "abcd";
se (s == t) {
System.out.println("s é igual a t, são o mesmo objeto");
} outro {
System.out.println("s não é igual a t, eles não são o mesmo objeto");
}
}
}
O resultado de seu funcionamento é este:
s não é igual a t, eles não são o mesmo objeto
Acabei de fazer uma pequena alteração e o resultado é exatamente o oposto do exemplo agora. Vamos analisar novamente. Embora A e B sejam definidos como constantes (só podem ser atribuídos uma vez), eles não são atribuídos imediatamente. Antes de o valor de s ser calculado, quando eles são atribuídos e qual valor eles são atribuídos são todas variáveis. Portanto, A e B se comportam como uma variável antes de receberem um valor. Então s não pode ser determinado em tempo de compilação, mas só pode ser criado em tempo de execução.
Por fim, vamos falar sobre o armazenamento de objetos String na Máquina Virtual JAVA (JVM) e o relacionamento entre o pool de strings e o heap e a pilha. Vamos primeiro revisar a diferença entre heap e pilha:
Pilha: salva principalmente tipos básicos (ou tipos integrados) (char, byte, short, int, long, float, double, boolean) e referências de objetos. Os dados podem ser compartilhados e sua velocidade perde apenas para o registro. pilha.
Heap: usado para armazenar objetos.
Quando olharmos o código-fonte da classe String, descobriremos que ele possui um atributo value, que armazena o valor do objeto String. O tipo é char[], o que também mostra que uma string é uma sequência de caracteres. Ao executar String a="abc";, a máquina virtual JAVA cria três valores de char 'a', 'b' e 'c' na pilha e, em seguida, cria um objeto String no heap, seu valor (value ) é uma matriz de três valores char recém-criados na pilha {'a', 'b', 'c'} Finalmente, o objeto String recém-criado será adicionado ao conjunto de strings.
Se executarmos o código String b=new String("abc"); , uma vez que "abc" foi criado e salvo no pool de strings, a máquina virtual JAVA criará apenas um novo objeto String no heap, mas será o The. valor são os três valores do tipo char 'a', 'b' e 'c' criados na pilha quando a linha de código anterior foi executada.
Neste ponto, já estamos bastante claros sobre a questão de por que String str=new String("abc") levantada no início deste artigo cria dois objetos.
Este artigo vem do blog CSDN. Indique a fonte ao reimprimir: http://blog.csdn.net/yakihappy/archive/2009/03/10/3977169.aspx.
Este artigo vem do blog CSDN. Indique a fonte ao reimprimir: http://blog.csdn.net/Foxalien/archive/2009/12/18/5029470.aspx.
-