¿Es confiable el método assertEquals de Java?

Question

Sé que == tiene algunos problemas al comparar dos Strings . Parece que String.equals () es un mejor enfoque. Bueno, estoy haciendo pruebas JUnit y mi inclinación es usar afirmarEquals (str1, str2) . ¿Es esta una forma confiable de afirmar que dos cadenas contienen el mismo contenido? Yo usaría assertTrue (str1.equals (str2)) , pero luego no obtiene el beneficio de ver cuáles son los valores esperados y reales en caso de error.

En una nota relacionada, ¿alguien tiene un enlace a una página o tema que explique claramente los problemas con str1 == str2 ?

Answer 1

Debería siempre usar .equals () cuando compare Strings en Java.

JUnit llama al método .equals () para determinar la igualdad en el método assertEquals (Object o1, Object o2) .

Por lo tanto, definitivamente estás seguro usando assertEquals (string1, string2) . (Porque los String s son Object s)

Aquí hay un enlace a una excelente pregunta sobre Stackoverflow con respecto a algunas de las diferencias entre == y .equals () .

Answer 2

assertEquals utiliza el método equals para la comparación. Hay una aserción diferente, assertSame , que utiliza el operador == .

Para entender por qué == no debe usarse con cadenas, debe comprender lo que hace == : hace una verificación de identidad. Es decir, a == b comprueba si a y b se refieren al mismo objeto . Está integrado en el lenguaje, y su comportamiento no puede ser cambiado por diferentes clases. El método es igual a , por otra parte, puede ser anulado por clases. Si bien su comportamiento predeterminado (en la clase Object ) es realizar una verificación de identidad con el operador == , muchas clases, incluida String , anulan para hacer una " equivalencia " comprobar. En el caso de String , en lugar de verificar si a y b se refieren al mismo objeto, a.equals (b) comprueba si los objetos a los que hacen referencia son cadenas que contienen exactamente los mismos caracteres.

Tiempo de analogía: imagina que cada objeto String es una hoja de papel con algo escrito. Digamos que tengo dos hojas de papel con " Foo " escrito en ellos, y otro con " Bar " escrito en él. Si tomo los dos primeros pedazos de papel y uso == para compararlos, devolverá false porque esencialmente se pregunta "¿estos son el mismo pedazo de papel? & Quot; . No necesita ni siquiera mirar lo que está escrito en el papel. El hecho de que le esté dando dos hojas de papel (en lugar de la misma dos veces) significa que devolverá false . Sin embargo, si uso es igual a , el método es igual a leerá las dos hojas de papel y verá que dicen lo mismo (" Foo "), por lo que ' Devolveré true .

El bit que se confunde con Strings es que Java tiene un concepto de " interning " Cadenas, y esto se realiza (efectivamente) automáticamente en cualquier cadena de literales en su código. Esto significa que si tiene dos literales de cadena equivalentes en su código (incluso si están en clases diferentes), ambos se referirán al mismo objeto String . Esto hace que el operador == devuelva true más a menudo de lo que uno podría esperar.

Answer 3

En pocas palabras: puede tener dos objetos de cadena que contienen los mismos caracteres pero son objetos diferentes (en diferentes ubicaciones de memoria). El operador == comprueba si dos referencias apuntan al mismo objeto (ubicación de memoria), pero el método equals () comprueba si los caracteres son iguales.

Por lo general, está interesado en verificar si dos cadenas contienen los mismos caracteres, no si apuntan a la misma ubicación de memoria.

Answer 4

Sí, se usa todo el tiempo para realizar pruebas. Es muy probable que el marco de prueba use .equals () para comparaciones como estas.

A continuación hay un enlace que explica el " error de igualdad de cadena " ;. Esencialmente, las cadenas en Java son objetos, y cuando se compara la igualdad de objetos, por lo general, se comparan según la dirección de la memoria y no por el contenido. Debido a esto, dos cadenas no ocuparán la misma dirección, incluso si su contenido es idéntico, por lo que no coincidirán correctamente, aunque se vean iguales cuando se imprimen.

http: //blog.enrii. com / 2006/03/15 / java-string-igualdad-error-común /

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

El JUnit afirmarEquals (obj1, obj2) llama a obj1.equals (obj2) .

También hay afirmarSame (obj1, obj2) que hace obj1 == obj2 (es decir, verifica que obj1 y obj2 hacen referencia a la misma instancia), que es lo que estás tratando de evitar.

Entonces estás bien.

Answer 7

  

" El operador == comprueba si dos Objects son exactamente el mismo Object . "

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

String es un Object en java, por lo que cae en esa categoría de reglas de comparación.