CompareTo () เทียบกับเท่ากับ ()

เมื่อทดสอบความเท่าเทียมกันของStringJava ฉันใช้มาตลอดequals()เพราะสำหรับฉันแล้วนี่เป็นวิธีที่เป็นธรรมชาติที่สุดสำหรับฉัน ท้ายที่สุดชื่อของมันก็บอกอยู่แล้วว่าตั้งใจจะทำอะไร แต่เพื่อนร่วมงานของผมเพิ่งบอกฉันได้รับการสอนที่จะใช้แทนcompareTo() == 0 equals()สิ่งนี้ให้ความรู้สึกผิดธรรมชาติ (ตามที่compareTo()ตั้งใจไว้เพื่อให้มีการสั่งซื้อและไม่เปรียบเทียบเพื่อความเท่าเทียมกัน) และถึงแม้จะค่อนข้างอันตราย (เพราะcompareTo() == 0ไม่จำเป็นต้องหมายความถึงความเท่าเทียมกันในทุกกรณีแม้ว่าฉันจะรู้ว่ามันทำStringเพื่อฉันก็ตาม)

เขาไม่ทราบว่าทำไมเขาถูกสอนให้ใช้compareTo()แทนequals()สำหรับString's, และฉันจะยังไม่พบเหตุผลใด ๆ นี่เป็นเรื่องของรสนิยมส่วนตัวจริงๆหรือมีเหตุผลที่แท้จริงสำหรับวิธีใดวิธีหนึ่ง?

ความแตกต่างคือ"foo".equals((String)null)ส่งคืนเท็จในขณะที่"foo".compareTo((String)null) == 0พ่น NullPointerException ดังนั้นจึงไม่สามารถใช้แทนกันได้เสมอไปแม้แต่กับ Strings

ความแตกต่างหลัก 2 ประการคือ:

1. equalsจะใช้ Object ใด ๆ เป็นพารามิเตอร์ แต่compareToจะใช้เฉพาะ Strings
2. equalsเพียงบอกคุณว่าเท่ากันหรือไม่ แต่compareToให้ข้อมูลว่าสตริงเปรียบเทียบตามศัพท์อย่างไร

ฉันดูโค้ดคลาส Stringแล้วอัลกอริทึมภายใน CompareTo และเท่ากับมีลักษณะเหมือนกันโดยทั่วไป ผมเชื่อว่าความเห็นของเขาเป็นเพียงเรื่องของรสชาติและผมเห็นด้วยกับคุณ - ถ้าสิ่งที่คุณจำเป็นต้องรู้คือความเท่าเทียมกันของสายและไม่ได้เป็นที่หนึ่งมาก่อน lexicographically equalsแล้วผมจะใช้

เมื่อเปรียบเทียบเพื่อความเท่าเทียมกันคุณควรใช้equals()เพราะเป็นการแสดงออกถึงเจตนาของคุณอย่างชัดเจน

compareTo()มีข้อเสียเปรียบเพิ่มเติมคือใช้งานได้กับวัตถุที่ใช้Comparableอินเทอร์เฟซเท่านั้น

สิ่งนี้ใช้โดยทั่วไปไม่ใช่เฉพาะกับสตริงเท่านั้น

compareToทำงานได้มากขึ้นหากสตริงมีความยาวต่างกัน equalsสามารถคืนค่าเท็จได้ในขณะที่compareToต้องตรวจสอบอักขระให้เพียงพอเสมอเพื่อค้นหาลำดับการจัดเรียง

compareTo()ไม่เพียง แต่นำไปใช้กับสาย แต่ยังวัตถุอื่นใด ๆ เพราะจะเกิดการโต้แย้งทั่วไปcompareTo<T> TString เป็นหนึ่งในคลาสที่ใช้compareTo()วิธีการนี้โดยใช้Comparableอินเทอร์เฟซ (CompareTo () เป็นวิธีการสำหรับอินเทอร์เฟซที่เทียบเคียงได้) ดังนั้นคลาสใด ๆ จึงมีอิสระที่จะใช้อินเทอร์เฟซที่เปรียบเทียบได้

แต่compareTo()ให้ลำดับของวัตถุโดยทั่วไปจะใช้ในการเรียงลำดับวัตถุจากน้อยไปมากหรือมากไปหาน้อยในขณะที่equals()จะพูดถึงความเท่าเทียมกันเท่านั้นและบอกว่ามันเท่ากันหรือไม่

ในบริบทสตริง:
CompareTo: เปรียบเทียบสองสตริงตามศัพท์
เท่ากับ: เปรียบเทียบสตริงนี้กับวัตถุที่ระบุ

