|
1 | | -## 比较java枚举成员使用equal还是== |
2 | | - |
3 | | -### 问题 |
4 | | -我知道Java枚举会被编译成一个包含私有构造参数和一堆静态方法的类，当去比较两个枚举的时候，总是使用equals()方法，例如： |
5 | | -```java |
6 | | -public useEnums(SomeEnum a) |
7 | | -{ |
8 | | - if(a.equals(SomeEnum.SOME_ENUM_VALUE)) |
9 | | - { |
10 | | - ... |
11 | | - } |
12 | | - ... |
13 | | -} |
14 | | -``` |
15 | | -除此之外，我也可以使用 == 替代equals() 方法 |
16 | | -```java |
17 | | -public useEnums2(SomeEnum a) |
18 | | -{ |
19 | | - if(a == SomeEnum.SOME_ENUM_VALUE) |
20 | | - { |
21 | | - ... |
22 | | - } |
23 | | - ... |
24 | | -} |
25 | | -``` |
26 | | -我有5年以上的java编程经验，并且我想我也懂得 == 和 equals() 之间的区别，但是我仍然觉得很困惑，哪一个操作符才是我该使用的。 |
27 | | - |
28 | | -### 答案 |
29 | | - |
30 | | -二者皆对，如果你看过枚举的源码，你会发现在源码中，equals也仅仅非常简单的 == 。 |
31 | | -我使用 == ，因为无论如何，这个左值是可以为 null的 |
32 | | - |
33 | | - |
34 | | -译者补充 java.lang.Enum 中Equals 代码： |
35 | | -```java |
36 | | -public final boolean equals(Object other) { |
37 | | - return this==other; |
38 | | -} |
39 | | -``` |
40 | | - |
41 | | - |
42 | | -### 额外答案 |
43 | | -#### 能在枚举中使用 == 进行判断？ |
44 | | -答案是肯定的，因为枚举有着严格的实例化控制，所以你可以用 == 去做比较符，这个用法，在官方文档中也有明确的说明。 |
45 | | - |
46 | | ->JLS 8.9 Enums |
47 | | ->An enum type has no instances other than those defined by its enum constants. |
48 | | ->It is a compile-time error to attempt to explicitly instantiate an enum type. The final clone method in Enum >ensures that enum constants can never be cloned, and the special treatment by the serialization mechanism ensures >that duplicate instances are never created as a result of deserialization. Reflective instantiation of enum types >is prohibited. Together, these four things ensure that no instances of an enum type exist beyond those defined by >the enum constants. |
49 | | ->Because there is only one instance of each enum constant, it is permissible to use the == operator in place of the >equals method when comparing two object references if it is known that at least one of them refers to an enum ?>constant. (The equals method in Enum is a final method that merely invokes super.equals on its argument and ?>returns the result, thus performing an identity comparison.) |
50 | | -
|
51 | | -#### 什么时候 == 和 equals 不一样？ |
52 | | -As a reminder, it needs to be said that generally, == is NOT a viable alternative to equals. When it is, however (such as with enum), there are two important differences to consider: |
53 | | -通常来说 == 不是一个 equals的一个备选方案，无论如何有2个重要的不同处需要考虑： |
54 | | - |
55 | | -##### == 不会抛出 NullPointerException |
56 | | -```java |
57 | | -enum Color { BLACK, WHITE }; |
58 | | - |
59 | | -Color nothing = null; |
60 | | -if (nothing == Color.BLACK); // runs fine |
61 | | -if (nothing.equals(Color.BLACK)); // throws NullPointerException |
62 | | -``` |
63 | | -##### == 在编译期检测类型兼容性 |
64 | | -```java |
65 | | -enum Color { BLACK, WHITE }; |
66 | | -enum Chiral { LEFT, RIGHT }; |
67 | | - |
68 | | -if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine |
69 | | -if (Color.BLACK == Chiral.LEFT); // DOESN'T COMPILE!!! Incompatible types! |
70 | | -``` |
71 | | - |
72 | | -#### 什么时候使用 == ？ |
73 | | -Bloch specifically mentions that immutable classes that have proper control over their instances can guarantee to their clients that == is usable. enum is specifically mentioned to exemplify. |
74 | | -具体来说，那些提供恰当实例控制的不可变类能够保证 == 是可用的，枚举刚好符合这个条件。 |
75 | | - |
76 | | -> Item 1: Consider static factory methods instead of constructors |
77 | | -[...] it allows an immutable class to make the guarantee that no two equal instances exist: a.equals(b) if and only if a==b. If a class makes this guarantee, then its clients can use the == operator instead of the equals(Object) method, which may result in improved performance. Enum types provide this guarantee. |
78 | | - |
79 | | -总而言之，在枚举比较上使用 == ， 因为： |
80 | | -1. 能正常工作 |
81 | | -2. 更快 |
82 | | -3. 运行时是安全的 |
83 | | -4. 编译期也是安全的 |
84 | | - |
85 | | -stackoverlfow链接：http://stackoverflow.com/questions/1750435/comparing-java-enum-members-or-equals |
| 1 | +# 比较java中枚举成员是用“==”还是equals() |
| 2 | + |
| 3 | +## 问题 |
| 4 | +java枚举被编译成带有私有构造器和一堆public的静态成员的类。当比较枚举中的两个成员时，经常使用.equals()方法，例如 |
| 5 | + public useEnums(SomeEnum a) |
| 6 | + { |
| 7 | + if(a.equals(SomeEnum.SOME_ENUM_VALUE)) |
| 8 | + { |
| 9 | + ... |
| 10 | + } |
| 11 | + ... |
| 12 | + } |
| 13 | +然而，偶然间使用“==”代替equals方法 |
| 14 | + public useEnums2(SomeEnum a) |
| 15 | + { |
| 16 | + if(a == SomeEnum.SOME_ENUM_VALUE) |
| 17 | + { |
| 18 | + ... |
| 19 | + } |
| 20 | + ... |
| 21 | + } |
| 22 | +应该使用哪个呢？ |
| 23 | +## 解答 |
| 24 | +### 回答1 |
| 25 | +技术上来说，都是对的，如果你看了equals的源码，它简单地遵从“==” ，然而我一般使用“==” 因为它对于空指针，比较安全 |
| 26 | +### 回答2 |
| 27 | +#### 能在枚举时使用用“==”吗？ |
| 28 | + |
| 29 | +可以，枚举值有小型实例控制，允许你用“==”去比较实例，在文档中有说明： |
| 30 | + |
| 31 | +JLS 8.9 枚举 |
| 32 | +一个枚举类型除了定义的那些枚举常量外没有其他实例了。 |
| 33 | +试图明确地说明一种枚举类型是会导致编译期异常。在枚举中final clone方法确保枚举常量从不会被克隆，而且序列化机制会确保从不会因为反序列化而创造复制的实例。枚举类型的反射实例化也是被禁止的。总之，以上内容确保了除了定义的枚举常量之外，没有枚举类型实例。 |
| 34 | + |
| 35 | +因为每个枚举常量只有一个实例，所以如果在比较两个参考值，至少有一个涉及到枚举常量时，允许使用“==”代替equals()。（equals()方法在枚举类中是一个final方法，在参数和返回结果时，很少调用父类的equals()方法，因此是一种恒等的比较。） |
| 36 | + |
| 37 | +这足够强力地支持Josh的建议，如果你坚持使用单例模式，最好的方法是用枚举类型强化单例属性（见Effective Java第二版中的第三条：用私有构造器或者枚举类型强化Singleton属性，或者单例模式的线程安全 |
| 38 | +>http://stackoverflow.com/questions/2912281/thread-safety-in-singleton/ ） |
| 39 | +
|
| 40 | +#### “==”和equals的区别 |
| 41 | +通常情况下，==并不是可以替换equals，然而在枚举中是可以的。它们之间有两个重要的不同： |
| 42 | + |
| 43 | + “==”从不会抛出空指针异常 |
| 44 | + |
| 45 | + |
| 46 | + enum Color { BLACK, WHITE }; |
| 47 | + |
| 48 | + Color nothing = null; |
| 49 | + |
| 50 | + if (nothing == Color.BLACK); // 正常运行 |
| 51 | + |
| 52 | + if (nothing.equals(Color.BLACK)); // 抛出空指 |
| 53 | + 针异常 |
| 54 | + |
| 55 | +在编译期，"=="会检查其类型的兼容性 |
| 56 | + |
| 57 | + enum Color { BLACK, WHITE }; |
| 58 | + enum Chiral { LEFT, RIGHT }; |
| 59 | + |
| 60 | + if (Color.BLACK.equals(Chiral.LEFT)); // 编译正常 |
| 61 | + if (Color.BLACK == Chiral.LEFT); // 无法编译，类型不兼容 |
| 62 | + |
| 63 | +#### 在适用时，“==”可以被使用吗 |
| 64 | + |
| 65 | +Bloch（effective java的作者）明确指出不可变类可以控制它们实例保证客户端“==”是可用的。枚举就被明确地证明了 |
| 66 | + |
| 67 | +考虑静态工厂方法代替构造器 |
| 68 | +它使得不可变的类可以确保不会存在两个相等的实例，即当且仅当a==b的时候才有a.equals(b)为true。如果类保证了这一点，它的客户端可以使用“==”操作符来代替equals（Object）方法，这样可以提升性能。枚举类型保证了这一点 |
| 69 | + |
| 70 | +总之，在枚举中使用“==”优势： |
| 71 | + |
| 72 | +- 能运行 |
| 73 | +- 更快 |
| 74 | +- 在运行期更安全 |
| 75 | +- 在编译期更安全 |
| 76 | + |
| 77 | +备注：强有力的反击了那些认为foo.equals(bar)比foo==bar更有可读性的人们。 |
| 78 | + |
| 79 | +原文地址： |
| 80 | +> http://stackoverflow.com/questions/1750435/comparing-java-enum-members-or-equals |
0 commit comments