Java: ¿Es confiable assertEquals (String, String)?

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 assertEquals(str1, str2). ¿Es esta una manera confiable de afirmar que dos cadenas contienen el mismo contenido? 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 falla.

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

Answer 1

Usted debe siempre uso .equals() al comparar 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á seguro usando assertEquals(string1, string2). (porque String s son Object s)

Here is a link to a great Stackoverflow question con respecto a algunas de las diferencias entre == y .equals().

Answer 2

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

A continuación se muestra un enlace que explica el "error de igualdad de cadenas". Básicamente, las cadenas en Java son objetos, y cuando se compara la igualdad de objetos, generalmente se comparan en función de la dirección de la memoria y no del 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 tengan el mismo aspecto cuando se impriman.

http://blog.enrii.com/2006/03/15/java-string-equality-common-mistake/

Answer 3

"Los == operador comprueba para ver si dos Objects son exactamente los mismos 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.

Answer 4

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 5

El JUnit assertEquals(obj1, obj2) en efecto llamar obj1.equals(obj2).

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

Así que estás bien.

Answer 6

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

Por lo general, le interesa comprobar si dos cadenas contienen los mismos caracteres, no si apuntan a la misma ubicación de memoria.

Answer 7

assertEquals usa el método equals para comparar. Hay una afirmación diferente, assertSame, que utiliza el operador ==.

Para comprender por qué == no debe usarse con cadenas, necesita comprender lo que hace ==: realiza una comprobació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 modificado por diferentes clases. El método equals, por otro lado, puede ser anulado por clases. Si bien su comportamiento predeterminado (en la clase Object) es realizar una comprobación de identidad con el operador ==, muchas clases, incluido String, lo reemplazan para realizar una comprobación de "equivalencia" en su lugar. 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: imagine que cada objeto String es un trozo de papel con algo escrito en él. Digamos que tengo dos pedazos de papel con "Foo" escrito en ellos, y otro con "Barra" escrito en él. Si tomo las dos primeras hojas de papel y uso == para compararlas, devolverá false porque básicamente se está preguntando "¿son estas la misma hoja de papel?". No necesita ni siquiera mirar lo que está escrito en el papel. El hecho de que le doy dos hojas de papel (en lugar de la misma dos veces) significa que devolverá false. Si utilizo equals, sin embargo, el método equals leerá los dos trozos 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" Strings, y esto se realiza (efectivamente) automáticamente en cualquier literal de cadena 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 con más frecuencia de lo que cabría esperar.