เปรียบเทียบเพื่อเปรียบเทียบสองสตริงโดยใช้อักขระ (ที่ดัชนีเดียวกัน) และส่งกลับจำนวนเต็ม (บวกหรือลบ) ตามนั้น

String s1 = "ab";
String s2 = "ab";
String s3 = "qb";
s1.compareTo(s2); // is 0
s1.compareTo(s3); // is -16
s3.compareTo(s1); // is 16

เท่ากับ ()จะสามารถมีประสิทธิภาพมากขึ้นแล้วcompareTo ()

ความแตกต่างที่สำคัญมากระหว่าง CompareTo และเท่ากับ:

"myString".compareTo(null);  //Throws java.lang.NullPointerException
"myString".equals(null);     //Returns false

เท่ากับ ()ตรวจสอบว่าวัตถุสองชิ้นเหมือนกันหรือไม่และส่งคืนบูลีน

CompareTo () (จากอินเทอร์เฟซเปรียบเทียบได้) ส่งคืนจำนวนเต็ม จะตรวจสอบว่าวัตถุใด "น้อยกว่า" "เท่ากับ" หรือ "มากกว่า" อีกชิ้นหนึ่ง ไม่ใช่ทุกออบเจ็กต์ที่สามารถเรียงลำดับตามเหตุผลได้ดังนั้นวิธีการ CompareTo () จึงไม่สมเหตุสมผลเสมอไป

โปรดทราบว่า equals () ไม่ได้กำหนดการจัดลำดับระหว่างออบเจ็กต์ซึ่ง CompareTo () ทำ

ตอนนี้ฉันแนะนำให้คุณตรวจสอบซอร์สโค้ดของทั้งสองวิธีเพื่อสรุปว่าการเท่ากับเป็นที่นิยมมากกว่าการเปรียบเทียบซึ่งเกี่ยวข้องกับการคำนวณทางคณิตศาสตร์บางอย่าง

ดูเหมือนว่าทั้งสองวิธีจะทำสิ่งเดียวกันได้ดี แต่วิธีการ CompareTo () ใช้ใน String ไม่ใช่ Object และเพิ่มฟังก์ชันพิเศษบางอย่างที่ด้านบนของวิธีการ equals ปกติ () หากสิ่งที่คุณสนใจคือความเท่าเทียมกันดังนั้นวิธีการ equals () จะเป็นทางเลือกที่ดีที่สุดเพียงเพราะมันสมเหตุสมผลมากขึ้นสำหรับโปรแกรมเมอร์คนต่อไปที่จะดูโค้ดของคุณ ความแตกต่างของเวลาระหว่างสองฟังก์ชันที่แตกต่างกันไม่ควรมีความสำคัญเว้นแต่คุณจะวนซ้ำรายการจำนวนมาก CompareTo () มีประโยชน์มากเมื่อคุณต้องการทราบลำดับของสตริงในคอลเลกชันหรือเมื่อคุณต้องการทราบความแตกต่างของความยาวระหว่างสตริงที่ขึ้นต้นด้วยลำดับอักขระเดียวกัน

ที่มา: http://java.sun.com/javase/6/docs/api/java/lang/String.html

equals() ควรเป็นวิธีการเลือกในกรณีของ OP

เมื่อดูการใช้งานequals()และcompareTo()ในjava.lang.String บน grepcodeเราจะเห็นได้อย่างง่ายดายว่าการเท่ากับจะดีกว่าถ้าเราเกี่ยวข้องกับความเท่าเทียมกันของสองสตริง:

equals():

1012   บูลีนสาธารณะ เท่ากับ ( Object anObject) { 1013 if ( this == anObject) { 1014 return true ; 1015       } 1016 if (anObject instanceof String ) { 1017 String anotherString = ( String ) anObject; 1018 int n = นับ; 1019 ถ้า (n == anotherString.count) { 1020 ถ่าน v1 [] = ค่า; 1021 ถ่าน v2 [] = anotherString.value; 1022 int
      
           

       
          
          
          
              
              
              ผม = ชดเชย; 
1023               int j = anotherString.offset; 
1024               ในขณะที่ (! n-- = 0) { 
1025                   ถ้า (v1 [ผม ++] = v2 [เจ ++]!) 
1026                       ผลตอบแทน เท็จ ; 
1027               } 
1028               กลับ จริง ; 
1029           } 
1030       } 
1031       ผลตอบแทน เท็จ ; 
1032   }

และcompareTo():

