I-format ang output ng mga numero sa Java

Kamusta kayong lahat! Kadalasan ang aming mga pamamaraan ay may mga numero na kailangang ipakita sa ilang espesyal na format. Tila isang maliit na bagay, ngunit paano mo ipapatupad ang gawaing ito? Inaanyayahan ka naming pag-isipan ito nang kaunti ngayon. Una, upang sumisid sa pag-format ng numero sa Java, tandaan natin ang paraan ng format ng String class : public static String format(String format, Object... args) - nagbabalik ng string na na-format mula sa format na string gamit ang natitirang args arguments . At isang halimbawa lamang:

String str = String.format("Hi - %s! How are you %s?", "Sasha", "At work");
System.out.println(str);

Bilang resulta, makukuha natin ang output sa console:

printf at mga pamamaraan ng format

Ang String.format() ay hindi lamang ang paraan para sa pag-format ng isang string. Ang mga analogue nito ay System.out.printf() at System.out.format(); . Kaya, maaari naming palitan ang nakaraang code ng:

System.out.printf("Hi - %s! How are you %s?", "Sasha", "At work");

o

System.out.format("Hi - %s! How are you %s?", "Sasha", "At work");

Ang output sa console ay mananatiling pareho. Ang pagkakaiba lang ay agad na ipinapakita ng mga pamamaraang ito ang halaga sa console, hindi tulad ng String.format() . Ngunit mas gusto ko ang String.format() , dahil hindi natin palaging kailangang ipakita ang resulta sa console, kaya gagamitin pa natin ang pamamaraang ito. Bumalik tayo sa ating halimbawa. Ano ang nakikita natin? At ang katotohanan ay sa mga lugar kung saan mayroong mga character - %s , ang mga linya - "Sasha" at "sa trabaho" ay ipinasok . Paano ito makakatulong sa atin sa pag-unlad? Isipin na mayroon kang isang malaking template ng teksto, ngunit sa ilang mga lugar kailangan mong magpasok ng mga halaga na maaaring naiiba at dumating bilang mga argumento mula sa labas. Dito magagamit ang pag-format na ito. Ang mga tagatukoy ng format ay nagsisimula sa isang porsyentong tanda, %, at nagtatapos sa isang character na nagsasaad ng uri ng argumentong ipo-format. At, tulad ng malamang na naiintindihan mo, ang %s ay ginagamit upang magpasok ng mga bagay - mga string. Ngunit kung susubukan nating magpasok, halimbawa, ng double sa lugar kung saan nakarehistro ang string object:

String str = String.format("Hi - %s! How are you %s?", 55.6, "At work");

gagana rin ito. double ay ihahagis sa isang string at makakakuha tayo ng: Bukod sa mga string at floating point na numero, may iba pang mga uri sa Java, tama ba? Kaya tingnan natin ang buong arsenal: Gumamit tayo ng mas angkop na format para sa double :

String str = String.format("The distance from Kyiv to Odessa is %f. Not so short, is it?", 475.4d);
System.out.println(str);

Output ng console: Tulad ng maaaring napagtanto mo, ang %f ay magiging isang mas naaangkop na specifier para sa mga numero ng floating point, na kinabibilangan ng mga uri ng data tulad ng double at float sa Java. Gamit ang specifier na ito maaari naming i-format ang isang floating point number:

String str = String.format("The distance from Kyiv to Odessa is %.2f. Not so short, is it?", 475.4d);

Ang pagpasok ng .2 sa specifier na ito ay puputulin ang bilang ng mga decimal na lugar sa dalawa, na magbibigay sa amin ng output: Ang .2 ay hindi lamang ang tweak sa mga specifier. Ang kumbinasyon ng mga subsetting na ito ay tinatawag na isang pagtuturo . Ang pangkalahatang anyo ng mga tagubilin ay ang mga sumusunod: Ngayon ay tukuyin natin ang lahat sa pagkakasunud-sunod:

• Ang [argument_index] ay isang integer na nagsasaad ng posisyon sa listahan ng argumento. Halimbawa, ang link sa unang argumento ay $1, ang link sa pangalawang argumento ay $2, atbp. Kung ang posisyon ay hindi tinukoy, ang mga argumento ay dapat na nasa parehong pagkakasunud-sunod bilang ang mga ito ay isinangguni sa string ng format.
• Ang [flags] ay mga espesyal na character para sa pag-format. Halimbawa:
  • + flag na nagsasaad na kung positibo ang isang numeric na value, dapat itong may kasamang + sign
  • - nangangahulugang ihanay ang resulta sa kaliwa
  • , itinatakda ang libu-libong separator para sa mga integer
