Almindelige strengoperationer i Java

1. Introduktion

Strengbaserede værdier og operationer er ret almindelige i den daglige udvikling, og enhver Java-udvikler skal være i stand til at håndtere dem.

I denne vejledning giver vi et hurtigt snydeark af almindeligt Snor operationer.

Derudover kaster vi lys over forskellene mellem lige med og “==” og imellem StringUtils # isBlank og #er tom.

2. Omdannelse af en char til en streng

EN char repræsenterer et tegn i Java. Men i de fleste tilfælde har vi brug for en Snor.

Så lad os starte med at transformere chars ind i Snors:

String toStringWithConcatenation (final char c) {return String.valueOf (c); }

3. Tilføjelse af strenge

En anden ofte nødvendig handling er at tilføje strenge med andre værdier, som f.eks char:

String appendWithConcatenation (final String prefix, final char c) {return prefix + c; }

Vi kan tilføje andre grundlæggende typer med en StringBuilder såvel:

String appendWithStringBuilder (final String prefix, final char c) {return new StringBuilder (prefix) .append (c) .toString (); }

4. Få et tegn efter indeks

Hvis vi har brug for at udtrække et tegn ud af en streng, giver API'en alt, hvad vi vil have:

char getCharacterByIndex (final String text, final int index) {return text.charAt (index); }

Siden en Snor bruger en char [] som en bagvedliggende datastruktur, indekset starter ved nul.

5. Håndtering af ASCII-værdier

Vi kan let skifte mellem en char og dens numeriske repræsentation (ASCII) ved støbning:

int asciiValue (final char character) {return (int) character; } char fraAsciiValue (final int værdi) {Assert.isTrue (værdi> = 0 && værdi <65536, "værdi er ikke et gyldigt tegn"); returneringsværdi (char) }

Selvfølgelig, siden en int er 4 usignerede byte og en char er 2 usignerede byte, skal vi kontrollere for at sikre, at vi arbejder med juridiske karakterværdier.

6. Fjernelse af al hvidt mellemrum

Nogle gange er vi nødt til at slippe af med nogle tegn, oftest mellemrum. EN god måde er at bruge udskift alle metode med et regulært udtryk:

String removeWhiteSpace (endelig strengtekst) {return text.replaceAll ("\ s +", ""); }

7. Deltagelse i samlinger til en streng

En anden almindelig brugssag er, når vi har en slags Kollektion og ønsker at oprette en streng ud af den:

 String fromCollection (final Collection collection) {return collection.stream (). Map (Objects :: toString) .collect (Collectors.joining (",")); }

Bemærk, at Samlere. Tilslutter sig tillader angivelse af præfikset eller suffikset.

8. Opdeling af en streng

Eller på den anden side kan vi opdele en streng ved en afgrænser ved hjælp af dele metode:

String [] splitByRegExPipe (final String text) return text.split ("\

Igen bruger vi et regelmæssigt udtryk her, denne gang til at splitte med et rør. Da vi ønsker at bruge en speciel karakter, er vi nødt til at undslippe den.

En anden mulighed er at bruge Mønster klasse:

String [] splitByPatternPipe (final String text) ")); 

9. Behandling af alle tegn som en stream

I tilfælde af detaljeret behandling kan vi omdanne en streng til en IntStream:

IntStream getStream (sidste strengtekst) {return text.chars (); }

10. Referencelighed og værdilighed

Selvom strenge ligner en primitiv type, de er det ikke.

Derfor er vi nødt til at skelne mellem reference lighed og værdi lighed. Reference lighed indebærer altid værdi lighed, men generelt ikke omvendt. Den første kontrollerer vi med '==' operationen og sidstnævnte med lige med metode:

@Test offentlig ugyldig, nårUsingEquals_thenWeCheckForTheSameValue () {assertTrue ("Værdierne er lige", nye streng ("Test"). Er lig med ("Test")); } @Test offentlig ugyldig nårUsingEqualsSign_thenWeCheckForReferenceEquality () {assertFalse ("Referencer er ikke lige", ny streng ("Test") == "Test"); }

Bemærk, at bogstaver er interneret i strengpoolen. Derfor kan compileren til tider optimere dem til den samme reference:

@Test offentligt ugyldigt nårTheCompileCanBuildUpAString_thenWeGetTheSameReference () {assertTrue ("Litteratur sammenkobles af kompilatoren", "Test" == "Te" + "st"); }

11. Tom streng vs. tom streng

Der er en subtil forskel mellem er tom og er tom.

En streng er tom, hvis den er nul eller har længde nul. Mens en streng er tom, hvis den er nul eller kun indeholder mellemrumstegn:

@Test offentlig ugyldig nårUsingIsEmpty_thenWeCheckForNullorLengthZero () {assertTrue ("null er tom", isEmpty (null)); assertTrue ("intet er tomt", isEmpty ("")); assertFalse ("hvidt mellemrum er ikke tomt", isEmpty ("")); assertFalse ("hvidt mellemrum er ikke tomt", isEmpty ("\ n")); assertFalse ("hvidt mellemrum er ikke tomt", er tomt ("\ t")); assertFalse ("teksten er ikke tom", isEmpty ("Alt!")); } @Test offentlig ugyldigt nårUsingIsBlank_thenWeCheckForNullorOnlyContainingWhitespace () {assertTrue ("null er blank", isBlank (null)); assertTrue ("intet er tomt", isBlank ("")); assertTrue ("hvidt mellemrum er tomt", isBlank ("\ t \ t \ t \ n \ r")); assertFalse ("test er ikke blank", isBlank ("Alt!")); }

12. Konklusion

Strenge er en kernetype i alle slags applikationer. I denne vejledning lærte vi nogle nøgleoperationer i almindelige scenarier.

Desuden gav vi anvisninger til mere detaljerede referencer.

Endelig er den fulde kode med alle eksempler tilgængelig i vores GitHub-lager.