1174   int สาธารณะ  CompareTo ( String anotherString) { 1175 int len1 = count; 1176 int len2 = anotherString.count; 1177 int n = คณิตศาสตร์ นาที (len1, len2); 1178 ถ่าน v1 [] = ค่า; 1179 ถ่าน v2 [] = anotherString.value; 1180 int i = ชดเชย; 1181 int j = anotherString.offset; 1183 ถ้า (i == j) { 1184 int k = i; 1185 int lim = n + ฉัน; 1186 while (k <lim) {
      
      
      
      
      
      
      
      
          
          
          
1187               ถ่าน c1 = v1 [k]; 
1188               ถ่าน c2 = v2 [k]; 
1189               ถ้า (c1! = c2) { 
1190                   กลับ c1 - c2; 
1191               } 
1192               กิโล ++; 
1193           } 
1194       } else { 
1195           while (n--! = 0) { 
1196               ถ่าน c1 = v1 [i ++]; 
1197               ถ่าน c2 = v2 [j ++]; 
1198               if (c1! = c2) { 
1199                   กลับ c1 - c2; 
1200               } 
1201           } 
1202       }
1203       ส่งคืน len1 - len2; 
1204   }

เมื่อหนึ่งในสตริงเป็นคำนำหน้าของอีกสตริงประสิทธิภาพของcompareTo()จะแย่ลงเนื่องจากยังคงต้องกำหนดลำดับคำศัพท์ในขณะที่equals()ไม่ต้องกังวลอีกต่อไปและส่งคืนเท็จทันที

ในความคิดของฉันเราควรใช้สองสิ่งนี้ตามที่ตั้งใจไว้:

• equals() เพื่อตรวจสอบความเท่าเทียมกันและ
• compareTo() เพื่อค้นหาคำสั่งซื้อ

เท่ากับ () ตรวจสอบว่าสองสตริงเท่ากันหรือไม่มันให้ค่าบูลีน CompareTo () ตรวจสอบว่าสตริงอ็อบเจกต์เท่ากับมากกว่าหรือเล็กกว่ากับอ็อบเจ็กต์สตริงอื่นหรือไม่โดยให้ผลลัพธ์เป็น: 1 ถ้าอ็อบเจ็กต์สตริงมีค่ามากกว่า 0 ถ้าทั้งสองมีค่าเท่ากัน -1 ถ้าสตริงมีขนาดเล็กกว่าสตริงอื่น

EQ:

String a = "Amit";
String b = "Sumit";
String c = new String("Amit");
System.out.println(a.equals(c));//true
System.out.println(a.compareTo(c)); //0
System.out.println(a.compareTo(b)); //1

มีบางสิ่งที่คุณต้องจำไว้ในขณะที่การลบล้าง CompareTo ใน Java เช่น Compareto ต้องสอดคล้องกับการเท่ากับและการลบไม่ควรใช้ในการเปรียบเทียบฟิลด์จำนวนเต็มเนื่องจากสามารถล้นได้ ตรวจสอบสิ่งที่ต้องจำขณะลบล้างตัวเปรียบเทียบใน Javaเพื่อดูรายละเอียด

นี่คือการทดลองในเรื่องเวทมนตร์ :-)

คำตอบส่วนใหญ่เปรียบเทียบประสิทธิภาพและความแตกต่างของ API พวกเขาพลาดประเด็นพื้นฐานที่ว่าการดำเนินการทั้งสองมีความหมายต่างกัน

สัญชาตญาณของคุณถูกต้อง x.equals (y) ไม่สามารถใช้แทนกันได้กับ x.compareTo (y) == 0 ตัวแรกเปรียบเทียบข้อมูลประจำตัวในขณะที่อีกตัวเปรียบเทียบความคิดของ 'ขนาด' เป็นความจริงที่ว่าในหลาย ๆ กรณีโดยเฉพาะอย่างยิ่งกับประเภทดั้งเดิมทั้งสองนี้สอดคล้องกัน

กรณีทั่วไปคือ:

ถ้า x และ y เหมือนกันจะมี 'ขนาด' เท่ากัน: ถ้า x.equals (y) เป็นจริง => x.compareTo (y) คือ 0

อย่างไรก็ตามหาก x และ y มีขนาดเท่ากันก็ไม่ได้หมายความว่าจะเหมือนกัน

ถ้า x.compareTo (y) เป็น 0 ไม่จำเป็นต้องหมายความว่า x.equals (y) เป็นจริง