• Ang [width] ay isang positibong decimal integer na tumutukoy sa minimum na bilang ng mga character na ilalabas. Kung ang numerong ito ay nauuna sa 0, ang mga nawawalang character ay lagyan ng 0, kung walang 0, pagkatapos ay may mga puwang.
• Ang [.accuracy] ay isang non-negative na integer na pinangungunahan ng isang tuldok. Karaniwang ginagamit upang limitahan ang bilang ng mga character. Ang partikular na pag-uugali ay depende sa partikular na uri ng specifier.

Gusto ko ring tandaan na ang lahat ng mga elemento sa itaas ng mga tagubilin ay opsyonal, at lahat ay gagana nang wala ang mga ito. Bilang halimbawa ng paggamit ng mga subsetting, isipin natin na kailangan natin ng partikular na output ng numerong Pi:

String str = String.format("%1$+09.5f", 3.1415926535897);
System.out.print(str);

At naaayon, ang output sa console: Mukhang madali, tama? Ngunit pagdating sa pag-format ng isang numero, hindi mo maaaring balewalain ang DecimalFormat . Alamin natin kung ano ang ibig sabihin nito.

DecimalFormat

Ang DecimalFormat ay isang klase para sa pag-format ng anumang numero sa Java, maging ito ay isang integer o isang floating point na numero. Kapag ang isang DecimalFormat object ay nilikha , maaari kang tumukoy ng isang template para sa pag-format ng mga papasok na numero nang direkta sa constructor. Ito ang magiging hitsura ng aming halimbawa gamit ang DecimalFormat :

DecimalFormat dF = new DecimalFormat( "#.###" );
double value = 72.224463;
System.out.print(dF.format(value));

Output ng console: Ang linyang #.### ay isang pattern na nagsasaad na pino-format namin ang naipasa na halaga sa 3 decimal na lugar. Ano ang iba pang mga simbolo na magagamit para sa mga pattern? Narito ang ilan sa mga ito:

• # — digit, ang mga nangungunang zero ay tinanggal;
• 0 — ang digit ay palaging ipinapakita, kahit na ang numero ay may mas kaunting mga digit (sa kasong ito, 0 ang ipinapakita);
• . — tanda ng decimal separator;
• , — separator grouping sign (halimbawa, thousands separator);
• ; - naghihiwalay ng mga format;
• - — minarkahan ang prefix ng isang negatibong numero;
• % - dumarami sa 100 at ipinapakita ang bilang bilang isang porsyento;
• ? — multiply sa 1000 at ipinapakita ang numero sa ppm;
• E - Pinaghihiwalay ang mantissa at exponent para sa scientific notation.

Tingnan natin ang ilang halimbawa:

System.out.println(new DecimalFormat( "###,###.##" ).format(74554542.224463));

Output ng console:

System.out.println(new DecimalFormat( "%###.##" ).format(0.723456));

Output ng console:

System.out.println(new DecimalFormat( "000.###" ).format(42.224463));

Output ng console: Hindi kinakailangang lumikha ng bagong DecimalFormat object sa bawat oras upang tukuyin ang isang bagong template. Sapat na gamitin ang mga pamamaraan na applyPattern at applyLocalizedPattern nito :

DecimalFormat dF = new DecimalFormat("###.###");
dF.applyPattern("000000.000");
dF.applyLocalizedPattern("#,#00.0#");

Kapag pinag-uusapan natin ang pag-format ng isang floating point number, medyo interesado tayo sa pag-round, di ba? Kaya, kapag nag-trim ng isang numero na may mga decimal na lugar na lampas sa tinukoy na pattern, ang DecimalFormat ay ni-round up ang numero kung ang huling na-trim na numero ay mas malaki sa 5. Paano kung ang huling na-trim na numero ay 5? Sa katunayan, sa kasong ito, ang numerong ito ay eksaktong nasa gitna sa pagitan ng pinakamalapit na integer. Sa kasong ito, ang nakaraang numero ay isinasaalang-alang. Kung pantay ang dating numero, tapos na ang pag-round:

DecimalFormat dF = new DecimalFormat("##.###");
String result = dF.format(56.4595);
System.out.println((result));

Output ng console: Kung kakaiba, hindi ito ginagawa:

DecimalFormat dF = new DecimalFormat("##.###");
String str = dF.format(56.4595);
System.out.println((str));

Output ng console: Ang pagkakaiba sa pagitan ng pag-format ng mga numero ng floating point gamit ang String.format() at DecimalFormat.format() ay na sa unang kaso ay magkakaroon ng mga trailing zero, kahit na walang fractional na bahagi. Halimbawa:

String firstStr = String.format("%.4f", 9.00001273);
System.out.println((firstStr));

Output ng console:

DecimalFormat decimalFormat = new DecimalFormat("#.####");
String secondStr = decimalFormat.format(9.00001273);
System.out.println((secondStr));

Output ng console: Gaya ng nakikita mo, kapag na-format ang numerong 9.00001273 na may katumpakan ng apat na decimal na lugar, ang format() na paraan ng String class ay maglalabas ng value na 9.0000 , habang ang katulad na format() na paraan ng DecimalFormat ay maglalabas ng 9 .

BigDecimal at BigInteger

Dahil nahawakan natin ang paksa ng pag-ikot ng mga numero sa Java, pag-usapan natin kung paano gamitin ang klase ng BigDecimal para sa mga naturang operasyon . Ang klase na ito ay nakatuon sa pagtatrabaho sa talagang MALAKING numero: para dito, ang maximum na doble at float na mga halaga ay masyadong maliit. Ang klase na ito ay may maraming iba't ibang mga setting para sa floating point rounding, pati na rin ang maraming mga pamamaraan para sa mga pagpapatakbo ng aritmetika. Mayroon itong katulad na klase, ngunit nakatuon sa pagtatrabaho sa MALAKING integer - BigInteger . Maaari kang magbasa nang higit pa tungkol sa BigDecimal at BigInteger sa artikulong ito .

Pag-format ng Petsa at Oras

Nabanggit lamang sa itaas na ang paggamit ng format() ng String class ay maaari mo ring i-format ang oras at petsa. Well, tingnan natin kung paano ito ginawa. Una, gusto naming ipaalala sa iyo na ang %t format specifier ay ginagamit para sa mga petsa . Pangalawa, kapag nagfo-format ng template, ang mga karagdagang flag sa pag-format ay kinakailangan para sa bawat format specifier para sa mga petsa. Narito ang mga posibleng pag-format ng mga flag para sa mga petsa: Ito ay isang pinaikling listahan ng mga posibleng flag sa pag-format ng petsa - marami sa kanila, para sa bawat panlasa. Ang kumpletong listahan ng mga ito at posibleng mga specifier ay matatagpuan sa link na ito . Tingnan natin kung paano ito gamitin. Sa pagkakataong ito hindi namin ginagamit ang String.format() , ngunit kaagad System.out.printf() .

Halimbawa 1

Bilang karagdagan, itatakda namin ang wika ng resulta sa pamamagitan ng pagpasa nito bilang unang argumento sa pamamaraan:

Date date = new Date();
System.out.printf(Locale.ENGLISH,"%tB %te, %tY",date,date,date);

Output ng console: Nang walang pagtukoy ng isang wika, ang default na wika ay gagamitin (halimbawa, mayroon akong Russian).

Halimbawa 2

Ipakita natin ang isang mas kumpletong petsa:

Date date = new Date();
System.out.printf("%td %tB %tY of %n%tH:%tM:%tS",date,date,date,date,date,date,date);

At ang output sa console: Pagpasa sa parehong bagay na Petsa bilang isang argumento nang maraming beses... Mukhang hindi ito masyadong maganda, hindi ba? Gamitin natin ang $ internal subset para tukuyin ang argument na gusto nating gamitin:

System.out.printf("%1$td %1$tB %1$tY of year %n%1$tH:%1$tM:%1$tS",date);

Ang output sa aming console ay hindi magbabago. Mayroong iba pang mga parehong kawili-wiling paraan upang i-format ang mga petsa. Maaari mong basahin ang tungkol sa mga ito at kaunti pa tungkol sa oras at petsa sa Java sa materyal na ito . Iyon lang para sa araw na ito, salamat sa iyong pansin!