¿Está garantizado que new Integer (i) == i en Java?

StackOverflow https://stackoverflow.com/questions/2831945

Pregunta

Considere el siguiente fragmento: 

    int i = 99999999;
    byte b = 99;
    short s = 9999;
    Integer ii = Integer.valueOf(9); // should be within cache

    System.out.println(new Integer(i) == i); // "true"
    System.out.println(new Integer(b) == b); // "true"
    System.out.println(new Integer(s) == s); // "true"
    System.out.println(new Integer(ii) == ii); // "false"

Es obvio por qué la última línea Siempre impresiones "false": estamos utilizando la comparación de identidad de referencia ==, y un objeto new nunca ser == a un objeto ya existente .

La pregunta es acerca de las 3 primeras líneas: son aquellas comparaciones garantizada para estar en el int primitiva, con la auto-Integer sacó de la caja? ¿Hay casos en que la primitiva sería automático en caja de cambio, y se realizan comparaciones de identidad de referencia? (Lo que todo ser entonces false!)

¿Fue útil?

Solución

Sí. JLS §5.6.2 especifica el reglas para la promoción numérica binaria. En parte:

  

Cuando se aplica un operador binario   promoción numérica a un par de   operandos, cada uno de los cuales debe denotar una   valor que se puede convertir en un valor numérico   tipo, se aplican las siguientes reglas, en   orden, conversión utilizando ensanchamiento   (§5.1.2) para convertir operandos como   necesario:

     

Si cualquiera de los operandos es de un   tipo de referencia, la conversión unboxing   (§5.1.8) se realiza.

aplica promoción numérica binaria por varios operadores numéricos, incluyendo "los operadores de igualdad numéricos == y! =."

JLS §15.21.1 (Igualdad numérica Operadores == y! =) especifica:

  

Si los operandos de una igualdad   operador son ambos de tipo numérico, o   uno es de tipo numérico y el otro   es convertible (§5.1.8) a numérico   tipo, promoción numérica binaria es   realizado en los operandos (§5.6.2).

En contraste, JLS §15.21.3 (! == Igualdad Operadores de referencia y =) establece lo siguiente:

  

Si los operandos de una igualdad   operador son ambos de cualquiera de referencia   escriba o el tipo null, entonces la   operación es igualdad de objetos

Esto encaja con la comprensión común de boxeo y unboxing, eso es todo sólo se realiza cuando hay una falta de coincidencia.

Otros consejos

La primera vez que va a explicar precisamente cuando == es una igualdad de referencia, y precisamente cuando Es una igualdad numérica. Las condiciones para la igualdad de referencia es más simple, por lo que se explicará en primer lugar.

operadores de igualdad de Referencia 15.21.3 JLS == y !=

  

Si los operandos de un operador de igualdad son ambos de cualquiera de los tipos de referencia o la nula tipo, entonces la operación es la igualdad objeto.

Esto explica lo siguiente: 

System.out.println(new Integer(0) == new Integer(0)); // "false"

Los dos operandos son Integer, que son los tipos de referencia, y por eso el == es comparación de igualdad de referencia, y dos objetos new nunca serán == el uno al otro, así que por eso que imprime false.

Para == sea igualdad numérica, al menos uno de los operando debe ser un tipo numérico ; esto se especifica como sigue:

Operadores de igualdad numérica 15.21.1 JLS == y !=

  

Si los operandos de un operador de igualdad son ambos de tipo numérico, o uno es de tipo numérico y el otro es convertible a numérico tipo, promoción numérica binaria se realiza en los operandos. Si el tipo promovido de los operandos es int o long, a continuación, una prueba de la igualdad de número entero se lleva a cabo; si el tipo es promovido float ordouble`, a continuación, una prueba de igualdad de punto flotante se realiza.

     

Tenga en cuenta que binarios realiza promoción numérica valor de ajuste de conversión y la conversión unboxing.

Por lo tanto, tenga en cuenta lo siguiente: 

System.out.println(new Integer(0) == 0); // "true"

Esta impresiones true, ya que:

  • el operando derecho es un tipo int numérico
  • el operando de la izquierda es convertible a un tipo numérico, por unboxing a int
  • Por lo tanto, == es una operación numérica igualdad

Resumen

  • Si ambos operandos de == y != son los tipos de referencia, que será siempre una operación de la igualdad de referencia
    • No importa si los operandos son convertibles a tipos numéricos
  • Si al menos uno de los operandos es un tipo numérico, que será siempre una operación numérica igualdad
    • Auto-unboxing en un (a lo más!) De los operandos se llevará a cabo si es necesario

Referencias

preguntas relacionadas

No afiliado a StackOverflow
scroll top