ตัวอย่างที่น่าสนใจซึ่งข้อมูลประจำตัวแตกต่างจากขนาดคือจำนวนเชิงซ้อน สมมติว่าการเปรียบเทียบทำได้โดยค่าสัมบูรณ์ ดังนั้นให้สองจำนวนเชิงซ้อน: Z1 = a1 + b1 * i และ Z2 = a2 + b2 * i:

Z1.equals (z2) ส่งกลับค่าจริงถ้า a1 = a2 และ b1 = b2 เท่านั้น

อย่างไรก็ตาม Z1.compareTo (Z2) จะคืนค่า 0 สำหรับและจำนวนอนันต์ของคู่ (a1, b1) และ (a2, b2) ตราบใดที่พวกมันเป็นไปตามเงื่อนไข a1 ^ 2 + b1 ^ 2 == a2 ^ 2 + b2 ^ 2

การเท่ากับสามารถมีประสิทธิภาพมากกว่าแล้วเปรียบเทียบ

หากความยาวของลำดับอักขระใน String ไม่ตรงกันจะไม่มีทางที่ Strings จะเท่ากันดังนั้นการปฏิเสธจะเร็วขึ้นมาก

ยิ่งไปกว่านั้นถ้าเป็นวัตถุเดียวกัน (ความเท่าเทียมกันของตัวตนแทนที่จะเป็นความเท่าเทียมทางตรรกะ) ก็จะมีประสิทธิภาพมากขึ้นเช่นกัน

หากพวกเขาใช้การแคช hashCode ด้วยอาจเป็นการเร็วกว่าที่จะปฏิเสธการไม่เท่ากับในกรณีที่ hashCode ไม่ตรงกัน

String.equals()ต้องมีการเรียกใช้instanceofตัวดำเนินการในขณะที่compareTo()ไม่ต้องการ เพื่อนร่วมงานของฉันสังเกตเห็นเมนูแบบเลื่อนลงของประสิทธิภาพจำนวนมากที่เกิดจากวิธีการinstanceofโทรจำนวนมากเกินไปequals()อย่างไรก็ตามการทดสอบของฉันพิสูจน์แล้วว่าcompareTo()เร็วกว่าเล็กน้อยเท่านั้น

อย่างไรก็ตามฉันใช้ Java 1.6 ในเวอร์ชันอื่น ๆ (หรือผู้จำหน่าย JDK รายอื่น) ความแตกต่างอาจมากกว่านี้

การทดสอบเปรียบเทียบสตริงแต่ละรายการในอาร์เรย์องค์ประกอบ 1,000 รายการซ้ำ 10 ครั้ง

1. equalsสามารถใช้ Object ใด ๆ เป็นพารามิเตอร์ แต่compareToสามารถรับได้เฉพาะ String

2. เมื่อดาวหางเป็นโมฆะcompareToจะทำให้เกิดข้อยกเว้น

3. compareToเมื่อคุณต้องการที่จะทราบว่าแตกต่างเกิดขึ้นคุณสามารถใช้

• equals: จำเป็นสำหรับการตรวจสอบความเท่าเทียมกันและ จำกัด รายการที่ซ้ำกัน Java Library หลายคลาสใช้สิ่งนี้ในกรณีที่ต้องการค้นหารายการที่ซ้ำกัน เช่นHashSet.add(ob1)จะเพิ่มก็ต่อเมื่อไม่มีอยู่ equals()ดังนั้นหากคุณกำลังขยายชั้นเรียนบางอย่างเช่นแทนที่แล้วนี้

• compareTo: จำเป็นสำหรับการจัดลำดับองค์ประกอบ อีกครั้งสำหรับการเรียงลำดับที่เสถียรคุณต้องการความเท่าเทียมกันดังนั้นจึงมีผลตอบแทนเป็น 0

เท่ากับ -

1- แทนที่เมธอด GetHashCode เพื่อให้ชนิดทำงานได้อย่างถูกต้องในตารางแฮช

2- อย่าโยนข้อยกเว้นในการใช้วิธีการเท่ากับ ให้ส่งคืนเท็จแทนสำหรับอาร์กิวเมนต์ว่าง

3-

  x.Equals(x) returns true.

  x.Equals(y) returns the same value as y.Equals(x).

  (x.Equals(y) && y.Equals(z)) returns true if and only if x.Equals(z) returns true.

การเรียกใช้ x.Equals (y) ต่อเนื่องส่งคืนค่าเดียวกันตราบเท่าที่วัตถุที่อ้างถึงโดย x และ y จะไม่ถูกแก้ไข

x.Equals(null) returns false.

