É o método assertEquals de Java confiável?

Question

Eu sei que == tem alguns problemas quando se comparam dois Strings. Parece que String.equals() é uma abordagem melhor. Bem, eu estou fazendo testes JUnit e minha inclinação é usar assertEquals(str1, str2). Será esta uma maneira confiável para afirmar duas cordas contêm o mesmo conteúdo? Gostaria de usar assertTrue(str1.equals(str2)), mas então você não obter o benefício de ver o que os valores previstos e reais estão em fracasso.

Em uma nota relacionada, alguém tem um link para uma página ou segmento que claramente explica os problemas com str1 == str2?

Answer 1

Você deve sempre uso .equals() ao comparar Strings em Java.

JUnit chama o método .equals() para determinar a igualdade no assertEquals(Object o1, Object o2) método.

Então, você está definitivamente segura usando assertEquals(string1, string2). (Porque Strings são Objects)

Aqui está um link para uma grande questão Stackoverflow em relação a algumas das diferenças entre == e .equals().

Answer 2

assertEquals usa o método equals para comparação. Há um assert diferente, assertSame, que usa o operador ==.

Para entender por que == não deve ser utilizado com cordas você precisa entender o que == faz: ele faz uma verificação de identidade. Ou seja, verifica a == b para ver se a e b referem-se ao mesmo objeto . Ele é construído dentro da linguagem, e seu comportamento não pode ser alterado por diferentes classes. O método equals, por outro lado, pode ser substituído por classes. Enquanto seu comportamento padrão (na classe Object) é fazer uma verificação de identidade usando o operador ==, muitas classes, incluindo String, substituí-lo em vez disso, fazer uma verificação de "equivalência". No caso de String, em vez de verificar se a e b se referem ao mesmo objeto, cheques a.equals(b) para ver se os objetos a que se referem são os dois strings que contêm exatamente os mesmos caracteres.

tempo analogia: imagine que cada objeto String é um pedaço de papel com algo escrito nele. Digamos que eu tenho dois pedaços de papel com "Foo" escrito sobre eles, e outro com "Bar" escrito nele. Se eu tomar os dois primeiros pedaços de papel e uso == para compará-los ele irá retornar false porque está essencialmente perguntando "são estes o mesmo pedaço de papel?". Ele não precisa olhar ainda para o que está escrito no papel. O fato de que eu estou dando-lhe dois pedaços de papel (em vez do mesmo duas vezes) significa que ele irá retornar false. Se eu usar equals, no entanto, o método equals lerá os dois pedaços de papel e ver que eles dizem a mesma coisa ( "Foo"), e por isso vai voltar true.

O pouco que fica confuso com cordas é que o Java tem um conceito de "internar" Cordas, e isso é (efetivamente) realizada automaticamente em qualquer strings literais em seu código. Isto significa que se você tem duas strings literais equivalentes em seu código (mesmo se eles estão em diferentes classes) eles realmente se referem tanto ao mesmo objeto String. Isso faz com que o operador == retorno true mais frequentemente do que se poderia esperar.

Answer 3

Em poucas palavras - você pode ter dois objetos String que contêm os mesmos personagens, mas são objetos diferentes (em diferentes posições de memória). Os == operador verifica para ver que duas referências estão apontando para o mesmo objeto (local de memória), mas os equals () método verifica se os personagens são os mesmos.

Normalmente, você está interessado em verificar se dois strings contêm os mesmos personagens, não se eles apontam para o mesmo local de memória.

Answer 4

Sim, ele é usado o tempo todo para o teste. É muito provável que os usos framework de testes .equals () para comparações como essas.

Abaixo está um link explicando a "string igualdade erro". Essencialmente, strings em Java são objetos, e quando você comparar a igualdade objeto, normalmente eles são comparados com base no endereço de memória, e não pelo conteúdo. Devido a isso, duas cordas não vai ocupar o mesmo endereço, mesmo se o seu conteúdo é idêntico, de modo que não irá corresponder corretamente, mesmo que eles têm a mesma aparência quando impresso.

http: //blog.enrii. COM / 2006/03/15 / java-corda-igualdade-common-engano /

Answer 5

public class StringEqualityTest extends TestCase {
    public void testEquality() throws Exception {
        String a = "abcde";
        String b = new String(a);
        assertTrue(a.equals(b));
        assertFalse(a == b);
        assertEquals(a, b);
    }
}

Answer 6

O assertEquals(obj1, obj2) JUnit faz obj1.equals(obj2) fato chamada.

Há também assertSame(obj1, obj2) que faz obj1 == obj2 (ou seja, verifica que obj1 e obj2 estão fazendo referência a mesma instância), que é o que você está tentando evitar.

Então, você está bem.

Answer 7

"cheques O operador == para ver se dois Objects são exatamente os mesmos Object."

http://leepoint.net/notes-java/data/strings /12stringcomparison.html

String é um Object em java, por isso cai nessa categoria de regras de comparação.