equals en Java

Compara texto String con equals para que las palabras coincidentes impriman true. En Yard.java, escribe String a = "red"; y String b = "red";, luego imprime a.equals(b). Añade String c = "blue"; e imprime a.equals(c). Compila con javac Yard.java y ejecuta java Yard. La pantalla debe mostrar true, luego false. Una segunda demo construye dos objetos new String("red") para que == pueda imprimir false mientras equals sigue imprimiendo true. Deja debugging para la pagina siguiente — esta leccion es coincidencia de contenido frente a identidad de objeto.

Coincide el texto con equals

La pagina de polimorfismo ejecuto cuerpos horn distintos a traves de variables tipadas Machine. Esta pagina compara texto. Abre Yard.java. Mantén el nombre de clase publica Yard. Borra demos sobrantes de Machine / Truck / Car si entierran la historia de cadenas, rellenos abstract sobrantes, demos de ruta y cualquier Scanner de teclado. El programa no debe esperar que escribas. No necesitas linea import para estas demos.
Dentro de Yard.main, construye tres cadenas:
String a = "red";
String b = "red";
String c = "blue";
Imprime las comparaciones:
System.out.println(a.equals(b));
System.out.println(a.equals(c));
El metodo equals mira los caracteres. El mismo texto devuelve true. Texto distinto devuelve false.

Desde la carpeta que guarda Yard.java, ejecuta javac Yard.java. Cuando parentesis, llaves y puntos y coma coinciden, javac no escribe una linea propia. Luego ejecuta java Yard — no java Yard.java. Quita la extension .java del comando de ejecucion. Mantén una clase publica en el archivo para que el nombre coincida con Yard.
La pantalla muestra true, luego false. Recorre la ejecucion una vez. Java empieza en Yard.main. a.equals(b) compara red con red e imprime true. a.equals(c) compara red con blue e imprime false. Llamaste un metodo sobre a y pasaste la otra cadena como argumento.
Si aun ves tone / honk / beep de un archivo de polimorfismo, cambia al archivo de enseñanza equals y ejecuta java Yard de nuevo. Si imprimes las cadenas mismas en vez de los resultados de equals, veras red y blue en la pantalla — envuelve a.equals(b) dentro de println para que aparezca el boolean.
Di la regla en voz alta mientras miras la pantalla: equals pregunta si el texto coincide caracter a caracter. No inventes una ventana de debugger en esta pagina. Debugging espera la siguiente leccion.

Contrasta == con equals en new String

Un segundo programa construye dos objetos String separados con new. Ambos guardan el texto red. El programa imprime a == b y luego a.equals(b).

Compila con javac Yard.java, luego ejecuta java Yard. La pantalla muestra false, luego true. La comprobacion == pregunta si a y b son exactamente el mismo objeto en memoria. Dos llamadas new String("red") construyen dos objetos, asi que == imprime false. La comprobacion equals sigue mirando los caracteres, asi que imprime true.
Lee las dos lineas en main una vez mas. Primera linea: identidad con ==. Segunda linea: contenido con equals. Mantén ambas impresiones para esta forma de enseñanza para que el contraste quede en una sola pantalla. Si solo imprimes ==, pierdes la coincidencia de contenido que esta pagina tambien enseña.
En literales de principiante como "red" sin new, Java puede reutilizar el mismo objeto pooled, asi que == a veces parece true por accidente. Esta segunda demo usa new String("red") a proposito para que la comprobacion de identidad se quede claramente en false mientras el contenido se queda en true. Prefiere equals cuando te importa el texto.
Si demos de polimorfismo sobrantes siguen cerca, guardalas como historia. Para esta leccion ejecuta el archivo de enseñanza equals para que la pantalla muestre booleanos, no palabras horn. Si javac se queja de clases publicas duplicadas, mantén solo Yard public.

Comparado con llamadas de polimorfismo

En la pagina de polimorfismo, un nombre de metodo ejecuto cuerpos distintos a traves de variables tipadas padre. En esta pagina, un nombre de metodo — equals — responde si dos cadenas guardan el mismo texto, y == responde si son el mismo objeto. Sigues compilando Yard.java y ejecutando java Yard. Los tokens nuevos son equals, las impresiones boolean true / false, y el contraste == con new String.
Si un archivo sobrante Machine t = new Truck() sigue abierto, veras llamadas horn. Cambia al archivo equals para que main construya cadenas e imprima resultados de comparacion. Mantén demos de herramientas de debugging fuera de esta pagina. Mantén la entrada de teclado fuera de esta pagina.

Lo que esta pagina deja para debugging

Esta pagina compara el contenido de cadenas y muestra por que == es el valor por defecto equivocado para texto. La pagina siguiente muestra debugging, donde descubres por que un programa se comporta mal con lecturas cuidadosas de la pantalla y del fuente. Quedate con equals y == aqui. Aun no exijas un recorrido completo de debugger.
Cuando mas adelante depuras una rama incorrecta, un fallo de equals es una causa comun. Trata esta pagina como la mitad de comparacion de esa historia vecina. Termina ambas demos Yard hasta que true / false y false / true se sientan automaticos antes de abrir la leccion de debugging.

Antes de debugging

Puedes llamar a.equals(b) sobre texto red coincidente y ver true, luego ver false para blue. Puedes construir dos objetos new String("red") y ver que == imprime false mientras equals imprime true. Compila Yard.java y ejecuta java Yard para cada demo guardada por turno. La coincidencia de contenido y la identidad de objeto se mantuvieron separadas. La pagina siguiente es debugging, donde cazas errores con la pantalla y el fuente lado a lado.
Mantén la demo de tres cadenas con equals para una comprobacion clara de contenido. Mantén la demo new String para un contraste claro de ==. Mantén archivos de debugging fuera de esta pagina. Esos tres habitos son el punto de control antes de avanzar. Cuando equals imprime true para texto coincidente — y cuando == imprime false para dos objetos nuevos con ese texto — esta leccion hizo su trabajo y estas listo para el siguiente tema sobre debugging.
Una ultima pasada por la carpeta: un Yard publico, comparaciones de cadenas en main, sin espera de teclado, sin debugger forzado. Ejecuta javac Yard.java y java Yard una vez mas en la demo que mantienes abierta. Si la pantalla sigue imprimiendo los booleanos que esperas, la historia de comparacion es solida y el curso puede pasar a debugging en la pagina siguiente.