java == operador

Question

Duplicar posibles:
Weird Java Boxing

Hola,

Puede alguien explicar por qué la última impresión vuelve falsa?

int a = 100; 
int b = 100; 

System.out.println(a == b); // prints true 

Integer aa = 100; 
Integer bb = 100; 

System.out.println(aa == bb); // prints true 

Integer aaa = 1000; 
Integer bbb = 1000; 

System.out.println(aaa == bbb); // prints false 

Gracias Michael

Answer 1

La razón por la cual la segunda impresión se evalúa como verdadera es porque los primeros 128 objetos de enteros están almacenados en caché por la clase de enteros. Quieres usar equals

Answer 2

Usted está comparando dos objetos Integer, que utilizando el operador == compara las dos referencias, en lugar de los dos valores.

Utilice el método equals() para asegurarse de que está comparando ambos valores.

Answer 3

Debe usar Integer.compareTo para probar la igualdad numérica para los objetos Integer. El operador == está comparando los objetos, no los números.

Answer 4

Los Integer objetos son autoboxed utilizando el método Integer.valueOf(int). Echa un vistazo a la documentación de ese método. Entonces todo debería quedar claro.

Answer 5

Lo que quiere que esté usando es aaa.equals(bbb). En Java utilizando == en objetos, se compara si son la misma instancia del objeto en lugar de si son iguales según su método equals().

Answer 6

Estoy sorprendido de que el segundo caso devuelva true. Pero por eso en Java Puzzlers aconsejan no mezclar el uso de las clases Wrapper y el operador ==.

Echa un vistazo a esta clase y código:

public class RichardInt { 
    private int value; 
    public RichardInt(int value) { 
     this.value = value; 
    } 
} 

¿Cuál sería el resultado de lo siguiente?

RichardInt aa = new RichardInt(100); 
RichardInt bb = new RichardInt(100); 
System.out.println(aa == bb); // prints false 

Imprime falsa debido a que el operador igual == compara referencias cuando se utiliza con objetos. Recuerde, en Java, los objetos son tipos de referencia, mientras que las primitivas (como int) son tipos de valores. (Nota: puede alguien que me haga saber si estoy haciendo mal uso "tipo de valor" Tengo la sensación de que soy yo?). El siguiente imprimiría cierto:

RichardInt aa = new RichardInt(100); 
RichardInt bb = aa; 
System.out.println(aa == bb); // prints true 

... desde aa y bb referencia la misma instancia de RichardInt.

Así que tal vez el comportamiento anterior sea más fácil de entender en el siguiente ejemplo ...

Intger aaa = new Intger(1000); 
Intger bbb = new Integer(1000); 
System.out.println(aaa == bbb); // prints false 

En versiones más recientes de Java, las clases de envoltura (Integer y Float y Boolean etc ...) puede auto-caja, lo que significa que puede hacer lo siguiente:

Integer aa = 1000; 
// this is a shorthand for... 
// Integer aa = new Integer(1000); 

Pero lleva a un comportamiento confuso cuando intenta cosas como esta:

Integer aaa = 1000; 
Integer bbb = 1000; 
System.out.println(aaa == bbb); // prints false 

O mejor aún, se puede acabar con los rompecabezas como éste ...

// what values of x and y will result in output? 
if(!(x<y)&&!(x>y)&&!(x==y)) { 
    System.out.println("How is this possible?"); 
} 

Al final, cada vez que se trata de objetos, tendrá que utilizar en lugar de .equals()==.

Integer aaa = 1000; 
Integer bbb = 1000; 
System.out.println(aaa.equals(bbb)); // prints true