ฉันรู้ว่า Java enums ถูกคอมไพล์ไปยังคลาสที่มีคอนสตรัคเตอร์ส่วนตัวและสมาชิกสแตติกสาธารณะ เมื่อเปรียบเทียบสมาชิกสองคนของ enum ที่กำหนดฉันใช้เสมอ.equals()เช่น

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

อย่างไรก็ตามฉันเพิ่งเจอรหัสบางส่วนที่ใช้ตัวดำเนินการเท่ากับ==แทน. equals ():

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

ฉันควรใช้โอเปอเรเตอร์แบบใด

ทั้งสองถูกต้องทางเทคนิค ถ้าคุณดูซอร์สโค้ด.equals()มันก็จะ==เปลี่ยนไป

ฉันใช้==อย่างไรก็ตามเนื่องจากจะปลอดภัย

สามารถ==ใช้กับenum?

ใช่: enums มีการควบคุมอินสแตนซ์ที่ จำกัด ที่ช่วยให้คุณใช้==เพื่อเปรียบเทียบอินสแตนซ์ นี่คือการรับประกันโดยข้อกำหนดภาษา (เน้นโดยฉัน):

JLS 8.9 Enums

ประเภท enum ไม่มีอินสแตนซ์อื่นนอกเหนือจากที่กำหนดโดยค่าคงที่ enum

มันเป็นข้อผิดพลาดในการคอมไพล์เวลาพยายามที่จะยกตัวอย่างอย่างชัดเจนประเภท enum final cloneวิธีในการEnumทำให้มั่นใจว่าenumคงไม่สามารถโคลนและการดูแลเป็นพิเศษโดยมั่นใจกลไกอนุกรมว่ากรณีที่ซ้ำกันจะไม่เคยสร้างเป็นผลมาจาก deserialization ห้ามมิให้มีการสะท้อนกลับของชนิด enum ร่วมกันสิ่งทั้งสี่นี้ช่วยให้แน่ใจว่าไม่มีอินสแตนซ์ของenumประเภทที่เกินกว่าที่กำหนดโดยenumค่าคงที่

เนื่องจากมีเพียงหนึ่งตัวอย่างของแต่ละenumคงได้รับอนุญาตให้ใช้==ประกอบการในสถานที่ของequalsวิธีการเมื่อเปรียบเทียบสองอ้างอิงวัตถุถ้ามันเป็นที่รู้จักกันว่าอย่างน้อยหนึ่งของพวกเขาหมายถึงenumอย่างต่อเนื่อง ( equalsวิธีการในEnumเป็นfinalวิธีการที่เรียกใช้super.equalsการโต้แย้งและส่งคืนผลลัพธ์เท่านั้นจึงทำการเปรียบเทียบตัวตน)

การรับประกันนี้มีความแข็งแกร่งเพียงพอที่ Josh Bloch แนะนำว่าหากคุณยืนยันในการใช้รูปแบบซิงเกิลวิธีที่ดีที่สุดในการติดตั้งคือการใช้องค์ประกอบเดียวenum(ดู: มีผลบังคับใช้ Java 2nd Edition รายการ 3: บังคับใช้คุณสมบัติ Singleton ด้วย คอนสตรัคส่วนตัวหรือประเภท enum ; และยังปลอดภัยเรื่องเธรดในซิงเกิล )

อะไรคือความแตกต่างระหว่าง==และequals?

เพื่อเป็นการเตือนความจำต้องมีการกล่าวโดยทั่วไปว่า==ไม่ใช่ทางเลือกที่เป็นไปequalsได้ อย่างไรก็ตามเมื่อเป็นเช่นenumนั้นมีความแตกต่างที่สำคัญสองประการที่ควรพิจารณา:

== ไม่เคยโยน NullPointerException

enum Color { BLACK, WHITE };

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

== อาจมีการตรวจสอบความเข้ากันได้ของประเภทในเวลารวบรวม

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!

ควร==ใช้เมื่อมีผล?

โบลชกล่าวโดยเฉพาะว่าคลาสที่ไม่เปลี่ยนรูปซึ่งมีการควบคุมอินสแตนซ์ที่เหมาะสมสามารถรับประกันกับลูกค้าที่==ใช้งานได้ enumมีการกล่าวถึงโดยเฉพาะเพื่อเป็นตัวอย่าง

