I'tenho utilizado o operador ==
no meu programa para comparar todas as minhas cordas até agora.
Entretanto, eu encontrei um bug, mudei uma delas para .igual()
ao invés disso, e ele corrigiu o bug.
É ==
mau? Quando deve e não deve ser usado? Qual'é a diferença?
==
testes de igualdade de referência (se são o mesmo objeto).
.igual()
testes para igualdade de valor (se são logicamente "igual").
Objects.equals() verifica se há null
antes de chamar .equals()
para que você não't precise (disponível a partir de JDK7, também disponível em Guava).
String.contentEquals() compara o conteúdo da String
com o conteúdo de qualquer CharSequence
(disponível desde Java 1.5).
Consequentemente, se você quiser testar se duas cordas têm o mesmo valor, você provavelmente vai querer utilizar Objects.equals()
.
// These two have the same value
new String("test").equals("test") // --> true
// ... but they are not the same object
new String("test") == "test" // --> false
// ... neither are these
new String("test") == new String("test") // --> false
// ... but these are because literals are interned by
// the compiler and thus refer to the same object
"test" == "test" // --> true
// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true
// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true
Você quase sempre quer utilizar Objects.equals()
. Na rare situação em que você **know** you're dealing with interned strings, você pode* utilizar ==
.
De JLS 3.10.5. Literais de Cordas:
Além disso, uma string refere-se sempre literalmente à instância same da classe
String'. Isto porque strings literais - ou, mais geralmente, strings que são os valores de expressões constantes ([§15.28](https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.28)) - são "interned" de modo a compartilhar instâncias únicas, utilizando o método
String.intern`.
Exemplos similares também podem ser encontrados em JLS 3.10.5-1.
Sim, ==
é ruim para comparar Strings (quaisquer objetos realmente, a menos que você saiba que eles're canônico). ==`` apenas compara referências de objetos.
.equals()` testes para igualdade. Para Strings, muitas vezes eles'serão os mesmos, mas como você'descobriu, isso'não é sempre garantido.
**===
compara referências de objectos em Java***, e isso não é excepção para objectos String
.
Para comparar o conteúdo real dos objetos (incluindo 'String'), deve-se utilizar o método 'igual'.
Se uma comparação de dois objetos String
utilizando ==
se revelar verdadeiro
, isto é porque os objetos String
foram internados, e a Máquina Virtual Java está tendo múltiplas referências apontando para a mesma instância de String
. Não se deve esperar que a comparação de um objeto String
contendo o mesmo conteúdo que outro objeto String
utilizando ==
para avaliar como verdadeiro
.