streamalism.org

1. Áttekintés

Ebben a cikkben a Húr formázás Java-ban a java.util.Formatter osztály, amely támogatja az elrendezés igazolását és igazítását.

2. Hogyan kell használni a Formázó

Ne feledje a C-eket printf? Formázás a Húr Java-ban nagyon hasonlónak érzi magát.

A formátum() módszere Formázó statikus módszerrel teszik ki a Húr osztály. Ez a módszer elfogad egy sablont Húr és a sablon feltöltéséhez szükséges argumentumok listája:

String üdvözlet = String.format ("Helló emberek, üdvözlöm a% s-nál!", "Baeldung");

A kapott Húr az:

- Helló emberek, üdvözlöm a Baeldungban!

A sablon a Húr tartalmaz néhány statikus szöveget és egy vagy több formátummeghatározót, amelyek jelzik, hogy melyik argumentumot kell elhelyezni az adott pozícióban.

Ebben az esetben, van egyetlen formátummeghatározó % s, amelyet felvált a megfelelő argumentum.

3. Formátum specifikátorok

3.1. Általános szintaxis

A formátum-meghatározók szintaxisa a következőhöz: Általános, Karakter, és Numerikus típusa:

% [argument_index $] [zászlók] [szélesség] [. pontosság] konverzió

Specifikátorok argumentum_index, zászló, szélesség, és pontosság választhatóak.

• argumentum_index rész egész szám én - jelezve, hogy a ith Az argumentumlista argumentumát kell itt használni
• zászlók a kimeneti formátum módosításához használt karakterkészlet
• szélesség pozitív egész szám, amely a kimenetbe írandó karakterek minimális számát jelöli
• pontosság egy egész szám, amelyet általában a karakterek számának korlátozására használnak, és amelyek sajátos viselkedése a konverziótól függ
• a kötelező rész. Ez egy karakter, amely jelzi az argumentum formázását. Egy adott argumentum érvényes konverzióinak halmaza az argumentum adattípusától függ

A fenti példánkban, ha kifejezetten meg akarjuk adni egy argumentum számát, akkor a segítségével megírhatjuk 1$ és 2$ érvindexek.

Mindkettő az első, illetve a második érv:

String üdvözlet = String.format ("Hello% 2 $ s, üdvözlöm a% 1 $ s-nél!", "Baeldung", "Folks");

3.2. Mert Dátum idő Reprezentáció

% [argument_index $] [zászlók] [szélesség] konverzió

Ismét a argument_index, zászlók, és szélesség választhatóak.

Vegyünk egy példát ennek megértésére:

@Test public void whenFormatSpecifierForCalendar_thenGotExpected () {Naptár c = új GregorianCalendar (2017, 11, 10); String s = String.format ("A dátum:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("A dátum: 12 10,2017", s); }

Itt minden formátummeghatározóhoz az 1. argumentumot kell használni 1$. Itt, ha kihagyjuk a argumentum_index a 2. és a 3. formátum-specifikálóhoz 3 argumentumot próbál meg találni, de mind a 3 formátum-specifikációnál ugyanazt az argumentumot kell használnunk.

Szóval rendben van, ha nem adjuk meg argumentum _index az elsőhöz, de a másik kettőhöz meg kell adnunk.

A zászló itt két karakterből áll. Ahol az első karakter mindig a „T” vagy „T”. A második karakter attól függ, hogy melyik része Naptár meg kell jeleníteni.

Példánkban az első formátum-specifikátorok tm, a hónapot két számjegyként formázva jelöli, te jelzi a hónap napját és tY jelzett év négy számjeggyel formázva.

3.3. Formátum specifikátorok argumentumok nélkül

% [zászlók] [szélesség] konverzió

Az opcionális zászlók és szélesség megegyeznek a fenti szakaszokban meghatározottakkal.

A szükséges átalakítás egy karakter vagy Húr megjelölve a kimenetbe beillesztendő tartalmat. Jelenleg csak a ‘%' és newline „N” ezzel nyomtatható:

@Test public void whenNoArguments_thenExpected () {String s = String.format ("John 90 %% -ot ért el őszi félévben"); assertEquals ("John 90% -ot ért el az őszi félévben", s); } 

Belül formátum(), ha nyomtatni akarunk ‘%' - meg kell menekülnünk a használatával ‘%%'.

4. Konverziók

Vizsgáljuk meg most a Format Specifier szintaxis minden részletét, kezdve az a-val átalakítás. Vegye figyelembe, hogy az összes részlet megtalálható a Formázó javadocs.

Amint a fenti példákban észrevettük, átalakítás rész minden formátum-specifikációban kötelező, és több kategóriába sorolható.

Vessünk egy pillantást mindegyikre példákkal.

4.1. Tábornok

Bármely argumentumtípushoz használható. Az általános konverziók a következők:

1. „B” vagy „B” - a Logikai értékek
2. „H” vagy „H” - a Hash kód
3. „S” vagy „S” - a Húr, ha nulla, „null” -t nyomtat, mást arg.toString ()

Most megpróbáljuk megjeleníteni logikai és Húr értékeket a megfelelő konverziók felhasználásával:

@Test public void givenString_whenGeneralConversion_thenConvertedString () {String s = String.format ("A helyes válasz:% s", hamis); assertEquals ("A helyes válasz hamis", s); s = String.format ("A helyes válasz:% b", null); assertEquals ("A helyes válasz hamis", s); s = String.format ("A helyes válasz:% B", igaz); assertEquals ("A helyes válasz IGAZ", s); }

4.2. karakter

Az Unicode karaktereket reprezentáló alaptípusokhoz használják: char, Karakter, bájt, Bájt, rövid, és Rövid. Ez az átalakítás a típusokhoz is használható int és Egész szám amikor az Character.isValidCodePoint (int) visszatér igaz nekik.

Írható úgy „C” vagy ’C’ a kívánt eset alapján.

Próbáljunk meg néhány karaktert kinyomtatni:

@Test public void givenString_whenCharConversion_thenConvertedString () {String s = String.format ("A helyes válasz:% c", 'a'); assertEquals ("A helyes válasz a", s); s = String.format ("A helyes válasz:% c", null); assertEquals ("A helyes válasz null", s); s = String.format ("A helyes válasz:% C", 'b'); assertEquals ("A helyes válasz B", s); s = String.format ("Az érvényes unicode karakter:% c", 0x0400); assertTrue (Karakter.isValidCodePoint (0x0400)); assertEquals ("Az érvényes unicode karakter: Ѐ", s); }

Vegyünk még egy példát egy érvénytelen kódpontra:

@Test (várható = IllegalFormatCodePointException.class) public void whenIllegalCodePointForConversion_thenError () {String s = String.format ("Az érvényes unicode karakter:% c", 0x11FFFF); assertFalse (Character.isValidCodePoint (0x11FFFF)); assertEquals ("Az érvényes unicode karakter: Ā", s); }

4.3. Numerikus - Integrál

Ezeket a Java integrált típusaihoz használják: bájt, bájt, rövid, rövid, int és Egész, hosszú, hosszú, és BigInteger. Három konverzió van ebben a kategóriában:

1. „D” - tizedes számra
2. „O” - oktális számra
3. 'X' vagy 'x' - hexadecimális számra

Próbáljuk meg kinyomtatni ezeket:

@Test public void whenNumericIntegralConversion_thenConvertedString () {String s = String.format ("A 25. szám tizedesjegyben =% d", 25); assertEquals ("A 25. szám tizedesjegy = 25", s); s = karakterlánc-formátum ("A 25-es szám oktális =% o-ban", 25); assertEquals ("A 25. szám oktális = 31-ben", s); s = String.format ("A 25-es szám hexadecimális =% x", 25); assertEquals ("A 25. szám hexadecimális = 19", s); }

4.4. Numerikus - lebegőpont

Java lebegőpontos típusokhoz használják: úszó, úszó, dupla, dupla, és BigDecimal

1. „E” vagy „E” – tizedes számként formázva a számítógépes tudományos jelölésekben
2. „F” – tizedes számként formázva
3. „G” vagy „G” – a kerekítés utáni pontosság alapján ez az átalakítás számítógépes tudományos jelölés vagy tizedes formátumba formázódik

Próbáljuk meg kinyomtatni a lebegőpontos számokat:

@Test public void whenNumericFloatingConversion_thenConvertedString () {String s = String.format ("A 10000,00 számítógépes tudományos formátuma" + "=% e", 10000,00); assertEquals ("Az 10000,00 = 1,000000e + 04 számítógépes tudományos formátuma", s); String s2 = String.format ("A 10.019 =% f tizedes formátuma", 10.019); assertEquals ("A 10.019 = 10.019000 tizedes formátuma", s2); }

4.5. Egyéb konverziók

• Dátum idő - dátum vagy idő kódolására képes Java típusok esetében: hosszú, hosszú, naptár, Dátum és TemporalAccessor. Ehhez előtagot kell használnunk „T” vagy „T”, amint azt korábban láthattuk
• Százalék - nyomtat egy szó szerinti szót „%” („\ U0025”)
• Vonalelválasztó - platformspecifikus vonalválasztót nyomtat

Nézzünk meg egy egyszerű példát:

@Test public void whenLineSeparatorConversion_thenConvertedString () {String s = String.format ("Első sor% nSecond sor"); assertEquals ("Első sor \ n" + "Második sor", s); }

5. Zászlók

A jelzéseket általában a kimenet formázására használják. Míg dátum és idő esetén megadják, hogy a dátum melyik részét kell megjeleníteni, amint azt a 4. szakasz példájában láthattuk.

Számos zászló áll rendelkezésre, amelyek listája megtalálható a dokumentációban.

Lássunk egy zászló példát, hogy megértsük a használatát. ‘-‘ a kimenet balra igazított formázására szolgál:

@Test public void whenSpecifyFlag_thenGotFormattedString () {String s = String.format ("Balra igazolt zászló nélkül:% 5d", 25); assertEquals ("Balra igazolt zászló nélkül: 25", s); s = String.format ("Balra igazított jelzővel:% -5d", 25); assertEquals ("Balra igazolt zászlóval: 25", s); }

6. Pontosság

Általános konverziókhoz A pontosság csak a kimenetre írható karakterek maximális száma. Míg f vagy a lebegőpontos konverziók, a pontosság a radix pont utáni számjegyek száma.

Az első állítás példa lebegőpontos pontosságra, a második általános konverzióval:

@Test public void whenSpecifyPrecision_thenGotExpected () {String s = String.format ("25.09878 kimenete 2-es pontossággal:% .2f", 25.09878); assertEquals ("25.09878 kimenete 2. pontossággal: 25.10", s); String s2 = String.format ("Általános konverziótípus kimenete 2. pontossággal:% .2b", true); assertEquals ("Általános konverziótípus kimenete 2. pontossággal: tr", s2); }

7. Érvindex

Mint korábban említettük, aargumentum_index egy egész szám, amely az argumentum helyét jelzi az argumentumlistában. 1$ jelzi az első érvet, 2$ a második érv stb.

Van még egy módja az argumentumok pozíciónkénti hivatkozásának a ’<’ (’\ U003c ') flag, ami azt jelenti, hogy az előző formátummeghatározó argumentumát újra felhasználják. Például ez a két állítás azonos kimenetet eredményezne:

@Test public void whenSpecifyArgumentIndex_thenGotExpected () {Naptár c = Naptár.getInstance (); String s = String.format ("A dátum:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("A dátum: 12 10,2017", s); s = String.format ("A dátum:% tm%<>

8. A felhasználás egyéb módjai Formázó

Mostanáig láttuk a használatát formátum() módszere Formázó osztály. Hozhatunk létre a Formázó Például, és használja ezt a formátum() módszer.

Hozhatunk létre példányt egy Hozzáfűzhető, OutputStream, File vagy fájlnév. Ez alapján a formázott Húr egy Hozzáfűzhető, OutputStream, File illetőleg.

Lássunk egy példát egy Hozzáfűzhető. Ugyanúgy használhatjuk másokkal is.

8.1. Használata Formázó Val vel Hozzáfűzhető

Hozzunk létre egy S-ttringBuilder példa sb, és hozzon létre egy Formázó használni azt. Majd felhívjuk formátum() formázni a Húr:

@Test public void whenCreateFormatter_thenFormatterWithAppendable () {StringBuilder sb = new StringBuilder (); Formázó formázó = új Formázó (sb); formatter.format ("% s példányhoz írok.", sb.getClass ()); assertEquals ("Írok egy java.lang.StringBuilder példányba.", sb.toString ()); }

9. Következtetés

Ebben a cikkben láttuk a java.util.Formatter osztály. Különböző szintaxist láttunk, amelyek felhasználhatók a Húr valamint a különböző adattípusokhoz használható konverziótípusok.

Szokás szerint az általunk látott példák kódja a Githubon található.