streamalism.org

1. Introduksjon

I denne korte opplæringen ser vi flere måter å fjerne ledende og etterfølgende tegn fra a String. For enkelhets skyld fjerner vi nuller i eksemplene.

For hver implementering lager vi to metoder: en for å lede og en for å følge nuller.

Dette problemet har en kantstilfelle: hva vil vi gjøre når inngangen bare inneholder nuller? Returner en tom String, eller a String inneholder et enkelt nullpunkt? Vi ser implementeringer for begge brukssaker i hver av løsningene.

Vi har enhetstester for hver implementering, som du finner på GitHub.

2. Bruke StringBuilder

I vår første løsning oppretter vi en StringBuilder med originalen String, og vi sletter de unødvendige tegnene fra begynnelsen eller slutten:

String removeLeadingZeroes (String s) {StringBuilder sb = nye StringBuilder (s); mens (sb.length ()> 0 && sb.charAt (0) == '0') {sb.deleteCharAt (0); } returner sb.toString (); } Streng removeTrailingZeroes (String s) {StringBuilder sb = nye StringBuilder (s); mens (sb.length ()> 0 && sb.charAt (sb.length () - 1) == '0') {sb.setLength (sb.length () - 1); } returner sb.toString (); }

Merk at vi bruker StringBuilder.setLength () i stedet for StringBuilder.deleteCharAt () når vi fjerner etterfølgende nuller fordi det også sletter de siste tegnene og det er mer performant.

Hvis vi ikke vil returnere en tom String når inngangen bare inneholder nuller, er det eneste vi trenger å gjøre stopp loop hvis det bare er ett tegn igjen.

Derfor endrer vi sløyfetilstanden:

String removeLeadingZeroes (String s) {StringBuilder sb = nye StringBuilder (s); mens (sb.length ()> 1 && sb.charAt (0) == '0') {sb.deleteCharAt (0); } returner sb.toString (); } Streng removeTrailingZeroes (String s) {StringBuilder sb = nye StringBuilder (s); mens (sb.length ()> 1 && sb.charAt (sb.length () - 1) == '0') {sb.setLength (sb.length () - 1); } returner sb.toString (); }

3. Bruke String.subString ()

I denne løsningen når vi fjerner ledende eller etterfølgende nuller, vi finn posisjonen til det første eller siste tegnet som ikke er null.

Etter det trenger vi bare ringe substring (), for å returnere de gjenværende delene:

String removeLeadingZeroes (String s) {int-indeks; for (index = 0; index = 0; index--) {if (s.charAt (index)! = '0') {break; }} returner s.substring (0, indeks + 1); }

Merk at vi må erklære variabelen indeks før for loop fordi vi ønsker å bruke variabelen utenfor loopens omfang.

Vær også oppmerksom på at vi må se etter tegn som ikke er null manuelt, siden String.indexOf () og String.lastIndexOf () fungerer bare for nøyaktig samsvar.

Hvis vi ikke vil returnere en tom String, må vi gjøre det samme som før: endre sløyfetilstanden:

String removeLeadingZeroes (String s) {int-indeks; for (index = 0; index 0; index--) {if (s.charAt (index)! = '0') {break; }} returner s.substring (0, indeks + 1); }

4. Bruke Apache Commons

Apache Commons har mange nyttige klasser, inkludert org.apache.commons.lang.StringUtils. For å være mer presis, er denne klassen i Apache Commons Lang3.

4.1. Avhengigheter

Vi kan bruke Apache Commons Lang3 ved å sette inn denne avhengigheten i vår pom.xml fil:

 org.apache.commons commons-lang3 3.8.1 

4.2. Gjennomføring

I StringUtils klasse, har vi metodene stripStart () og stripEnd (). De fjerner henholdsvis ledende og etterfølgende tegn.

Siden det er akkurat det vi trenger, er løsningen vår ganske grei:

String removeLeadingZeroes (String s) {return StringUtils.stripStart (s, "0"); } Streng removeTrailingZeroes (String s) {return StringUtils.stripEnd (s, "0"); }

Dessverre kan vi ikke konfigurere, hvis vi vil fjerne alle forekomster eller ikke. Derfor må vi kontrollere det manuelt.

