ahora no entiendo == equals

[aldo_rengo]

hola bueno....

estaba viendo lo de comparar, valores de tipo primitivo con objetos...

que objetos siempre deben compararse con equals()

INTEGER , STRING, son objetos, no ?....

y por lo tanto deberian compararse con equals();
en el caso de que los compare con el "=="

compararia la direccion de memoria a donde apunta, en java creo que no se puede manejar la direccion de memoria como puntero. osea comparo. a un lugar de memoria donde hace referencia...

pero en este ejemplo me confunde todo...

ya que le asigna el misma valor a 2 objetos distintos.. y al compararlos con "=="
da que son iguales...

Código PHP:

  public class Equivalencia4 {
   public static void main(String[] args) {
     Integer n1 = 47;
     Integer n2 = 47;
     Integer n3 = new Integer(47);
  
     System.out.println("n1==n2: "+(n1 == n2));
     System.out.println("n1!=n2: "+(n1 != n2));
     System.out.println("n1.equals(n2): "+n1.equals(n2));
     System.out.println("n1==n3: "+(n1 == n3));
     System.out.println("n1.equals(n3): "+n1.equals(n3));
 
     String s1 = "Hola";
     String s2 = "Hola";
 
     System.out.println("s1==s2: "+(s1 == s2));
     System.out.println("s1!=s2: "+(s1 != s2));
     System.out.println("s1.equals(s2): "+s1.equals(s2));
   }
}  
   

despues explica con algo como esto...

Cuando creamos n1 y le damos el valor 47, este valor se guarda en memoria (en la pila). Al crear una nueva variable con valor 47, en lugar de almacenar este valor en memoria, como ya existe, n2 apuntará al valor 47 que está en la pila. Entonces tenemos n1 y n2 apuntando a 47. Lo mismo ocurriría con s1 y s2. Por este motivo, en este ejemplo, las comparaciones tienen el mismo comportamiento para == (referencias) y equals() (valores). Sin embargo, si damos un nuevo valor a n1, n2, s1 o s2, las variables ya no apuntarán al mismo valor y serán de este modo diferentes, tanto para == como para equals(). Si nos fijamos en la variable n3, se crea con new Integer(47), si la comparamos con n1 o n2 el resultado es el siguiente: con == el resultado sería false, ya que al crear un nuevo objeto con new, se le asigna un nuevo espacio de memoria (en el cúmulo), por tanto no apuntaría al valor 47 de la pila, sin embargo, con equals() el comportamiento es el esperado ya que se comparan los valores y estos son iguales. Para recordar dónde se almacena cada tipo de variable, puedes repasar el Tema 2, el apartado Los lugares de almacenamiento.

es raro----

[chuidiang]

Hola:

El concepto general es correcto, == compara que dos objetos sean el mismo (misma zona de memoria) y equals(), que cada objeto puede definir a su gusto para saber si dos objetos distintos representan lo mismo o no.

El problema que planteas se debe al compilador. El compilador de java es listo y optimiza el código al compilarlo. Si tienes dos objetos Integer de valor 47 declarados de una forma tan inmediata (Integer a = 47;) el compilador creará un únicoi objeto y lo reutilizará para los.

En este enlace http://blog.chuidiang.com/2010/06/30...sidad-en-java/ tienes una curiosidad justo con los Integer que puede dar resultados sorprendentes.

Se bueno.

[aldo_rengo]

si pero esto, puede resultar confuso, es como de "1 en un millon", no deberia usarse, o por lo menos ahora creo saber lo que sucede...
me decis.. "misma zona de memoria"
que esto ocurre cuando "se declaran inmediatamente"...

es raro la verdad...:
hasta antes de saber esto...
venia bien claro con que los primitivos se comparaban con "=="
y los objetos. propiedades de objetos (instancias de una clase propia)
deben compararse con equals...

pero bueno, voy a leer bien, aunque no deberia, ser algo de tanta importancia...


otra cosa....


-----------------------------------------

esto me imprime "iguales"
no era que no se podia comparar, objetos con datos de tipo primitivo...