4- สำหรับวัตถุบางประเภทเป็นที่พึงปรารถนาที่จะให้มีการทดสอบ Equals เพื่อหาความเท่าเทียมกันของค่าแทนความเท่าเทียมกันของการอ้างอิง การปรับใช้ Equals ดังกล่าวจะคืนค่าจริงหากวัตถุทั้งสองมีค่าเท่ากันแม้ว่าจะไม่ใช่อินสแตนซ์เดียวกันก็ตาม

ตัวอย่างเช่น -

   Object obj1 = new Object();
   Object obj2 = new Object();
   Console.WriteLine(obj1.Equals(obj2));
   obj1 = obj2; 
   Console.WriteLine(obj1.Equals(obj2)); 

เอาท์พุท: -

False
True

ในขณะที่เปรียบเทียบถึง-

เปรียบเทียบอินสแตนซ์ปัจจุบันกับออบเจ็กต์อื่นในประเภทเดียวกันและส่งกลับจำนวนเต็มที่ระบุว่าอินสแตนซ์ปัจจุบันนำหน้าตามหลังหรือเกิดขึ้นในตำแหน่งเดียวกันในลำดับการจัดเรียงกับอ็อบเจ็กต์อื่น

ผลตอบแทน -

น้อยกว่าศูนย์ - อินสแตนซ์นี้นำหน้า obj ในลำดับการจัดเรียง ศูนย์ - อินสแตนซ์นี้เกิดขึ้นในตำแหน่งเดียวกันในลำดับการจัดเรียงเป็น obj มากกว่าศูนย์ - อินสแตนซ์นี้ตาม obj ในลำดับการจัดเรียง

สามารถโยน ArgumentException ได้หากวัตถุไม่ใช่ประเภทเดียวกับอินสแตนซ์

ตัวอย่างเช่นคุณสามารถเยี่ยมชมได้ที่นี่

ดังนั้นฉันขอแนะนำให้ใช้ Equals แทนการเปรียบเทียบถึงจะดีกว่า

"เท่ากับ" เปรียบเทียบอ็อบเจ็กต์และส่งคืนจริงหรือเท็จและ "เปรียบเทียบเป็น" ส่งคืน 0 หากเป็นจริงหรือตัวเลข [> 0] หรือ [<0] หากเป็นเท็จตัวอย่าง:

<!-- language: lang-java -->
//Objects Integer
Integer num1 = 1;
Integer num2 = 1;
//equal
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));
//New Value
num2 = 3;//set value
//diferent
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));

ผล:

num1.equals(num2) =true
num1.compareTo(num2) =0
num1.equals(num2) =false
num1.compareTo(num2) =-1

เอกสารเปรียบเทียบกับ: https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html

สมการเอกสาร: https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

สิ่งหนึ่งที่สำคัญในขณะที่ใช้compareTo()มากกว่าequals()นั้นcompareToใช้ได้กับคลาสที่ใช้อินเทอร์เฟซ 'เปรียบเทียบได้' มิฉะนั้นจะทำให้ไฟล์NullPointerException. Stringคลาสใช้อินเทอร์เฟซที่เปรียบเทียบได้ในขณะที่StringBufferคุณไม่สามารถใช้"foo".compareTo("doo")ในStringวัตถุ แต่ไม่สามารถใช้ในStringBufferObject ได้

String s1 = "a";
String s2 = "c";

System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

สิ่งนี้พิมพ์ -2 และเท็จ

String s1 = "c";
String s2 = "a";
System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

สิ่งนี้พิมพ์ 2 และเท็จ

String s1 = "c";
String s2 = "c";
System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

สิ่งนี้พิมพ์ 0 และจริง

เท่ากับส่งคืนบูลีนในกรณีที่สตริงทั้งสองตรงกันเท่านั้น

CompareTo มีขึ้นเพื่อไม่เพียงแค่บอกว่ามันตรงกัน แต่ยังบอกด้วยว่า String ใดน้อยกว่าอีกตัวหนึ่งและยังรวมถึงจำนวนตามศัพท์ด้วย ส่วนใหญ่จะใช้ในขณะจัดเรียงในคอลเล็กชัน

ผมเชื่อequalsและequalsIgnoreCaseวิธีการของStringการกลับมาtrueและfalseซึ่งจะเป็นประโยชน์ถ้าคุณต้องการที่จะเปรียบเทียบค่าของวัตถุสตริง แต่ในกรณีของการดำเนินการcompareToและcompareToIgnoreCaseวิธีการผลตอบแทนบวกลบและความคุ้มค่าเป็นศูนย์ซึ่งจะเป็นประโยชน์ในกรณีของการเรียงลำดับ