Hvis inngangen ikke var tom, men strippet String er tom, så må vi returnere nøyaktig ett null:

String removeLeadingZeroes (String s) {String stripped = StringUtils.stripStart (s, "0"); hvis (stripped.isEmpty () &&! s.isEmpty ()) {return "0"; } retur strippet; } Streng removeTrailingZeroes (String s) {String stripped = StringUtils.stripEnd (s, "0"); hvis (stripped.isEmpty () &&! s.isEmpty ()) {return "0"; } retur strippet; }

Merk at disse metodene godtar a String som deres andre parameter. Dette String representerer et sett med tegn, ikke en sekvens vi vil fjerne.

For eksempel hvis vi passerer “01”, vil de fjerne alle ledende eller etterfølgende tegn, som er enten ‘0' eller ‘1'.

5. Bruke Guava

Guava tilbyr også mange bruksklasser. For dette problemet kan vi bruke com.google.common.base.CharMatcher, som gir verktøymetoder for å samhandle med samsvarende tegn.

5.1. Avhengigheter

For å bruke Guava, bør vi legge til følgende avhengigheter i vår pom.xml fil:

 com.google.guava guava 27.0.1-jre 

Merk at hvis vi ønsker å bruke Guava i et Android-program, bør vi bruke versjonen 27.0-android i stedet.

5.2. Gjennomføring

I vårt tilfelle er vi interessert i trimLeadingFrom () og trimTrailingFrom ().

Som navnet antyder, fjerner de henholdsvis ledende eller etterfølgende tegn fra a String, som samsvarer med CharMatcher:

String removeLeadingZeroes (String s) {return CharMatcher.is ('0'). TrimLeadingFrom (s); } String removeTrailingZeroes (String s) {return CharMatcher.is ('0'). TrimTrailingFrom (s); }

De har de samme egenskapene som Apache Commons-metodene vi så.

Derfor, hvis vi ikke vil fjerne alle nuller, kan vi bruke det samme trikset:

String removeLeadingZeroes (String s) {String stripped = CharMatcher.is ('0'). TrimLeadingFrom (s); hvis (stripped.isEmpty () &&! s.isEmpty ()) {return "0"; } retur strippet; } String removeTrailingZeroes (String s) {String stripped = CharMatcher.is ('0'). TrimTrailingFrom (s); hvis (stripped.isEmpty () &&! s.isEmpty ()) {return "0"; } retur strippet; }

Merk, at med CharMatcher vi kan lage mer komplekse regler for samsvar.

6. Bruke vanlige uttrykk

Siden problemet vårt er et mønstermatchingsproblem, kan vi bruke vanlige uttrykk: vi vil matche alle nuller i begynnelsen eller slutten av en String.

På toppen av det vil vi fjerne de matchende nullene. Med andre ord, vi vil erstatt dem med ingenting, eller med andre ord, en tom String.

Vi kan gjøre akkurat det, med String.replaceAll () metode:

String removeLeadingZeroes (String s) {return s.replaceAll ("^ 0+", ""); } Streng removeTrailingZeroes (String s) {return s.replaceAll ("0 + $", ""); }

Hvis vi ikke vil fjerne alle nuller, kan vi bruke den samme løsningen som vi brukte med Apache Commons og Guava. Det er imidlertid en ren måte å gjøre dette på: Vi må gi et mønster som ikke samsvarer med helheten String.

På den måten, hvis inngangen bare inneholder nuller, vil regexp-motoren holde nøyaktig en utenfor matchingen. Vi kan gjøre dette med følgende mønstre:

String removeLeadingZeroes (String s) {return s.replaceAll ("^ 0 + (?! $)", ""); } Streng removeTrailingZeroes (String s) {return s.replaceAll ("(?! ^) 0 + $", ""); }

Noter det “(?!^)” og “(?!$)” betyr at det ikke er begynnelsen eller slutten av String henholdsvis.

7. Konklusjon

I denne opplæringen så vi flere måter å fjerne ledende og etterfølgende tegn fra a String. Valget mellom disse implementeringene er ofte bare personlige preferanser.

Som vanlig er eksemplene tilgjengelige på GitHub.