Comparando los miembros de Java enum: == o equals ()?



6 Answers

¿Puede == ser utilizado en enum ?

Sí: las enumeraciones tienen controles de instancia ajustados que le permiten usar == para comparar instancias. Aquí está la garantía proporcionada por la especificación del idioma (énfasis mío):

JLS 8.9 Enums

Un tipo enum no tiene más instancias que las definidas por sus constantes enum.

Es un error en tiempo de compilación intentar instanciar explícitamente un tipo de enumeración. El método de final clone en Enum garantiza que las constantes de la enum nunca se puedan clonar, y el tratamiento especial del mecanismo de serialización garantiza que las instancias duplicadas nunca se creen como resultado de la deserialización. La ejemplificación reflexiva de los tipos enum está prohibida. En conjunto, estas cuatro cosas aseguran que no existan instancias de un tipo de enum más allá de las definidas por las constantes enum .

Debido a que solo hay una instancia de cada constante enum , es permisible usar el operador == en lugar del método equals cuando se comparan dos referencias de objetos si se sabe que al menos uno de ellos se refiere a una constante enum . (El método equals en Enum es un método final que simplemente invoca super.equals en su argumento y devuelve el resultado, realizando así una comparación de identidad.)

Esta garantía es lo suficientemente fuerte como para que Josh Bloch recomiende que si insiste en usar el patrón singleton, la mejor manera de implementarlo es usar una enum un solo elemento (consulte: Effective Java 2nd Edition, Item 3: Aplicar la propiedad singleton con un constructor privado o un tipo enum ; también seguridad de subprocesos en Singleton )

¿Cuáles son las diferencias entre == y equals ?

Como recordatorio, es necesario decir que, en general, == NO es una alternativa viable para los equals . Sin embargo, cuando lo es (como enum ), hay dos diferencias importantes a considerar:

== nunca arroja NullPointerException

enum Color { BLACK, WHITE };

Color nothing = null;
if (nothing == Color.BLACK);      // runs fine
if (nothing.equals(Color.BLACK)); // throws NullPointerException

== está sujeto a verificación de compatibilidad de tipo en tiempo de compilación

enum Color { BLACK, WHITE };
enum Chiral { LEFT, RIGHT };

if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine
if (Color.BLACK == Chiral.LEFT);      // DOESN'T COMPILE!!! Incompatible types!

¿Debe == usarse cuando corresponda?

Bloch menciona específicamente que las clases inmutables que tienen el control adecuado sobre sus instancias pueden garantizar a sus clientes que == es utilizable. enum se menciona específicamente para ejemplificar.

Punto 1: Considere métodos de fábrica estáticos en lugar de constructores

[...] permite que una clase inmutable haga la garantía de que no existen dos instancias iguales: a.equals(b) si y solo si a==b . Si una clase hace esta garantía, sus clientes pueden usar el operador == lugar del método equals(Object) , lo que puede dar como resultado un mejor rendimiento. Los tipos de Enum proporcionan esta garantía.

Para resumir, los argumentos para usar == en enum son:

  • Funciona.
  • Es mas rapido.
  • Es más seguro en tiempo de ejecución.
  • Es más seguro en tiempo de compilación.
Question

Sé que las enumeraciones de Java se compilan en clases con constructores privados y un grupo de miembros estáticos públicos. Al comparar dos miembros de una enumeración dada, siempre he usado .equals() , por ejemplo

public useEnums(SomeEnum a)
{
    if(a.equals(SomeEnum.SOME_ENUM_VALUE))
    {
        ...
    }
    ...
}

Sin embargo, acabo de encontrar un código que usa el operador igual == lugar de .equals ():

public useEnums2(SomeEnum a)
{
    if(a == SomeEnum.SOME_ENUM_VALUE)
    {
        ...
    }
    ...
}

¿Qué operador es el que debería usar?




En caso de enum, ambos son correctos y correctos.




