השוואת מיתרים בג'אווה

1. סקירה כללית

במאמר זה נדבר על דרכי השוואה שונות מיתרים בג'אווה.

כפי ש חוּט הוא אחד מסוגי הנתונים הנפוצים ביותר ב- Java, באופן טבעי מדובר בפעולה נפוצה מאוד.

2. חוּט להשוות עם חוּט מעמד

2.1. באמצעות “==” מפעיל השוואה

השימוש באופרטור “==” להשוואה בין ערכי טקסט הוא אחת הטעויות הנפוצות ביותר שעושים Java מתחילים. זה לא נכון כי “==” בודק רק את השוויון ההתייחסותי של שניים מיתרים, כלומר אם הם מתייחסים לאותו אובייקט או לא.

בואו נראה דוגמה להתנהגות זו:

String string1 = "באמצעות אופרטור השוואה"; String string2 = "באמצעות אופרטור השוואה"; מחרוזת מחרוזת 3 = מחרוזת חדשה ("באמצעות אופרטור השוואה"); assertThat (string1 == string2) .isTrue (); assertThat (string1 == string3) .isFalse ();

בדוגמה לעיל, הקביעה הראשונה נכונה מכיוון ששני המשתנים מצביעים על אותו דבר חוּט מילולית.

מצד שני, הקביעה השנייה שקרית כי מחרוזת 1 נוצר עם מילולי ו מחרוזת 3 נוצר באמצעות ה- חָדָשׁ מפעיל - לכן הם מתייחסים לאובייקטים שונים.

2.2. באמצעות שווים()

ה חוּט הכיתה עוקפת את שווים() בירושה מ לְהִתְנַגֵד. שיטה זו משווה בין שתיים מיתרים אופי אחר אופי, תוך התעלמות מכתובתם.

הוא רואה אותם שווים אם הם באותו אורך והתווים באותו סדר:

מחרוזת מחרוזת 1 = "בשיטה שווה"; String string2 = "בשיטת שווה"; String string3 = "בשיטת EQUALS"; מחרוזת מחרוזת 4 = מחרוזת חדשה ("בשיטה שווה"); assertThat (string1.equals (string2)). isTrue (); assertThat (string1.equals (string4)). isTrue (); assertThat (string1.equals (null)). isFalse (); assertThat (string1.equals (string3)). isFalse ();

בדוגמה זו, מחרוזת 1, מחרוזת 2, ו מחרוזת 4 המשתנים שווים מכיוון שיש להם אותו מקרה וערך ללא קשר לכתובת שלהם.

ל מחרוזת 3 השיטה חוזרת שֶׁקֶר, מכיוון שהוא תלוי רישיות.

כמו כן, אם אחד משני המיתרים הוא ריקואז השיטה חוזרת שֶׁקֶר.

2.3. באמצעות equalsIgnoreCase ()

ה equalsIgnoreCase () השיטה מחזירה ערך בוליאני. כפי שהשם מרמז על שיטה זו מתעלם ממעטפת בתווים תוך כדי השוואה מיתרים:

String string1 = "באמצעות שווה מקרה להתעלם"; String string2 = "USING EQUALS IGNORE CASE"; assertThat (string1.equalsIgnoreCase (string2)). isTrue ();

2.4. באמצעות בהשוואה ל()

ה בהשוואה ל() שיטה מחזירה int ערך סוג ו משווה בין שניים מיתרים אופי אחר אופי באופן לקסיקוגרפי מבוסס על מילון או סדר טבעי.

שיטה זו מחזירה 0 אם שתיים מיתרים שווים או אם שניהם ריק, מספר שלילי אם הראשון חוּט מגיע לפני הוויכוח, ומספר גדול מאפס אם הראשון חוּט מגיע אחרי הוויכוח חוּט.

בואו נראה דוגמה:

מחבר מחרוזת = "מחבר"; ספר מיתרים = "ספר"; מחרוזת duplicateBook = "ספר"; assertThat (author.compareTo (ספר)). isEqualTo (-1); assertThat (book.compareTo (author)) .isEqualTo (1); assertThat (duplicateBook.compareTo (book)) .isEqualTo (0);

2.5. באמצעות CompareToIgnoreCase ()

ה CompareToIgnoreCase () דומה לשיטה הקודמת, אלא שהיא מתעלמת מהמקרה:

מחבר מחרוזת = "מחבר"; ספר מיתרים = "ספר"; מחרוזת duplicateBook = "ספר"; assertThat (author.compareToIgnoreCase (ספר)) .isEqualTo (-1); assertThat (book.compareToIgnoreCase (מחבר)) .isEqualTo (1); assertThat (duplicateBook.compareToIgnoreCase (ספר)) .isEqualTo (0);

3. חוּט להשוות עם חפצים מעמד

חפצים הוא מחלקת תועלת המכילה סטטי שווים() שיטה, שימושית בתרחיש זה - להשוות בין שניים מיתרים.

השיטה חוזרת נָכוֹן אם שניים מיתרים שווים על ידי ראשון להשוות אותם באמצעות הכתובת שלהם כלומר “==”. כתוצאה מכך, אם שני הטיעונים הם ריק, זה חוזר נָכוֹן ואם בדיוק טיעון אחד הוא ריק, זה מחזיר שקר.

