streamalism.org

1. Oversikt

I denne artikkelen vil vi diskutere String formatering i Java ved hjelp av java.util.Formatter klasse, som gir støtte for layoutjustering og justering.

2. Hvordan bruke Formaterer

Husk C-er printf? Formatering av en String i Java føles veldig likt.

De format() metoden for Formaterer eksponeres via en statisk metode fra String klasse. Denne metoden godtar en mal String og en liste over argumenter for å fylle malen med:

Stringhilsener = String.format ("Hei folkens, velkommen til% s!", "Baeldung");

Resultatet String er:

"Hei folkens, velkommen til Baeldung!"

En mal er en String som inneholder noe statisk tekst og en eller flere formatspesifikatorer, som indikerer hvilket argument som skal plasseres på den bestemte posisjonen.

I dette tilfellet, det er et enkelt format spesifiserende % s, som blir erstattet av det tilsvarende argumentet.

3. Formater spesifikatorer

3.1. Generell syntaks

Syntaksen for formatspesifikatorer for Generelt, Karakter, og Numerisk typen er:

% [argument_index $] [flagg] [bredde] [. presisjon] konvertering

Spesifikatorer argument_index, flagg, bredde, og presisjon er valgfrie.

• argument_indeks del er et helt tall Jeg - som indikerer at ith argument fra argumentlisten skal brukes her
• flagg er et sett med tegn som brukes til å endre utdataformatet
• bredde er et positivt heltall som indikerer minimum antall tegn som skal skrives til utdataene
• presisjon er et helt tall som vanligvis brukes til å begrense antall tegn, hvis spesifikke oppførsel avhenger av konverteringen
• er den obligatoriske delen. Det er et tegn som indikerer hvordan argumentet skal formateres. Settet med gyldige konverteringer for et gitt argument avhenger av argumentets datatype

I vårt eksempel ovenfor, hvis vi ønsker å spesifisere nummeret på et argument eksplisitt, kan vi skrive det ved hjelp av 1$ og 2$ argumentindekser.

Begge disse er henholdsvis første og andre argument:

Stringhilsener = String.format ("Hei% 2 $ s, velkommen til% 1 $ s!", "Baeldung", "Folkens");

3.2. Til Dato tid Representasjon

% [argument_index $] [flagg] [bredde] konvertering

Igjen den argument_index, flagg, og bredde er valgfrie.

La oss ta et eksempel for å forstå dette:

@Test offentlig ugyldig nårFormatSpecifierForCalendar_thenGotExpected () {Calendar c = new GregorianCalendar (2017, 11, 10); Streng s = String.format ("Datoen er:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("Datoen er: 12 10,2017", s); }

Her, for hvert format spesifiserende, vil det første argumentet bli brukt, derav 1$. Her hvis vi hopper over argument_indeks for spesifisering av 2. og 3. format, prøver den å finne 3 argumenter, men vi må bruke det samme argumentet for alle 3 formatspesifikatorer.

Så det er ok hvis vi ikke spesifiserer argument _indeks for den første, men vi må spesifisere den for de to andre.

De flagg her består av to tegn. Hvor den første karakteren alltid er en ‘T’ eller ‘T’. Den andre karakteren avhenger av hvilken del av Kalender skal vises.

I vårt eksempel spesifiserer det første formatet tm, indikerer måned formatert med to sifre, te angir dag i måneden og tY angitt år formatert som fire sifre.

3.3. Formater spesifikatorer uten argumenter

% [flagg] [bredde] konvertering

Valgfritt flagg og bredde er de samme som definert i avsnittene ovenfor.

Det nødvendige omdannelse er en karakter eller String som indikerer innholdet som skal settes inn i utgangen. Foreløpig er det bare ‘%' og ny linje ‘N’ kan skrives ut ved hjelp av dette:

@Test offentlig ugyldig nårNoArguments_thenExpected () {String s = String.format ("John scoret 90 %% i høstsemesteret"); assertEquals ("John scoret 90% i høstsemesteret", s); } 

Innsiden format(), hvis vi vil skrive ut ‘%' - vi må unnslippe den ved å bruke ‘%%'.

4. Konverteringer

La oss nå grave inn i alle detaljer i Format Specifier-syntaksen, startende med a omdannelse. Merk at du finner alle detaljene i Formaterer javadocs.

Som vi la merke til i eksemplene ovenfor, omdannelse del kreves i alle formatspesifikatorer, og den kan deles inn i flere kategorier.

La oss ta en titt på hver enkelt ved å ta eksempler.

4.1. Generell

Brukes for alle argumenttyper. De generelle konverteringene er:

1. ‘B’ eller ‘B’ - for Boolsk verdier
2. ‘H’ eller ‘H’ - for HashCode
3. ‘S’ eller ‘S’ - for String, hvis null, det skrives ut "null", ellers arg.toString ()

Vi prøver nå å vise boolsk og String verdier, ved hjelp av tilsvarende konverteringer:

@Test offentlig ugyldig givenString_whenGeneralConversion_thenConvertedString () {String s = String.format ("Det riktige svaret er% s", usant); assertEquals ("Det riktige svaret er usant", s); s = String.format ("Det riktige svaret er% b", null); assertEquals ("Det riktige svaret er usant", s); s = String.format ("Det riktige svaret er% B", sant); assertEquals ("Det riktige svaret er SANT", s); }

4.2. Karakter

Brukes for de grunnleggende typene som representerer Unicode-tegn: røye, karakter, byte, byte, kort, og Kort. Denne konverteringen kan også brukes til typene int og Heltall når Character.isValidCodePoint (int) returnerer ekte for dem.

Det kan skrives som ‘C’ eller 'C' basert på saken vi ønsker.

La oss prøve å skrive ut noen tegn:

@Test offentlig ugyldig givenString_whenCharConversion_thenConvertedString () {String s = String.format ("Det riktige svaret er% c", 'a'); assertEquals ("Det riktige svaret er a", s); s = String.format ("Det riktige svaret er% c", null); assertEquals ("Det riktige svaret er null", s); s = String.format ("Det riktige svaret er% C", 'b'); assertEquals ("Det riktige svaret er B", s); s = String.format ("Det gyldige unicode-tegnet:% c", 0x0400); assertTrue (Character.isValidCodePoint (0x0400)); assertEquals ("Det gyldige unicode-tegnet: Ѐ", s); }

La oss ta et eksempel til med et ugyldig kodepunkt:

@Test (forventet = IllegalFormatCodePointException.class) offentlig ugyldig nårIllegalCodePointForConversion_thenError () {String s = String.format ("The valid unicode character:% c", 0x11FFFF); assertFalse (Character.isValidCodePoint (0x11FFFF)); assertEquals ("Det gyldige unicode-tegnet: Ā", s); }

4.3. Numerisk - Integrert

Disse brukes til Java-integrerte typer: byte, byte, kort, kort, int og Heltall, langt, langt, og BigInteger. Det er tre konverteringer i denne kategorien:

1. ‘D’ - for desimaltall
2. ‘O’ - for oktaltall
3. ‘X’ eller ‘X’ - for heksadesimaltall

La oss prøve å skrive ut hver av disse:

@Test offentlig ugyldig nårNumericIntegralConversion_thenConvertedString () {String s = String.format ("The number 25 in decimal =% d", 25); assertEquals ("Tallet 25 i desimal = 25", s); s = String.format ("Tallet 25 i oktalt =% o", 25); assertEquals ("Tallet 25 i oktalt = 31", s); s = String.format ("Tallet 25 i heksadesimal =% x", 25); assertEquals ("Tallet 25 i heksadesimal = 19", s); }

4.4. Numerisk - flytende punkt

Brukt for Java flytende punkttyper: flyte, flyte, dobbelt, dobbelt, og BigDecimal

1. ‘E’ eller ‘E’ – formatert som desimaltall i datastyrt vitenskapelig notasjon
2. ‘F’ – formatert som et desimaltall
3. ‘G’ eller ‘G’ – basert på presisjonsverdien etter avrunding, formaterer denne konverteringen til datastyrt vitenskapelig notasjon eller desimalformat

La oss prøve å skrive ut flytende tall:

@Test offentlig ugyldig nårNumericFloatingConversion_thenConvertedString () {String s = String.format ("Det datastyrte vitenskapelige formatet på 10000,00" + "=% e", 10000,00); assertEquals ("Det datastyrte vitenskapelige formatet 10000,00 = 1,000000e + 04", s); Streng s2 = String.format ("Desimalformatet 10.019 =% f", 10.019); assertEquals ("Desimalformatet 10.019 = 10.019000", s2); }

4.5. Andre konverteringer

• Dato tid - for Java-typer som kan kode en dato eller et klokkeslett: lang, lang, kalender, Dato og TemporalAccessor. For dette må vi bruke prefiks ‘T’ eller ‘T’, som vi så tidligere
• Prosent - skriver ut bokstavelig ‘% '(‘ \ U0025')
• Linjeseparator - skriver ut en plattformsspesifikk linjeskiller

La oss se på et enkelt eksempel:

@Test offentlig ugyldig nårLineSeparatorConversion_thenConvertedString () {String s = String.format ("First Line% nSecond Line"); assertEquals ("Første linje \ n" + "Andre linje", s); }

5. Flagg

Flagg brukes generelt til å formatere utdataene. Mens det gjelder dato og klokkeslett, brukes de til å spesifisere hvilken del av datoen som skal vises, som vi så i eksempel 4-eksemplet.

En rekke flagg er tilgjengelig, en liste over dem kan du finne i dokumentasjonen.

La oss se et flaggeksempel for å forstå bruken. ‘-‘ brukes til å formatere utdata som venstre begrunnet:

@Test offentlig ugyldig nårSpecifyFlag_thenGotFormattedString () {String s = String.format ("Uten venstre begrunnet flagg:% 5d", 25); assertEquals ("Uten venstre begrunnet flagg: 25", s); s = String.format ("Med venstre begrunnet flagg:% -5d", 25); assertEquals ("Med venstre rettferdiggjort flagg: 25", s); }

6. Presisjon

For generelle konverteringer, presisjon er bare det maksimale antall tegn som skal skrives til utdataene. Mens f eller flytepunktsomregningene er presisjonen antall sifre etter radikspunktet.

Den første utsagnet er et eksempel på presisjon med flytende tall, og den andre med generelle konverteringer:

@Test offentlig ugyldig nårSpecifyPrecision_thenGotExpected () {String s = String.format ("Output of 25.09878 with Precision 2:% .2f", 25.09878); assertEquals ("Output of 25.09878 with Precision 2: 25.10", s); String s2 = String.format ("Output of general conversion type with Precision 2:% .2b", true); assertEquals ("Output of general conversion type with Precision 2: tr", s2); }

7. Argumentindeks

Som nevnt tidligere,argument_indeks er et helt tall som indikerer argumentets plassering i argumentlisten. 1$ indikerer det første argumentet, 2$ det andre argumentet, og så videre.

Det er også en annen måte å referere til argumenter etter posisjon ved å bruke ‘<‘ (‘\ U003c ') flagg, som betyr at argumentet fra forrige formatspesifikator vil bli brukt på nytt. For eksempel vil disse to utsagnene gi den samme utgangen:

@Test offentlig ugyldig nårSpecifyArgumentIndex_thenGotExpected () {Calendar c = Calendar.getInstance (); Streng s = String.format ("Datoen er:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("Datoen er: 12 10,2017", s); s = String.format ("Datoen er:% tm%<>

8. Andre måter å bruke på Formaterer

Inntil nå så vi bruken av format() metoden for Formaterer klasse. Vi kan også lage en Formaterer eksempel, og bruk det til å påkalle format() metode.

Vi kan opprette en forekomst ved å sende inn en Anvendelig, OutputStream, Fil eller filnavn. Basert på dette, formatert String lagres i en Anvendelig, OutputStream, Fil henholdsvis.

La oss se et eksempel på å bruke den med en Anvendelig. Vi kan bruke den med andre på samme måte.

8.1. Ved hjelp av Formaterer Med Anvendelig

La oss lage en StringBuilder forekomst sb, og opprett en Formaterer bruker det. Så påkaller vi format() å formatere en String:

@Test offentlig ugyldig nårCreateFormatter_thenFormatterWithAppendable () {StringBuilder sb = new StringBuilder (); Formatter formatter = new Formatter (sb); formatter.format ("Jeg skriver til en% s-forekomst.", sb.getClass ()); assertEquals ("Jeg skriver til en klasse java.lang.StringBuilder Instance.", sb.toString ()); }

9. Konklusjon

I denne artikkelen så vi formateringsfasilitetene som tilbys av java.util.Formatter klasse. Vi så forskjellige syntakser som kan brukes til å formatere String og konverteringstyper som kan brukes til forskjellige datatyper.

Som vanlig kan du finne koden for eksemplene vi så på Github.