streamalism.org

1. Oversigt

I denne artikel vil vi tale om de forskellige måder at sammenligne på Strenge i Java.

Som Snor er en af ​​de mest anvendte datatyper i Java, dette er naturligvis en meget almindeligt anvendt operation.

2. Snor Sammenligning med Snor Klasse

2.1. Ved brug af “==” Sammenligningsoperatør

Brug af “==” operatoren til sammenligning af tekstværdier er en af ​​de mest almindelige fejl, Java begyndere laver. Dette er forkert, fordi “==” kontrollerer kun henvisningens lighed med to Strenge, hvilket betyder, hvis de henviser til det samme objekt eller ej.

Lad os se et eksempel på denne adfærd:

String string1 = "bruger sammenligningsoperator"; String string2 = "bruger sammenligningsoperator"; Strengstreng3 = ny streng ("ved hjælp af sammenligningsoperator"); assertThat (string1 == string2) .isTrue (); assertThat (string1 == string3) .isFalse ();

I eksemplet ovenfor er den første påstand sand, fordi de to variabler peger på det samme Snor bogstavelig.

På den anden side er den anden påstand falsk, fordi streng1 er skabt med en bogstavelig og streng3 oprettes ved hjælp af ny operatør - derfor refererer de til forskellige objekter.

2.2. Ved brug af lige med()

Det Snor klasse tilsidesætter lige med() arvet fra Objekt. Denne metode sammenligner to Strenge karakter for karakter, ignorerer deres adresse.

Det betragter dem som lige, hvis de er af samme længde, og tegnene er i samme rækkefølge:

String string1 = "ved hjælp af ligemetoden"; String string2 = "ved hjælp af ligemetoden"; String string3 = "ved hjælp af EQUALS-metoden"; Strengstreng4 = ny streng ("ved hjælp af ligemetoden"); assertThat (string1.equals (string2)). isTrue (); assertThat (string1.equals (string4)). isTrue (); assertThat (string1.equals (null)). isFalse (); assertThat (string1.equals (string3)). isFalse ();

I dette eksempel streng1, streng2, og streng4 variabler er ens, fordi de har samme sag og værdi uanset deres adresse.

Til streng3 metoden vender tilbage falsk, da det er store og små bogstaver

Også, hvis nogen af ​​de to strenge er nul, så vender metoden tilbage falsk.

2.3. Ved brug af er lig medIgnoreCase ()

Det er lig medIgnoreCase () metode returnerer en boolsk værdi. Som navnet antyder denne metode ignorerer kabinet i tegn, mens man sammenligner Strenge:

String string1 = "brug af lig med ignorere store og små bogstaver"; String string2 = "BRUGER EQUALS IGNORE CASE"; assertThat (string1.equalsIgnoreCase (string2)). isTrue ();

2.4. Ved brug af sammenligne med()

Det sammenligne med() metode returnerer en int type værdi og sammenligner to Strenge karakter for karakter leksikografisk baseret på en ordbog eller naturlig ordning.

Denne metode returnerer 0, hvis to Strenge er ens, eller hvis begge er nul, et negativt tal, hvis det første Snor kommer før argumentet, og et tal større end nul, hvis det første Snor kommer efter argumentet Snor.

Lad os se et eksempel:

Stringforfatter = "forfatter"; String book = "book"; String duplicateBook = "book"; assertThat (author.compareTo (book)) .isEqualTo (-1); assertThat (book.compareTo (forfatter)) .isEqualTo (1); assertThat (duplikatBook.compareTo (bog)) .isEqualTo (0);

2.5. Ved brug af CompareToIgnoreCase ()

Det CompareToIgnoreCase () svarer til den foregående metode, bortset fra at den ignorerer tilfældet:

Stringforfatter = "Forfatter"; String book = "book"; String duplicateBook = "BOOK"; assertThat (author.compareToIgnoreCase (bog)) .isEqualTo (-1); assertThat (book.compareToIgnoreCase (forfatter)) .isEqualTo (1); assertThat (duplikatBook.compareToIgnoreCase (bog)) .isEqualTo (0);

3. Snor Sammenligning med Objekter Klasse

Objekter er en hjælpeklasse, der indeholder en statisk lige med() metode, nyttig i dette scenarie - for at sammenligne to Strenge.