รายการที่ 1: พิจารณาวิธีการโรงงานแบบคงที่แทนการก่อสร้าง

[ ... ] มันจะช่วยให้ระดับไม่เปลี่ยนรูปเพื่อให้การรับประกันว่าไม่มีสองกรณีเท่ากับอยู่: ถ้าหากa.equals(b) a==bหากคลาสทำการรับประกันนี้ลูกค้าจะสามารถใช้==โอเปอเรเตอร์แทนequals(Object)วิธีการซึ่งอาจส่งผลให้ประสิทธิภาพดีขึ้น ประเภท Enum ให้การรับประกันนี้

เพื่อสรุปข้อโต้แย้งสำหรับการใช้==บนenumคือ:

• มันได้ผล.
• มันเร็วกว่า
• ปลอดภัยในเวลาทำงาน
• การรวบรวมเวลาปลอดภัยยิ่งขึ้น

การใช้==เพื่อเปรียบเทียบสองค่า enum ทำงานได้เนื่องจากมีเพียงวัตถุเดียวสำหรับค่าคงที่แต่ละ enum

ในบันทึกย่อด้านข้างไม่จำเป็นต้องใช้==ในการเขียนรหัสที่ปลอดภัยถ้าคุณเขียนequals()สิ่งนี้:

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

นี่คือวิธีปฏิบัติที่ดีที่สุดที่รู้จักกันในชื่อเปรียบเทียบค่าคงที่จากทางซ้ายที่คุณควรปฏิบัติตามอย่างแน่นอน

อย่างที่คนอื่น ๆ พูดกันทั้งสองอย่าง==และ.equals()ทำงานในกรณีส่วนใหญ่ ความแน่นอนของเวลาในการคอมไพล์ที่คุณไม่ได้เปรียบเทียบกับประเภทของวัตถุที่คนอื่น ๆ ชี้ให้เห็นนั้นถูกต้องและเป็นประโยชน์อย่างไรก็ตามข้อผิดพลาดชนิดหนึ่งของการเปรียบเทียบวัตถุของเวลารวบรวมสองประเภทที่แตกต่างกันก็จะถูกค้นพบโดย FindBugs การตรวจสอบเวลาคอมไพล์ Eclipse / IntelliJ) ดังนั้นคอมไพเลอร์ Java จึงพบว่ามันไม่ได้เพิ่มความปลอดภัยมากนัก

อย่างไรก็ตาม:

1. ความจริงที่ว่า==ไม่เคยพ่น NPE ในใจของฉันเป็นข้อเสีย==ของ ไม่ควรมีความจำเป็นที่จะต้องมีenumประเภทnullเนื่องจากสถานะพิเศษใด ๆ ที่คุณอาจต้องการให้แสดงผ่านnullสามารถเพิ่มลงในenumอินสแตนซ์เพิ่มเติมได้ หากเป็นเรื่องไม่คาดคิดnullฉันควรมี NPE มากกว่าที่==จะประเมินว่าเป็นเท็จ ดังนั้นผมจึงไม่เห็นด้วยกับมันปลอดภัยที่ใช้เวลาความเห็น; ดีกว่าที่จะได้รับเป็นนิสัยไม่เคยที่จะให้ค่าเป็นenum@Nullable
2. โต้แย้งว่า==เป็นได้เร็วขึ้นนอกจากนี้ยังปลอม ในกรณีส่วนใหญ่คุณจะเรียก.equals()ตัวแปรที่มีชนิดรวบรวมเวลาเป็นชั้น enum และในกรณีที่คอมไพเลอร์สามารถรู้ได้ว่านี้เป็นเช่นเดียวกับ==(เพราะenum's equals()วิธีการไม่สามารถแทนที่) และสามารถเพิ่มประสิทธิภาพการเรียกใช้ฟังก์ชัน ไป ฉันไม่แน่ใจว่าคอมไพเลอร์ในปัจจุบันทำเช่นนี้หรือไม่ แต่หากไม่เป็นเช่นนั้นและกลายเป็นปัญหาด้านประสิทธิภาพใน Java โดยรวมแล้วฉันควรแก้ไขคอมไพเลอร์มากกว่าให้โปรแกรมเมอร์ Java 100,000 คนเปลี่ยนสไตล์การเขียนโปรแกรมให้เหมาะสม คุณลักษณะด้านประสิทธิภาพของเวอร์ชันคอมไพเลอร์โดยเฉพาะ
3. enumsเป็นวัตถุ สำหรับทุกประเภทวัตถุอื่น ๆ เปรียบเทียบมาตรฐานคือไม่.equals() ==ฉันคิดว่ามันอันตรายที่จะทำการยกเว้นenumsเพราะคุณอาจบังเอิญเปรียบเทียบวัตถุกับ==แทนที่จะเป็นequals()โดยเฉพาะอย่างยิ่งถ้าคุณปรับโครงสร้างenumเข้าไปในชั้นที่ไม่ใช่ enum ในกรณีของการปรับโครงสร้างดังกล่าวจุดทำงานจากด้านบนผิด หากต้องการโน้มน้าวตัวเองว่าการใช้งาน==ถูกต้องคุณต้องตรวจสอบว่าคุณค่าของคำถามนั้นenumเป็นแบบดั้งเดิมหรือไม่ ถ้าไม่ใช่enumคลาสก็ผิด แต่พลาดง่ายเพราะรหัสจะคอมไพล์ กรณีเดียวเมื่อมีการใช้.equals()จะผิดคือถ้าค่าในคำถามเป็นพื้นฐาน ในกรณีนั้นรหัสจะไม่รวบรวมดังนั้นจึงเป็นเรื่องยากที่จะพลาด ดังนั้นจึง.equals()ง่ายต่อการระบุว่าถูกต้องและปลอดภัยกว่าการปรับโครงสร้างในอนาคต

ฉันคิดว่าภาษาจาวาควรกำหนด == บน Objects to call .equals () ทางด้านซ้ายมือและแนะนำตัวดำเนินการแยกต่างหากสำหรับเอกลักษณ์ของวัตถุ แต่นั่นไม่ใช่วิธีที่ Java กำหนดไว้

โดยสรุปฉันยังคงคิดว่าข้อโต้แย้งมีประโยชน์ในการใช้.equals()กับenumประเภท

ฉันชอบที่จะใช้==แทนequals:

เหตุผลอื่นนอกเหนือจากที่กล่าวถึงแล้วในที่นี้คือคุณสามารถแนะนำข้อผิดพลาดโดยไม่ทราบหรือไม่ สมมติว่าคุณมี enums นี้ซึ่งเหมือนกัน แต่ใน pacakges ที่แยกจากกัน (มันไม่ธรรมดา แต่มันอาจเกิดขึ้นได้):

Enum แรก :

package first.pckg

public enum Category {
    JAZZ,
    ROCK,
    POP,
    POP_ROCK
}

Enum ที่สอง:

package second.pckg

public enum Category {
    JAZZ,
    ROCK,
    POP,
    POP_ROCK
}

จากนั้นสมมติว่าคุณใช้เท่ากับเช่นถัดไปitem.categoryซึ่งเป็นfirst.pckg.Categoryแต่คุณนำเข้า enum ที่สอง ( second.pckg.Category) แทนอันแรกโดยที่ไม่ทราบว่า:

import second.pckg.Category;
...

Category.JAZZ.equals(item.getCategory())

ดังนั้นคุณจะได้รับ allways falseเนื่องจากเป็น enum ที่แตกต่างกันถึงแม้ว่าคุณจะคาดหวังเพราะความจริงคือitem.getCategory() JAZZและอาจเป็นเรื่องยากที่จะเห็น

ดังนั้นหากคุณใช้โอเปอเรเตอร์แทนคุณ==จะมีข้อผิดพลาดในการคอมไพล์:

โอเปอเรเตอร์ == ไม่สามารถใช้ได้กับ "second.pckg.Category", "first.pckg.Category"

import second.pckg.Category; 
...

Category.JAZZ == item.getCategory() 

นี่คือการทดสอบกำหนดเวลาน้ำมันดิบเพื่อเปรียบเทียบทั้งสอง:

import java.util.Date;

public class EnumCompareSpeedTest {

    static enum TestEnum {ONE, TWO, THREE }

    public static void main(String [] args) {

        Date before = new Date();
        int c = 0;

        for(int y=0;y<5;++y) {
            for(int x=0;x<Integer.MAX_VALUE;++x) {
                if(TestEnum.ONE.equals(TestEnum.TWO)) {++c;}
                if(TestEnum.ONE == TestEnum.TWO){++c;}              
            }
        }

        System.out.println(new Date().getTime() - before.getTime());
    }   

}

แสดงความคิดเห็น IFs ทีละหนึ่ง นี่คือทั้งสองเปรียบเทียบจากด้านบนในรหัสไบต์ถอดประกอบ:

 21  getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19]
 24  getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25]
 27  invokevirtual EnumCompareSpeedTest$TestEnum.equals(java.lang.Object) : boolean [28]
 30  ifeq 36

 36  getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19]
 39  getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25]
 42  if_acmpne 48

