Os tipos de dados em Java podem ser divididos em duas categorias:
1. Tipos de dados básicos, também chamados de tipos de dados primitivos. Para comparar byte, short, char, int, long, float, double, boolean, use o sinal de igual duplo (==) e compare seus valores.
2. Tipos de dados compostos (classes) Quando comparados usando (==), eles são comparados com seus endereços de armazenamento na memória. Portanto, a menos que sejam o mesmo novo objeto, o resultado de sua comparação é verdadeiro, caso contrário, a comparação. resultado é falso. Todas as classes em JAVA herdam da classe base Object. A classe base em Object define um método equals. O comportamento inicial deste método é comparar os endereços de memória dos objetos. , Inteiro e Data, igual a tem sua própria implementação nessas classes, em vez de comparar o endereço de armazenamento da classe na memória heap. Para comparação igual entre tipos de dados compostos, sem substituir o método equals, a comparação entre eles ainda é baseada no valor do endereço de seu local de armazenamento na memória, porque o método equals de Object também usa um sinal de igual duplo (==) é comparado , então o resultado da comparação é igual ao resultado do duplo sinal de igual (==).
Copie o código do código da seguinte forma:
classe pública TestString {
publicstaticvoid principal(String[] args) {
String s1="Segunda-feira";
String s2="Segunda-feira";
se (s1 == s2)
{
System.out.println("s1 == s2");}
outro{
System.out.println("s1!=s2");}
}
}
Compile e execute o programa, saída: s1 == s2 Nota: s1 e s2 referem-se ao mesmo objeto String - "Monday" 2. Se você alterar um pouco o programa, encontrará algo ainda mais estranho:
Copie o código do código da seguinte forma:
classe pública TestString {
publicstaticvoid principal(String[] args)
{
String s1="Segunda-feira";
String s2 =new String("Segunda-feira");
if (s1 == s2) {System.out.println("s1 == s2");
}
outro
{
System.out.println("s1!=s2");
}
se (s1.é igual(s2))
{
System.out.println("s1 é igual a s2");
}
outro
{
System.out.println("s1 não é igual a s2");
}
}
}
Usamos o operador new para criar a saída do programa para s2: s1 != s2 s1 é igual a s2 Nota: s1 e s2 referem-se a dois objetos String "Segunda-feira", respectivamente.
3. Buffer pool de string Acontece que o programa criará um buffer pool de string quando estiver em execução. Ao usar uma expressão como s2 = "Monday" para criar uma string, o programa primeiro procurará o mesmo valor na String. pool de buffers, no primeiro programa, s1 foi colocado primeiro no pool, então quando s2 foi criado, o programa encontrou s1 com o mesmo valor e referenciou s2 ao objeto "segunda-feira" referenciado por s1. Usado novo operador, ele diz claramente ao programa: "Eu quero um novo! Não o antigo!" Então, um novo objeto Sting "Monday" é criado na memória. Seus valores são os mesmos, mas suas localizações são diferentes, um está nadando na piscina e o outro descansando na praia. Ops, que desperdício de recursos. Por que temos que separá-los quando são obviamente iguais?
4. Altere o programa novamente:
Copie o código do código da seguinte forma:
classe pública TestString
{
publicstaticvoid principal(String[] args)
{
String s1="Segunda-feira";
String s2 =new String("Segunda-feira");
s2 = s2.interno();
se (s1 == s2)
{
System.out.println("s1 == s2");
}
outro
{
System.out.println("s1!=s2");
}
se (s1.é igual(s2))
{
System.out.println("s1 é igual a s2");
}
outro
{
System.out.println("s1 não é igual a s2");
}
}
}
Desta vez adicionado: s2 = s2.intern() Saída do programa: s1 == s2 s1 igual a s2; Acontece que (método intern() "abc" de (java.lang.String). O valor de retorno do método intern() ainda é a string "abc". Superficialmente, parece que esse método é inútil. Mas na verdade, ele faz um pequeno truque: verifique se existe uma string "abc" no pool de strings. Se existir, retorne a string no pool, se não existir, este método adicionará "abc" à string; pool e depois devolvê-lo citação.)
