1. Översikt
I den här artikeln kommer vi att prata om olika sätt att jämföra strängar i Java.
Eftersom String är en av de mest använda datatyperna i Java är detta naturligtvis en mycket vanlig operation.
2. String Jämförelse med String Class
2.1. Använda "==" Jämförelseoperatör
Att använda ”==” för att jämföra textvärden är ett av de vanligaste misstagen som Java-nybörjare gör. Detta är felaktigt eftersom “==” bara kontrollerar referenslikheten för två strängar , vilket betyder om de hänvisar till samma objekt eller inte.
Låt oss se ett exempel på detta beteende:
String string1 = "using comparison operator"; String string2 = "using comparison operator"; String string3 = new String("using comparison operator"); assertThat(string1 == string2).isTrue(); assertThat(string1 == string3).isFalse();I exemplet ovan är det första påståendet sant eftersom de två variablerna pekar på samma sträng bokstavliga.
Å andra sidan är det andra påståendet falskt eftersom sträng1 skapas med en bokstav och sträng3 skapas med den nya operatören - därför refererar de till olika objekt.
2.2. Använda lika ()
Den String klassen åsidosätter lika med () ärvts från Object. Den här metoden jämför två strängar tecken för tecken och ignorerar deras adress.
Det anser att de är lika om de har samma längd och karaktärerna är i samma ordning:
String string1 = "using equals method"; String string2 = "using equals method"; String string3 = "using EQUALS method"; String string4 = new String("using equals method"); assertThat(string1.equals(string2)).isTrue(); assertThat(string1.equals(string4)).isTrue(); assertThat(string1.equals(null)).isFalse(); assertThat(string1.equals(string3)).isFalse();I det här exemplet är variablerna sträng1, sträng2 och sträng4 lika eftersom de har samma fall och värde oavsett adress.
För string3 returnerar metoden falsk, eftersom den är skiftlägeskänslig.
Dessutom, om någon av de två strängarna är noll , returnerar metoden falsk.
2.3. Använda equalsIgnoreCase ()
Den equalsIgnoreCase () returnerar ett booleskt värde. Som namnet antyder ignorerar denna metod höljet i tecken medan man jämför strängar :
String string1 = "using equals ignore case"; String string2 = "USING EQUALS IGNORE CASE"; assertThat(string1.equalsIgnoreCase(string2)).isTrue();2.4. Använda jämförTo ()
Den compareTo () returnerar en int typ värde och jämför två strängar tecken för tecken lexikografiskt baserat på en ordbok eller naturlig beställning.
Den här metoden returnerar 0 om två strängar är lika eller om båda är null, ett negativt tal om den första strängen kommer före argumentet och ett tal större än noll om den första strängen kommer efter argumentet sträng.
Låt oss se ett exempel:
String author = "author"; String book = "book"; String duplicateBook = "book"; assertThat(author.compareTo(book)) .isEqualTo(-1); assertThat(book.compareTo(author)) .isEqualTo(1); assertThat(duplicateBook.compareTo(book)) .isEqualTo(0);2.5. Använda CompareToIgnoreCase ()
Den compareToIgnoreCase () liknar den tidigare metoden, förutom att det ignorerar fallet:
String author = "Author"; String book = "book"; String duplicateBook = "BOOK"; assertThat(author.compareToIgnoreCase(book)) .isEqualTo(-1); assertThat(book.compareToIgnoreCase(author)) .isEqualTo(1); assertThat(duplicateBook.compareToIgnoreCase(book)) .isEqualTo(0);3. String Jämförelse med objekt Class
Objekt är en verktygsklass som innehåller en statisk lika () -metod, användbart i detta scenario - för att jämföra två strängar.
Metoden returnerar true om två strängar är lika genom att först jämföra dem med deras adress, dvs. “ ==” . Följaktligen, om båda argumenten är null , returnerar den true och om exakt ett argument är null returnerar det false.
Annars kallar det helt enkelt metoden equals () för det skickade argumentets typs klass - vilket i vårt fall är String's klass lika () -metoden. Den här metoden är skiftlägeskänslig eftersom den internt kallar String class's equals () -metod.
Låt oss testa detta:
String string1 = "using objects equals"; String string2 = "using objects equals"; String string3 = new String("using objects equals"); 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. Sträng Jämförelse med Apache Commons
Apache Commons-biblioteket innehåller en verktygsklass som heter StringUtils för strängrelaterade operationer ; detta har också några mycket fördelaktiga metoder för strängjämförelse .
4.1. Använda lika () och lika med IgnoreCase ()
De equals () metod för StringUtils klass är en förbättrad version av de String klass metod lika med (), som också hanterar null-värden:
assertThat(StringUtils.equals(null, null)) .isTrue(); assertThat(StringUtils.equals(null, "equals method")) .isFalse(); assertThat(StringUtils.equals("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equals("equals method", "EQUALS METHOD")) .isFalse();Den equalsIgnoreCase () metod för StringUtils returnerar ett booleskt värde. Detta fungerar på samma sätt som lika med (), förutom att det ignorerar höljet av tecken i strängar:
assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD")) .isTrue();4.2. Använda equalsAny () och equalsAnyIgnoreCase ()
Den equalsAny () metoden första argument är en Sträng och den andra är en multi-args typ CharSequence. Metoden blir sant om någon av de andra givna strängarna matchar känsligt mot det första strängfallet .
Annars returneras falskt:
assertThat(StringUtils.equalsAny(null, null, null)) .isTrue(); assertThat(StringUtils.equalsAny("equals any", "equals any", "any")) .isTrue(); assertThat(StringUtils.equalsAny("equals any", null, "equals any")) .isTrue(); assertThat(StringUtils.equalsAny(null, "equals", "any")) .isFalse(); assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY")) .isFalse();Den () equalsAnyIgnoreCase metod fungerar på liknande sätt som () equalsAny metod, men också ignorerar höljet:
assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();4.3. Använd jämför () och jämförIgnoreCase ()
Den jämför () metoden i StringUtils klass är en null-säker version av compareTo () metod för String klass och handtag null värden genom väger en null -värde mindre än en icke-nollvärde. Två nollvärden anses vara lika.
Dessutom kan den här metoden användas för att sortera en lista med strängar med nollposter :
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);De compareIgnoreCase () metoden uppför sig på liknande sätt, förutom att det ignorerar höljet:
assertThat(StringUtils.compareIgnoreCase("Abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compareIgnoreCase("bbc", "ABC")) .isEqualTo(1); assertThat(StringUtils.compareIgnoreCase("abc", "ABC")) .isEqualTo(0);De två metoderna kan också användas med ett nullIsLess- alternativ. Detta är ett tredje booleskt argument som avgör om nollvärden ska betraktas som mindre eller inte .
Ett nollvärde är lägre än en annan sträng om nullIsLess är sant och högre om nullIsLess är falskt.
Låt oss prova det:
assertThat(StringUtils.compare(null, "abc", true)) .isEqualTo(-1); assertThat(StringUtils.compare(null, "abc", false)) .isEqualTo(1);Den compareIgnoreCase () metoden med tredjedel boolean argumentet arbete på liknande sätt, utom genom att ignorera fall.
5. Sammanfattning
I denna snabba handledning diskuterade vi olika sätt att jämföra strängar.
Och som alltid kan källkoden för exemplen hittas på GitHub.