ครั้งแรก (เท่ากับ) ทำการโทรเสมือนและทดสอบบูลีส่งคืนจากสแต็ก ที่สอง (==) เปรียบเทียบที่อยู่วัตถุโดยตรงจากสแต็ค ในกรณีแรกมีกิจกรรมมากขึ้น

ฉันรันการทดสอบนี้หลายครั้งโดยใช้ IFs ทั้งคู่ทีละครั้ง "==" เร็วขึ้นเล็กน้อย

ในกรณีของ enum ทั้งสองถูกต้องและถูกต้อง !!

TL; DR

ตัวเลือกอื่นคือObjects.equalsวิธีการยูทิลิตี้

Objects.equals( thisEnum , thatEnum )

Objects.equals เพื่อความปลอดภัย null

เท่ากับโอเปอเรเตอร์ == แทน. equals ()

ฉันควรใช้โอเปอเรเตอร์แบบใด

ตัวเลือกที่สามคือequalsวิธีสแตติกที่พบในObjectsคลาสยูทิลิตี้ที่เพิ่มใน Java 7และใหม่กว่า

ตัวอย่าง

นี่คือตัวอย่างการใช้Monthenum

boolean areEqual = Objects.equals( Month.FEBRUARY , Month.JUNE ) ;  // Returns `false`.

ประโยชน์ที่ได้รับ

ฉันพบประโยชน์สองสามประการสำหรับวิธีนี้:

• Null ความปลอดภัย
  • ทั้ง Null เป็นโมฆะ true
  • เป็นโมฆะ null false
  • ไม่มีความเสี่ยงในการขว้าง NullPointerException
• กะทัดรัดอ่านง่าย

มันทำงานอย่างไร

ตรรกะใช้โดยObjects.equalsอะไร

ดูด้วยตัวคุณเองจากซอร์สโค้ด Java 10ของOpenJDK :

return (a == b) || (a != null && a.equals(b));

การใช้สิ่งอื่นนอกเหนือจาก==การเปรียบเทียบค่าคงที่ enum นั้นเป็นเรื่องไร้สาระ มันเหมือนกับการเปรียบเทียบclassวัตถุกับequals - อย่าทำมัน!

อย่างไรก็ตามมีข้อผิดพลาดที่น่ารังเกียจ (BugId 6277781 ) ใน Sun JDK 6u10 และรุ่นก่อนหน้าซึ่งอาจน่าสนใจด้วยเหตุผลทางประวัติศาสตร์ ข้อผิดพลาดนี้ทำให้ไม่สามารถใช้งาน==deserialized enums ได้อย่างเหมาะสมแม้ว่าจะเป็นกรณีมุมก็ตาม

Enums เป็นคลาสที่คืนค่าอินสแตนซ์เดียว (เช่น singletons) สำหรับค่าคงที่การแจงนับแต่ละรายการที่ประกาศโดยpublic static final field(ไม่เปลี่ยนรูป) เพื่อให้==ผู้ปฏิบัติงานสามารถใช้ตรวจสอบความเท่าเทียมกันแทนที่จะใช้equals()วิธีการ

เหตุผล enums ทำงานได้อย่างง่ายดายด้วย == เป็นเพราะแต่ละอินสแตนซ์ที่กำหนดไว้ยังเป็นซิงเกิล ดังนั้นการเปรียบเทียบตัวตนโดยใช้ == จะทำงานเสมอ