Puede usar: ==, equals () o switch () para comparar Enums, todos son técnicamente verdaderos y servirían a su necesidad.

Consulte este tutorial para saber más sobre las operaciones comunes de Enum: Cómo usar Enums en Java




Usar cualquier cosa que no sea == para comparar las constantes enum es una tontería. Es como comparar objetos de class con equals , ¡no lo hagas!

Sin embargo, hubo un error desagradable (BugId 6277781 ) en Sun JDK 6u10 y anterior que podría ser interesante por razones históricas. Este error impidió el uso adecuado de == en las enumeraciones deserializadas, aunque podría decirse que se trata de un caso de esquina.




Como otros han dicho, ambos == y .equals() funcionan en la mayoría de los casos. La certeza del tiempo de compilación de que no está comparando tipos de objetos completamente diferentes que otros han señalado es válida y beneficiosa, sin embargo, el tipo particular de error de comparar objetos de dos tipos diferentes de tiempo de compilación también sería encontrado por FindBugs (y probablemente por Eclipse / IntelliJ compila las inspecciones de tiempo), por lo que el compilador de Java al encontrarlo no agrega tanta seguridad adicional.

Sin embargo:

  1. El hecho de que == nunca arroje NPE en mi mente es una desventaja de == . Casi nunca debería haber una necesidad de que los tipos enum sean null , ya que cualquier estado adicional que desee expresar mediante null solo se puede agregar a la enum como una instancia adicional. Si es inesperadamente null , prefiero tener un NPE que == evaluación silenciosa en falso. Por lo tanto, no estoy de acuerdo con que sea más seguro en la opinión en tiempo de ejecución ; es mejor acostumbrarse a nunca dejar que los valores enum sean @Nullable .
  2. El argumento de que == es más rápido también es falso. En la mayoría de los casos, usted llamará a .equals() en una variable cuyo tipo de tiempo de compilación es la clase enum, y en esos casos el compilador puede saber que esto es lo mismo que == (porque el método equals() enum puede no debe ser anulado) y puede optimizar la función llamar lejos. No estoy seguro si el compilador hace esto actualmente, pero si no lo hace, y resulta ser un problema de rendimiento en Java en general, entonces prefiero arreglar el compilador que tener 100.000 programadores Java que cambien su estilo de programación para adaptarse las características de rendimiento de una versión del compilador en particular.
  3. enums son Objetos. Para todos los demás tipos de objeto, la comparación estándar es .equals() , not == . Creo que es peligroso hacer una excepción para enums porque podrías terminar accidentalmente comparando Objetos con == lugar de equals() , especialmente si refactorizas una enum en una clase que no es enum. En el caso de tal refactorización, el punto de trabajo It desde arriba es incorrecto. Para convencerse de que el uso de == es correcto, debe verificar si el valor en cuestión es enum o primitivo; si fuera una clase no enum , sería incorrecto pero fácil pasar por alto porque el código aún se compilaría. El único caso en que un uso de .equals() sería incorrecto es si los valores en cuestión eran primitivos; en ese caso, el código no se compilaría, por lo que es mucho más difícil pasar por alto. Por lo tanto, .equals() es mucho más fácil de identificar como correcto, y es más seguro contra futuras refactorizaciones.

De hecho, creo que el lenguaje Java debería haber definido == en Objetos para llamar a .equals () en el valor de la izquierda e introducir un operador separado para la identidad del objeto, pero no fue así como se definió Java.

En resumen, sigo pensando que los argumentos son a favor de usar .equals() para los tipos enum .




En resumen, ambos tienen pros y contras.

Por un lado, tiene ventajas usar == , como se describe en las otras respuestas.

Por otro lado, si por alguna razón reemplazas las enumeraciones con un enfoque diferente (instancias de clases normales), habrás usado == mordiscos. (BTDT)




Enum en el medio es un conjunto de enteros constantes. "==" es tan válido y correcto como si comparas dos enteros.






Related



Tags

java java   enums