¿Es confiable el método afirmativo de Java?

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 forma confiable de afirmar que dos cadenas contienen el mismo contenido? yo usaríaassertTrue(str1.equals(str2)) , pero entonces no obtienes 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 explique claramente los problemas str1 == str2?

Usted debe siempre utilizar .equals()cuando se comparan Stringsen Java.

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

Entonces, definitivamente estás seguro de usar assertEquals(string1, string2). (Porque Strings son Objects)

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

assertEqualsusa el equalsmétodo de comparación. Hay una afirmación diferente assertSame, que utiliza el ==operador.

Para comprender por ==qué no debe usarse con cadenas, debe comprender lo que ==hace: hace una verificación de identidad. Es decir, a == bcomprueba para ver si ay se brefieren al mismo objeto . Está integrado en el lenguaje, y su comportamiento no puede ser cambiado por diferentes clases. El equalsmétodo, por otro lado, puede ser anulado por clases. Si bien su comportamiento predeterminado (en la Objectclase) es hacer una verificación de identidad utilizando el ==operador, muchas clases, incluso String, la anulan para hacer una verificación de "equivalencia". En el caso de String, en lugar de verificar si ay hacer breferencia al mismo objeto,a.equals(b) comprueba si los objetos a los que se refieren son cadenas que contienen exactamente los mismos caracteres.

Tiempo de analogía: imagine que cada Stringobjeto es un pedazo de papel con algo escrito en él. Digamos que tengo dos pedazos de papel con "Foo" escrito en ellos, y otro con "Bar" escrito en él. Si tomo los dos primeros trozos de papel y los uso ==para compararlos, se devolverá falseporque esencialmente se pregunta "¿son estos el mismo trozo de papel?". Ni siquiera necesita 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 volverá false. equalsSin embargo, si lo uso , el equalsmétodo leerá las dos hojas de papel y verá que dicen lo mismo ("Foo"), y así volverá true.

La parte que se confunde con las cadenas es que Java tiene un concepto de cadenas "internas", y esto (efectivamente) se realiza 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 Stringobjeto. Esto hace que el ==operador regrese con truemás frecuencia de lo que cabría esperar.

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.

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);
    }
}

Sí, se usa todo el tiempo para las 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, generalmente se comparan en función de la dirección de memoria y no por 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/

El JUnit assertEquals(obj1, obj2)sí llama obj1.equals(obj2).

También hay assertSame(obj1, obj2)qué hace obj1 == obj2(es decir, verifica eso obj1y hace obj2referencia a la misma instancia), que es lo que está tratando de evitar.

Entonces estás bien.

"El ==operador verifica si dos Objectsson exactamente iguales Object".

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

Stringes un Objecten java, por lo que cae en esa categoría de reglas de comparación.