แต่การใช้ == เพราะใช้งานได้กับ enums หมายความว่าโค้ดทั้งหมดของคุณมีการใช้ควบคู่กับ enum อย่างแน่นหนา

ตัวอย่างเช่น: Enums สามารถใช้อินเตอร์เฟสได้ สมมติว่าคุณกำลังใช้ enum ซึ่งใช้ Interface1 หากภายหลังใครบางคนเปลี่ยนหรือแนะนำคลาสใหม่ Impl1 เป็นการใช้งานอินเทอร์เฟซเดียวกัน จากนั้นหากคุณเริ่มใช้งานอินสแตนซ์ของ Impl1 คุณจะมีรหัสจำนวนมากที่จะเปลี่ยนแปลงและทดสอบเนื่องจากการใช้งานก่อนหน้านี้ของ ==

ดังนั้นจึงเป็นการดีที่สุดที่จะปฏิบัติตามสิ่งที่ถือว่าเป็นแนวปฏิบัติที่ดีเว้นแต่จะได้รับความสมเหตุสมผล

หนึ่งในกฎ Sonar Enum values should be compared with "=="คือ เหตุผลมีดังนี้

การทดสอบความเท่าเทียมกันของค่า enum ด้วยequals()นั้นใช้ได้อย่างสมบูรณ์เพราะ enum เป็นวัตถุและนักพัฒนา Java ทุกคน==ไม่ควรใช้เพื่อเปรียบเทียบเนื้อหาของวัตถุ ในเวลาเดียวกันใช้==กับ enums:

• ให้การเปรียบเทียบที่คาดหวัง (เนื้อหา) เช่นเดียวกับ equals()

• ปลอดภัยกว่า null equals()

• ให้การตรวจสอบเวลาแบบคงที่ (แบบคงที่) มากกว่าการตรวจสอบแบบรันไทม์

ด้วยเหตุผลเหล่านี้คุณ==ควรเลือกequals()ใช้

สุดท้าย แต่ไม่น้อยที่==ใน enums คือเนื้อหาที่อ่านได้มากขึ้น (verbose equals()น้อยกว่า)

ในระยะสั้นทั้งสองมีข้อดีและข้อเสีย

ในอีกด้านหนึ่งมันมีข้อดีที่จะใช้==ตามที่อธิบายไว้ในคำตอบอื่น ๆ

ในทางกลับกันถ้าคุณด้วยเหตุผลใด ๆ แทนที่ enums ด้วยวิธีการที่แตกต่างกัน (อินสแตนซ์ชั้นเรียนปกติ) มีการใช้==กัดคุณ (BTDT.)

ฉันต้องการเติมเต็มคำตอบ polygenelubricants:

ฉันชอบตัวเองเท่ากับ () แต่มันเป็นทะเลสาบตรวจสอบความเข้ากันได้ของประเภท ซึ่งฉันคิดว่าเป็นข้อ จำกัด ที่สำคัญ

เมื่อต้องการให้ตรวจสอบความเข้ากันได้ของชนิดในขณะรวบรวมให้ประกาศและใช้ฟังก์ชันที่กำหนดเองใน enum ของคุณ

public boolean isEquals(enumVariable) // compare constant from left
public static boolean areEqual(enumVariable, enumVariable2) // compare two variable

ด้วยวิธีนี้คุณจะได้รับประโยชน์ทั้งหมดจากโซลูชันทั้งสอง: การป้องกัน NPE รหัสที่อ่านง่ายและการตรวจสอบความเข้ากันได้ของประเภทในเวลารวบรวม

ฉันยังแนะนำให้เพิ่มค่า UNDEFINED สำหรับ enum

==สามารถโยนNullPointerExceptionหากประเภทดั้งเดิมจะถูกเปรียบเทียบกับรุ่นระดับของมัน ตัวอย่างเช่น:

private static Integer getInteger() {
    return null;
}

private static void foo() {
    int a = 10;

    // Following comparison throws a NPE, it calls equals() on the 
    // non-primitive integer which is itself null. 
    if(a == getInteger()) { 
        // Some code
    }
}