Código PHP:

  public class uo {
   public static void main(String[] args) {
     Integer n1 = 47;
     int n2=47;
     
     
     if(n1==n2){
         System.out.println("iguales");
     }else{
         System.out.println("nooo");
     }  
   

al menos JAVA, deberia tirar un error, ya que es tan ESTRICTO...

[chuidiang]

Hola:

con "inmediatamente" quiero decir una forma en que el compilador sea capaz de saber automaticamente el resultado, para poder optimizar, no me refiero a que vayan seguidas. El concepto es el que tenias, equals() para saber si son objetos iguales, == para saber si ocupan la misma memoria. La optimización del compilador puede hacer que == de true cuando aparentemente no debería darlo, pero sí es true porque el compilador se ha encargado de que esos objetos usen la misma memoria.

En cuanto a la segunda pregunta, el compilador de java sabe convertir automáticamente entre int e Integer (y entre float y Float, double y Double, etc). Si comparas con == un int con un Integer, el compilador convertira uno de los tipos al otro automáticamente para hacer la comparación y por el mismo motivo de antes, te dará true.

Estoy de acuerdo contigo en que un momento dado puede resultar confuso. Esta conversión automática se ha hecho para facilitar la vida al programador de forma que no tenga que crear explicitamente un Integer y pueda simplemente poner un valor o un int. Sin estas conversión automática, líneas como esta que pusiste en tu primer ejemplo

Integer n1 = 47;

simplemente no debería compilar y la única opción válida sería

Integer n1 = new Integer(47);

que es más engorrosa.


Se bueno.

[aldo_rengo]

Iniciado por chuidiang

En cuanto a la segunda pregunta, el compilador de java sabe convertir automáticamente entre int e Integer (y entre float y Float, double y Double, etc). Si comparas con == un int con un Integer, el compilador convertira uno de los tipos al otro automáticamente para hacer la comparación y por el mismo motivo de antes, te dará true.

No deberia, aunque bueno podria decirse que es inteligente el compilador.
pero me hace acordar a PHP, que "vale todo" entre tipos de datos...

si, uso eclipse como IDE., y detecta al toque los errores...

[posman]

Al comparar 2 variables de tipo Integer no importa si ocupan el mismo espacio de memoria. Existen un tipo de clases que lo que hacen es enmascarar un dato de tipo primitivo, se llaman Wrapper classes. Lo que hace el compilador con estas clases es convertir una variable Integer en int o viceversa. Por ejemplo puedes comparar una variable int con una variable Integer y el resultado es el esperado al utilizar == (se compara el valor numerico, no su posicion en memoria)
Este proceso se llama autoboxing y unboxing http://docs.oracle.com/javase/tutori...utoboxing.html

Un compilador no podria optimizar un codigo en donde el valor de la variable se pida al usuario (es imposible que el compilador sepa que valor escribira el usuario). Con este codigo se obtiene el mismo resultado que tu obtienes en tu codigo, pero aqui uno de los valores se pide al usuario

Código Java:

import java.util.Scanner;
 
public class Prueba {
    public static void main(String []args) {
        int entero1 = 50;
        Integer entero2 = 50;
        System.out.println("entero1 == entero2: " + (entero1==entero2));  //se comparan variables de diferente tipo
        
        Scanner in = new Scanner(System.in);
        int entero3 = in.nextInt();
        System.out.println("entero2 == entero3: " + (entero2==entero3));
    }
}
 

[aldo_rengo]

Iniciado por posman

Al comparar 2 variables de tipo Integer no importa si ocupan el mismo espacio de memoria. Existen un tipo de clases que lo que hacen es enmascarar un dato de tipo primitivo, se llaman Wrapper classes. Lo que hace el compilador con estas clases es convertir una variable Integer en int o viceversa. Por ejemplo puedes comparar una variable int con una variable Integer y el resultado es el esperado al utilizar == (se compara el valor numerico, no su posicion en memoria)
Este proceso se llama autoboxing y unboxing http://docs.oracle.com/javase/tutori...utoboxing.html

mmm... bueno, ahora no se en que momento,
comparando 2 int o integer, da false, por ocupar 2 espacios de memoria diferente.
ya me mareo. un poco.---
aparte creo que en java no se puede saber, la direccion de memoria, ya que no trabaja con punteros este lenguaje...

[Fuzzylog]

Es fácil, cuando quieras comparar recuerda esto:

Objetos => Usa equals()
tipos primitivos => Usa ==

Si intentas usar equals con un tipo primitivo, un ide como eclipse o netbeans te debería advertir que no es posible.

[aldo_rengo]

bueno pero mira...
TENGO BIEN CLARO que si son objetos debo usar, EQUALS()
y si son primitivos uso. ==.

pero este ejemplo esta complicado...

Código Java:

public class uo {
   public static void main(String[] args) {
       
      
       String cadena1 = new String("Hola");
       String cadena2 = new String("Hola");
       if (cadena1 == cadena2)
       {
        System.out.println("iguales");
       }else{
           System.out.println("distintos");
       }
       
       System.out.println("----------------------------");
       
       preguntas2 hh=new preguntas2();
       hh.set_frase("Hoy es jueves y llueve");
       
       
       preguntas2 hh3=new preguntas2();
       hh3.set_frase("Hoy es jueves y llueve");
       
       if(hh3.get_frase()==hh.get_frase()){
           System.out.println("son iguales");
           
       }else{
           
           System.out.println("no se puede comparar...");
       }  
       
}
}
 

esta es la clase que genera una instancia....

NO TIENE STATIC LA PROPIEDAD FRASE

Código Java:

public class preguntas2 {
 
    public  String frase;
    
    public preguntas2(){}
    
    
    public void set_frase(String contenido){
        frase=contenido;
    }
    
    public String get_frase(){
        return frase;
    }
    
}