Metoden vender tilbage rigtigt hvis to Strenge er ens med først sammenligne dem ved hjælp af deres adresse dvs. “==”. Derfor, hvis begge argumenter er nul, det vender tilbage rigtigt og hvis nøjagtigt et argument er nul, det returnerer falsk.

Ellers kalder det simpelthen lige med() metode til det godkendte arguments type klasse - hvilket i vores tilfælde er String's klasse lige med() metode. Denne metode er store og små bogstaver, fordi den internt kalder Snor klassens lige med() metode.

Lad os teste dette:

String string1 = "brug af objekter er lig med"; String string2 = "at bruge objekter er lig med"; String string3 = new String ("at bruge objekter er lig med"); assertThat (Objects.equals (string1, string2)). isTrue (); assertThat (Objects.equals (string1, string3)). isTrue (); assertThat (Objects.equals (null, null)). isTrue (); assertThat (Objects.equals (null, string1)). er Falsk ();

4. Snor Sammenligning med Apache Commons

Apache Commons-biblioteket indeholder en hjælpeklasse kaldet StringUtils til Snor-relaterede operationer; dette har også nogle meget gavnlige metoder til Snor sammenligning.

4.1. Ved brug af lige med() og er lig medIgnoreCase ()

Det lige med() metode til StringUtils klasse er en forbedret version af Snor klassemetode lige med(), som også håndterer nulværdier:

assertThat (StringUtils.equals (null, null)) .isTrue (); assertThat (StringUtils.equals (null, "er lig med metode")) .isFalse (); assertThat (StringUtils.equals ("er lig med metode", "er lig med metode")) .isTrue (); assertThat (StringUtils.equals ("er lig med metode", "LIGE METODE")) .isFalse ();

Det er lig medIgnoreCase () metode til StringUtils returnerer a boolsk værdi. Dette fungerer på samme måde som lige med(), bortset fra at det ignorerer omslag af tegn i Strenge:

assertThat (StringUtils.equalsIgnoreCase ("er lig med metode", "er lig med metode")). isTrue (); assertThat (StringUtils.equalsIgnoreCase ("lig metode", "LIGE METODE")) .isTrue ();

4.2. Ved brug af er lig med Enhver () og er lig medAnyIgnoreCase ()

Det er lig med Enhver () metodens første argument er en Snor og den anden er en multi-args-type CharSequence. Metoden vender tilbage rigtigt hvis noget af det andet er givet Strenge kamp mod den første Snor tilfælde følsomt.

Ellers returneres false:

assertThat (StringUtils.equalsAny (null, null, null)) .isTrue (); assertThat (StringUtils.equalsAny ("er lig med enhver", "er lig med enhver", "enhver")) .isTrue (); assertThat (StringUtils.equalsAny ("er lig med enhver", null, "er lig med enhver")) .isTrue (); assertThat (StringUtils.equalsAny (null, "er lig med", "enhver")) .isFalse (); assertThat (StringUtils.equalsAny ("er lig med enhver", "LIGER ALLE", "ALLE")) .isFalse ();

Det er lig medAnyIgnoreCase () metoden fungerer på samme måde som er lig med Enhver () metode, men ignorerer også beklædning:

assertThat (StringUtils.equalsAnyIgnoreCase ("ignorere sag", "IGNORE CASE", "enhver")). isTrue ();

4.3. Ved brug af sammenligne() og sammenlignIgnoreCase ()

Det sammenligne() metode i StringUtils klasse er en null-sikker version af sammenligne med() metode til Snor klasse og håndtag nul værdier efter overvejer en nul værdi mindre end a ikke-nul værdi. To nul værdier betragtes som lige.

Desuden kan denne metode bruges til at sortere en liste over Strenge med nul poster:

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);

Det sammenlignIgnoreCase () metoden opfører sig på samme måde, bortset fra at den ignorerer hylster:

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

De to metoder kan også bruges med en nullIsLess mulighed. Dette er en tredjedel boolsk argument, der afgør, om nulværdier skal betragtes som mindre eller ej.

EN nul værdi er lavere end en anden Snor hvis nullIsLess er sandt og højere hvis nullIsLess er falsk.

Lad os prøve det:

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

Det sammenlignIgnoreCase () metode med en tredjedel boolsk argument fungerer på samme måde, undtagen ved at ignorere sagen.

5. Konklusion

I denne hurtige vejledning diskuterede vi forskellige måder at sammenligne på Strenge.

Og som altid kan kildekoden til eksemplerne findes på GitHub.