StringUtils-klass från Apache Commons

Introduktion till StringUtils

StringUtils är den mest använda Apache Commons-klassen. Den innehåller olika verktyg och metoder som hjälper utvecklare att undvika att skriva bottenplatta eller helt enkelt svårhanterlig kod för grundläggande operationer.

Många av metoderna i klassen StringUtils har sina java.lang.String -ekvivalenter , men till skillnad från java.lang.String -metoderna är de nollsäkra. Detta innebär att ett NullPointerException inte kastas vid det mest oväntade ögonblicket.

Apache Commons innehåller ett antal metoder, och vi ska titta på några av de mest använda.

Lista över StringUtils-metoder:

StringUtils.isEmpty() och StringUtils.isBlank()

Båda metoderna används för att kontrollera om en sträng innehåller någon text. De returnerar sant om strängen är riktigt tom. Dessutom kommer isBlank() också att returnera true om strängen bara innehåller mellanslag.

De har också sina egna inversa metoder: isNotEmpty() och isNotBlank() .

Låt oss se hur du kan använda isEmpty() tillsammans med dess java.lang.String.isEmpty() motsvarighet , såväl som isBlank() :

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(!nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

Det finns tre variabler av typen String här . En pekar på null , den andra är inte null men har inget innehåll (en tom sträng), och den tredje är inte tom utan kommer att skriva ut ett tomt resultat.

Att köra den här koden resulterar i:

emptyValue is emptyValue
blankValue is blankValue
Exception in thread "main" java.lang.NullPointerException

Metoden isEmpty() inbyggd i java.lang.String är inte null säker . Du får lätt ett NullPointerException om du försöker kontrollera om det är tomt, eftersom du anropar metoden på en nollreferens . Det kommer att vara nödvändigt att kontrollera i förväg om referensen är null:

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(nullValue != null && !nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

Nu resulterar detta i:

emptyValue is emptyValue
blankValue is blankValue

Och om vi testar dessa metoder pånullString:

String nullValue = null;

if(StringUtils.isEmpty(nullValue)) {
   System.out.println("nullValue is emptyValue");
}

if(StringUtils.isBlank(nullValue)) {
   System.out.println("nullValue is blankValue");
}

Då får vi:

nullValue is emptyValue
nullValue is blankValue

StringUtils- metoderna är nullsäkra och ger det förväntade resultatet även om de godkänns null .

StringUtils.equals()

Den här metoden jämför två strängar och returnerar true om de är identiska eller om båda referenserna pekar på null , men tänk på att den här metoden är skiftlägeskänslig.

Låt oss se hur det fungerar:

System.out.println(StringUtils.equals(null, null));
System.out.println(StringUtils.equals(null, "some information"));
System.out.println(StringUtils.equals("some information", null));
System.out.println(StringUtils.equals("some information",  "some information"));
System.out.println(StringUtils.equals("some additional information", "some information"));

Resultat:

true
false
false
true
false

För att jämföra metoden equals() från StringUtils med java.lang.String.equals() :

String nullValue = null;

System.out.println(StringUtils.equals(nullValue, null));
System.out.println(StringUtils.equals(nullValue, "some information"));

System.out.println(nullValue.equals(null));
System.out.println(nullValue.equals("some information"));

Detta tar dig tillbaka till:

true
false
Exception in thread "main" java.lang.NullPointerException

Återigen, anrop av en metod på en nollreferens resulterar i en NullPointerException , och du måste kontrollera om referensvariabeln är null innan du använder den.

StringUtils.compare()

Deklarationen av denna metod ser ut så här:

public static int compare(final String str1, final String str2)

Den här metoden jämför två strängar lexikografiskt, som java.lang.String.compareTo() -metoden gör , och returnerar:

• 0 om str1 är lika med str2 (eller båda är null)
• Värdet är mindre än 0 om str1 är mindre än str2
• Värde större än 0 om str1 är större än str2

Den lexikografiska ordningen är ordboksordningen. Låt oss se hur vi kan använda detta i vårt program:

System.out.println(StringUtils.compare(null, null));
System.out.println(StringUtils.compare(null , "codeGym"));
System.out.println(StringUtils.compare("codeGym", null));
System.out.println(StringUtils.compare("codeGym", "CODEGYM"));
System.out.println(StringUtils.compare("codeGym", "codeGym"));

Vi får:

0
-1
1
32
0

Obs! Ett nollvärde anses vara mindre än ett icke- nullvärde . Två nollvärden anses vara lika .

Kontrollera om en sträng innehåller en annan delsträng

För att göra detta har StringUtils 5 metoder:

• innehåller()
• containsIgnoreCase()
• innehåller Alla()
• innehåller Ingen()
• innehåller endast()

Metoden contains() returnerar true eller false beroende på om söksekvensen finns i en annan sekvens eller inte.

Om null skickas till en sådan metod kommer den att returnera false . Om icke- null skickas kommer metoden helt enkelt att anropa java.lang.String.indexOf(String str) på det skickade objektet.

Exempel:

String value = "CodeGym is cool";

System.out.println(StringUtils.contains(null, "a"));
System.out.println(StringUtils.contains(value, "CodeGym"));
System.out.println(StringUtils.contains(value, "C++"));
System.out.println(StringUtils.contains(value, "codegym"));

Metoden är skiftlägeskänslig, så det senaste anropet kommer också att returnera false :

false
true
false
false

Metoden containsAny() returnerar true om strängen som skickas som det första argumentet innehåller minst en av delsträngarna som skickas i 2-N-argumenten.

Exempel:

String value = "CodeGym is cool";
System.out.println(StringUtils.containsAny(value, "cool", "c00l", "bro", "hello"));

Kommer att visa:

true

Denna metod är också skiftlägeskänslig.

containsNone()-metoden

När du behöver kontrollera att en viss sträng inte innehåller något från listan kan du använda metoden containsNone() . Den första parametern är en sträng och följande parametrar är strängar som inte ska finnas i målsänkan.

Exempel:

String s = "CodeGym is cool";
System.out.println(StringUtils.containsNone(s, 'g', 'a'));

Konsolutgång:

false

Arbeta med delsträngar

Att arbeta med delsträngar liknar att arbeta med metoder i klassen String :

substring(String str, int start)
substring (String str, int start, int end)

Dessa metoder returnerar en delsträng från strängen str . Strängen ges av två index: start och slut . Och som vanligt i Java är det sista tecknet i intervallet end-1 . Vad är fördelen med dessa metoder?

Om du skickar null till en sådan metod kommer den helt enkelt att returnera null istället för att skapa ett undantag. Dessa metoder stöder negativa indexvärden. I det här fallet betraktas strängen som en sluten slinga. Det sista tecknet följs av det första och så vidare.

Låt oss se hur vi kan använda det:

System.out.println(StringUtils.substring("lets java", 2, 6));
System.out.println(StringUtils.substring("lets java", -8));
System.out.println(StringUtils.substring(null, 3));

Att köra koden ovan ger oss:

ts j
ets java
null

StringUtils.split()

En metod som låter dig dela upp en sträng i delsträngar med hjälp av ett speciellt avgränsningstecken. Om det finns en i målsträngen kommer metoden att returnera en array av delsträngar. Om det inte finns något tecken kommer en tom array att returneras. Tja, om null skickas till metoden kommer den att returnera null . Låt oss ta en titt på den här koden och hur metoden fungerar:

String myData = "Address, City, State, Zip, Phone, Email, Password";

System.out.println(Arrays.toString(StringUtils.split(myData, ',')));
System.out.println(Arrays.toString(StringUtils.split(null, '.')));
System.out.println(Arrays.toString(StringUtils.split("", '.')));

Resultat:

[Address,  City,  State,  Zip,  Phone,  Email,  Password]
null
[]

StringUtils.join()

Metoden join() låter dig sammanfoga en array av strängar till en enda sträng. Samtidigt kan ett speciellt separatortecken skickas till den, som kommer att läggas till mellan delsträngar i den resulterande strängen. Och om null skickas till metoden kommer den att returnera null .

Denna metod är raka motsatsen till split()- metoden . Låt oss titta på detta enkla exempel:

String myData = "Address, City, State, Zip, Phone, Email, Password";

String[] myString =  StringUtils.split(myData, ',');
System.out.println(StringUtils.join(myString, '-'));

Att köra koden ovan ger oss:

Address- City- State- Zip- Phone- Email- Password

StringUtils.replace()

Söker efter en sträng i en sträng, hittar den om den finns och ersätter alla förekomster av den med en ny sträng.

Deklarationen av denna metod ser ut så här:

public static String replace(final String text, final String searchString, final String replacement)

Om söksträngen inte hittas i texten kommer ingenting att hända och texten förblir densamma. Enligt samma logik, om texten är null , returnerar denna metod null . Om du letar efter en nollsträng eller ersätter en delsträng med null , kommer metoden att returnera den ursprungliga strängen.

Låt oss prova den här metoden:

String value = "CodeGym is the best";
System.out.println(StringUtils.replace(value, "best", "cool"));

Resultat:

CodeGym is the cool

• Guide till Apache Commons StringUtils-klass i Java
• Apache Commons Java StringUtils Klassguide