Java - EQuals o ==?

No sé la diferencia entre ambos, me funcionan exactamente igual.

Estoy usando java 1.6.

Gracias.

hola..mira..yo ..soy un poco novato.pero esa pregunta ya la habia hecho..y me respondiron esto..

Si quieres saber si dos objetos Strings diferentes s1 y s2 tienen los mísmos carácteres, usa s1.equals(s2) que devuelve true si son iguales, porque compareTo lo que hace es la comparación lexicográfica, devolviendo si la primera es menor un entero negativo, cero en caso de igualdad, y un entero positivo si es mayor; el operador == solo te dirá si ámbos operadores son una referencia al mísmo objeto.

lo que yo habia leido por ahi..es que equals es para comparacion de objetos..mientras que == no lo es....

si tienes algo mas claro....porfa me escribes..
[email protected]

A ver, es muy sencillo.

Si tenemos esta situación:
String s1 = new String("hola");
String s2 = new String("hola");
String s3 = s2;

Aquí tenemos 3 variables: s1, s2 y s3. Si queremos saber si dos variables representan _el_mismo_objeto_, usamos ==. Esto es aplicable para cualquier tipo de objeto.

if (s1 == s2) ...
esto devuelve false, porque s1 y s2 son objetos distintos. Hemos creado s1 como una new String y luego s2 como otra new String.

if((s2 == s3) ...
esto devuelve true porque s2 y s3 realmente representan el mismo objeto (fíjate que hemos creado s3 asignándole s2 directamente, así que está claro que son el mismo objeto.

Ahora, tenemos en cuenta que los objetos que tenemos son String, y decidimos que lo que queremos saber no es si son el mismo objeto, sino si la cadena de texto que contienen es la misma. Entonces, para esto, String tiene un método llamado equals.

if (s1.equals(s2)) ...
Esto, al contrario que antes con ==, devuelve true, porque aunque no sea el mismo objeto, las cadenas que contienen sí que son iguales.

Hay que pensar que un objeto String es _más_ que la cadena que contiene. Es esa cadena y toda una serie de propiedades y métodos asociados al objeto. Por eso no es lo mismo comparar los objetos que sus valores.


--------------------------------------------------
compareTo. Este método va más allá de equals y sólo lo usaremos si realmente hace falta.
Es decir, equals sólo compara si son iguales o no. devuelve true o false y nada más. compareTo se usa cuando no sólo queremos saber si tienen el mismo valor, sino cuál es "mayor" o "menor".
Si hablamos de cadenas, "mayor" y "menor" se refieren a cuál va antes por órden alfabético.
Si sólo nos interesa saber si son iguales o distintas, usamos equals. Si necesitamos saber cuál es menor o mayor, usamos compareTo.

A ver, para comparar objetos...
equals sirve para comparar el valor de dichos objetos.
== compara la referencia... es decir si ambas referencias( nombres de los objetos) apuntan a la misma direccion de memoria.
Es decir si tengo:
MiObjeto o1=new MiObjeto();
MiObjeto o2=new MiObjeto();
o1==o2 devolvera false.
Si hago o1=o2
o1==o2 devolvera true
y si modificamos los atributos de o2 tb modificamos los de o1... pues apuntan al mismo objeto en memoria.
A la hora de comparar strings por tanto normalmente no buscamos realizar s1==s2. Puesto que nosotros lo que queremos es saber si s1 y s2 tienen la misma cadena, no si apuntan al mismo objeto.
Para comparar por valor existe la funcion equals... de la clase object, es decir utilizable por cualquier objeto... si se sobreescribe.
La clase String sobreescribe la funcion equals, para que devuelva si es igual mediante la comparacion lexicografica de las cadenas que contienen.
Las clases envolventes(Integer y demas) creo que tambien tienen sobreescrito el 'equals'.
Un ejemplo:
public class MiObjeto{
int miAtributo;
public int getMiAtributo(){
return miAtributo;
}
public void setMiAtributo(int valor){
this.miAtributo=valor;
}
public boolean equals(MiObjeto nuevo){
return(miAtributo==nuevo.getMiAtributo);
}

}
Con esta clase de ejemplo, veamos un poco de codigo.
MiObjeto o1=new MiObjeto();
MiObjeto o2=new MiObjeto();
o1.setMiAtributo(2);
o2.setAtributo(1);
o1==o2-->false
o1.equals(o2)-->false
o1.setMiAtributo(4);
o2.setAtributo(4);
o1==o2-->false
o1.equals(o2)-->true
o1=o2;//Son el mismo objeto
o1==o2-->true
o1.equals(o2)-->true
o1.setMiAtributo(1);
o2.setAtributo(4);
o1==o2-->true
o1.equals(o2)-->true(Los dos tienen valor 4... puesto que al ser el mismo objeto... tener identica referencia, si varias uno, varias el otro).


Por eso si haces String s1=new String();
String s2=new String();
s1="perro";
s2="perro";
s1==s2 es false.
s1.equals(s2) es true
Ahora, hay que tener cuidado con los ejemplos con String, pues es clase final.
Eso quiere decir...
s1="perro";
s1="hola";//No estamos cambiando el valor del string. Si no que estamos destruyendo el objeto anterior para crear uno nuevo, aunque a efectos practicos sea lo mismo.
Es final, no puede reasignarse un valor...
Espero haberme explicado con claridad. Saludos

Hola,

Lo que te dice Franco es erroneo. Es un error muy común.

Ll método equals de String lo usas cuando vas a comparar cadenas de texto y el == cuando comparas objetos (instancias de clases).

Es mejor que uses cada una de manera correcta sino te acarriara problemas.

Saludos