אחרת, זה פשוט קורא שווים() שיטת סוג הטיעון שהועבר - וזה במקרה שלנו מחרוזת מעמד שווים() שיטה. שיטה זו תלויה באותיות רישיות מכיוון שהיא מתקשרת פנימית חוּט כיתות שווים() שיטה.

בואו נבדוק זאת:

String string1 = "שימוש באובייקטים שווה"; String string2 = "שימוש באובייקטים שווה"; מחרוזת מחרוזת 3 = מחרוזת חדשה ("שימוש באובייקטים שווה"); assertThat (Objects.equals (string1, string2)). isTrue (); assertThat (Objects.equals (string1, string3)). isTrue (); assertThat (Objects.equals (null, null)). isTrue (); assertThat (Objects.equals (null, string1)). isFalse ();

4. חוּט להשוות עם אפאצ'י קומונס

ספריית Apache Commons מכילה מחלקת כלי עזר הנקראת StringUtils ל חוּט-פעולות קשורות; יש לכך גם כמה שיטות מועילות מאוד חוּט השוואה.

4.1. באמצעות שווים() ו equalsIgnoreCase ()

ה שווים() שיטה של StringUtils class הוא גרסה משופרת של חוּט שיטת כיתה שווים(), המטפל גם בערכי אפס:

assertThat (StringUtils.equals (null, null)) .isTrue (); assertThat (StringUtils.equals (null, "שווה שווה")) .isFalse (); assertThat (StringUtils.equals ("שווה שווה", "שווה שווה")) .isTrue (); assertThat (StringUtils.equals ("שווה שווה", "שווה שווה")) .isFalse ();

ה equalsIgnoreCase () שיטה של StringUtils מחזירה א בוליאני ערך. זה עובד באופן דומה ל שווים(), אלא שהיא מתעלמת ממעטפת של תווים ב מיתרים:

assertThat (StringUtils.equalsIgnoreCase ("שווה שווה", "שווה שיטה")) .isTrue (); assertThat (StringUtils.equalsIgnoreCase ("שווה שווה", "שווה שווה")) .isTrue ();

4.2. באמצעות שווה לכל () ו equalsAnyIgnoreCase ()

ה שווה לכל () הטיעון הראשון של השיטה הוא א חוּט והשני הוא סוג רב טיעונים CharSequence. השיטה חוזרת נָכוֹן אם כל אחד מהשניים שניתנו מיתרים משחק נגד הראשון חוּט מקרה ברגישות.

אחרת, שקר מוחזר:

assertThat (StringUtils.equalsAny (null, null, null)) .isTrue (); assertThat (StringUtils.equalsAny ("שווה לכל", "שווה לכל", "כל")). isTrue (); assertThat (StringUtils.equalsAny ("שווה לכל", null, "שווה לכל")) .isTrue (); assertThat (StringUtils.equalsAny (null, "שווה", "כל")) .isFalse (); assertThat (StringUtils.equalsAny ("שווה לכל", "שווה לכל", "כל")) .isFalse ();

ה equalsAnyIgnoreCase () השיטה עובדת בדומה ל- שווה לכל () שיטה, אך גם מתעלם ממארז:

assertThat (StringUtils.equalsAnyIgnoreCase ("התעלם ממקרה", "IGNORE CASE", "any")). isTrue ();

4.3. באמצעות לְהַשְׁווֹת() ו CompareIgnoreCase ()

ה לְהַשְׁווֹת() שיטה ב StringUtils הכיתה היא א גרסה בטוחה מאפס של בהשוואה ל() שיטה של חוּט כיתה וידיות ריק ערכים לפי שוקל א ריק ערך פחות מ- a לא אפס ערך. שתיים ריק ערכים נחשבים שווים.

יתר על כן, ניתן להשתמש בשיטה זו למיון רשימה של מיתרים עם ריק ערכים:

assertThat (StringUtils.compare (null, null)) .isEqualTo (0); assertThat (StringUtils.compare (null, "abc")) .isEqualTo (-1); assertThat (StringUtils.compare ("abc", "bbc")) .isEqualTo (-1); assertThat (StringUtils.compare ("bbc", "abc")) .isEqualTo (1);

ה CompareIgnoreCase () השיטה מתנהגת באופן דומה, אלא שהיא מתעלמת ממארז:

assertThat (StringUtils.compareIgnoreCase ("Abc", "bbc")) .isEqualTo (-1); assertThat (StringUtils.compareIgnoreCase ("bbc", "ABC")) .isEqualTo (1); assertThat (StringUtils.compareIgnoreCase ("abc", "ABC")) .isEqualTo (0);

ניתן להשתמש בשתי השיטות גם עם nullIsLess אוֹפְּצִיָה. זה שליש בוליאני טענה המחליטה אם יש להחשיב ערכי null או פחות.

א ריק הערך נמוך יותר מאחר חוּט אם nullIsLess נכון וגבוה יותר אם nullIsLess הוא שקר.

בואו ננסה את זה:

assertThat (StringUtils.compare (null, "abc", true)) .isEqualTo (-1); assertThat (StringUtils.compare (null, "abc", false)) .isEqualTo (1);

ה CompareIgnoreCase () שיטה עם שליש בוליאני הוויכוח עובד באופן דומה, למעט על ידי התעלמות מהמקרה.

5. מסקנה

במדריך מהיר זה דנו בדרכי השוואה שונות מיתרים.

וכמו תמיד, ניתן למצוא את קוד המקור לדוגמאות ב- GitHub.