Mga rounding na numero sa Java

Ang mga numero ng floating point (float, double) ay ginagamit kapag kinakalkula ang mga expression na nangangailangan ng katumpakan ng decimal. Ang mataas na katumpakan ay madalas na kailangan sa accounting at iba pang mga pagpapatakbo ng computing. Ngunit kailangan ba natin ng mahabang "buntot" ng mga numero pagkatapos ng decimal point? Siguro ang katumpakan ng tatlong tunay na bahagi ay sapat na para sa atin? At nasiyahan kami sa pagpipiliang ito, kung paano maayos na maisagawa ang pag-ikot? Ito mismo ang pag-uusapan natin ngayon: titingnan natin ang mga paraan upang i-round ang mga numero sa Java .

Format ng string

Bilang unang paraan, titingnan natin ang rounding double:

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

Bilang resulta, ipo-format namin ang aming numero ng floating point na 34766674 na may katumpakan na 3 decimal na lugar , dahil sa mga tagubilin sa pag-format ay tinukoy namin ang tatlong decimal na lugar "%.3f. Sa turn, ang %f kapag nag-format ng string ay nagpapahiwatig ng uri ng floating point mga numero, na kinabibilangan ng data type double at float sa Java. Sa halimbawa sa itaas, ilalabas namin ang resultang halaga sa console. Ngayon ang tanong ay: paano natin ito paikliin? Simple lang: kailangan mong gumamit ng printf, na kung saan ay format + print. Bilang resulta, ang nakaraang Ang aming halimbawa ay mababawasan sa:

double value = 34.766674;
System.out.printf("%.3f",value);

Bilang karagdagan sa pamamaraang ito , ang out instance ng klase ng PrintStream ay mayroon ding paraan ng format, na gumagana nang katulad:

double value = 34.766674;
System.out.format("%.3f",value);

Nagaganap ang pag-round sa HALF_UP mode - patungo sa numerong mas malapit sa pinuputol (sa 0 o 10). Kung ang mga numerong ito ay katumbas ng distansya (sa kaso ng 5), pagkatapos ay isasagawa ang pag-round up. Halimbawa:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

Tatalakayin natin ang mga rounding mode nang mas detalyado sa ibaba.

DecimalFormat

Ang isa pang pagpipilian ay ang paggamit ng klase ng DecimalFormat . Ito ay idinisenyo upang i-format ang anumang numero sa Java, maging ito ay isang integer o isang floating point na numero. Kapag nag-instantiate kami ng DecimalFormat, maipapasa namin ito sa isang format na string. Ipahiwatig nito kung gaano karaming mga decimal na lugar ang ipo-format para sa input. Ito ang magiging hitsura ng aming halimbawa gamit ang DecimalFormat :

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

Ang linyang #.### ay isang pattern na nagsasaad na pino-format namin ang naipasa na halaga sa 3 decimal na lugar. Upang baguhin ang pattern pagkatapos malikha ang DecimalFormat object, maaari mong gamitin ang mga pamamaraan na applyPattern at applyLocalizedPattern :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

Ngunit ngayon ay pinag-uusapan natin ang tungkol sa pag-ikot, hindi ba? Kapag pinuputol ang 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 pinutol na numero ay mas malaki sa 5. Ngunit paano kung ang numero ay 5? Ito ay lumiliko na ito ay eksaktong nasa gitna sa pagitan ng pinakamalapit na integer. Ano ngayon? Sa kasong ito, ang nakaraang numero ay isinasaalang-alang. Kung ito ay pantay, ang pag-round ay tapos na:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

Kung kakaiba, hindi ito ginagawa:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

Mayroong kaunting pagkakaiba sa pagitan ng pag-format ng mga numero ng floating point gamit ang String.format() at DecimalFormat.format(). Ang una ay palaging magpi-print ng mga trailing zero kahit na walang fractional na bahagi. Hal:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

Tulad ng nakikita natin, kapag ang pag-format ng numero 7.000132 sa tatlong decimal na lugar, ang String's format() method ay maglalabas ng 7.000, habang ang DecimalFormat's format() method ay maglalabas ng 7. Ibig sabihin, maaari mong piliin ang String.format() o DecimalFormat.format( ) depende sa kung kailangan mo ng mga trailing zero o hindi. Gamit ang mga pamamaraan na inilarawan sa itaas, natanggap namin ang resulta sa anyo ng isang string. Tingnan natin ang mga paraan upang maibalik nang eksakto ang mga numerong halaga.

Math

Imposibleng hindi banggitin ang isang espesyal na klase na iniayon para sa iba't ibang mga operasyon ng arithmetic na may mga numero - Math . Ang klase na ito ay mayroon ding mga pamamaraan para sa pag-ikot, ngunit hindi tulad ng mga inilarawan na, hindi ka nila pinapayagang magtakda ng isang tiyak na bilang ng mga decimal na lugar, ngunit sa halip ay ikot sa isang integer:

• Ang Math.ceil() ay umiikot sa pinakamalapit na integer, ngunit hindi nagbabalik ng uri ng integer, ngunit isang doble:

  double value = 34.777774;
  double result = Math.ceil(value);
  System.out.println((result)); //35.0

  Kahit na meron tayong 34.0000000, pagkatapos gamitin ang Math.ceil ay makakakuha pa rin tayo ng 35.0.

  Ang Math.floor() ay umiikot pababa sa pinakamalapit na integer, ibinabalik din ang resulta bilang doble:

  double value = 34.777774;
  double result = Math.floor(value);
  System.out.println((result)); //34.0

  Muli, kahit na mayroon tayong halaga na 34.999999999, pagkatapos ay pagkatapos gamitin ang Math.floor ay makakakuha tayo ng 34.0.

• Math.round () - mga round sa pinakamalapit na integer, na nagbibigay ng resulta int:

  double value = 34.777774;
  int result = Math.round(value);
  System.out.println((result)); //35

  Kung ang aming numero ay 34.5, ito ay ni-round sa 35, ngunit kung ito ay bahagyang mas mababa sa 34.499, ang numero ay pinutol sa 34.

  Upang hindi lamang putulin ang buong tunay na bahagi, ngunit upang ayusin ang prosesong ito sa isang tiyak na bilang ng mga decimal na lugar at sabay-sabay na pag-ikot, ang bilang ay pinarami ng 10^n (10 sa kapangyarihan ng n), kung saan n ay katumbas ng bilang ng mga kinakailangang decimal na lugar. Pagkatapos nito, ang ilang paraan ng klase ng Math ay ginagamit sa pag-ikot, at pagkatapos ay hinati muli ng 10^n:

  double value = 34.777774;
  double scale = Math.pow(10, 3);
  double result = Math.ceil(value * scale) / scale;
  System.out.println((result)); //34.778

  Math.pow - tumatagal ng dalawang argumento. Ang una ay ang numero, ang pangalawa ay ang kapangyarihan kung saan kailangan itong itaas.

Pag-round sa BigDecimal

Ang BigDecimal ay isang klase na nagbibigay-daan sa iyong magtrabaho sa mga numero ng floating point. Sa partikular, ang pangunahing tampok nito ay maaari itong mag-imbak ng mga fractional na numero ng di-makatwirang haba (iyon ay, walang limitasyon sa hanay ng numero). Bilang karagdagan, ang klase na ito ay nag-iimbak ng iba't ibang mga pamamaraan para sa pagproseso ng aritmetika, kabilang ang pag-ikot. Ang klase ng object na ito ay maaaring malikha sa pamamagitan ng pagtatakda ng constructor sa double, string upang magpakita ng floating point number, double at MathContext , at iba pa. Ang MathContext ay isang kumbinasyon ng RoundingMode at isang numero na naglalarawan sa kabuuang bilang ng mga digit sa hinanap na halaga. Rounding rules RoundingMode: DOWN - rounding patungo sa zero. UP —pag-ikot mula sa zero mode. CEILING - pag-ikot patungo sa positibong infinity. FLOOR - pag-ikot patungo sa negatibong infinity. HALF_UP - Nagra-round sa "pinakamalapit na kapitbahay" kung ang parehong kapitbahay ay hindi katumbas ng distansya (iyon ay, kapag ang numerong ni-round ay 5). Sa kasong ito, isinasagawa ang pag-ikot. HALF_DOWN - pag-ikot patungo sa "pinakamalapit na kapitbahay". Kung ang parehong kapitbahay ay hindi katumbas ng distansya, sa kasong ito, i-round down. HALF_EVEN - Iniikot sa "pinakamalapit na kapitbahay" kung ang parehong kapitbahay ay hindi katumbas ng distansya. Sa kasong ito, bilugan sa pantay na kapitbahay (tulad ng sa DecimalFormat na inilarawan sa itaas). UNNECESSARY - Ginagamit upang kumpirmahin na ang hiniling na operasyon ay may tamang resulta. Samakatuwid, hindi kinakailangan ang pag-ikot. Halimbawa:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

Bilang karagdagan sa kakayahang magtakda ng isang rounding rule sa constructor, pinapayagan ka ng BigDecimal na itakda ang rounding mode pagkatapos magawa ang instance. Upang gawin ito, gamitin ang setScale method , kung saan kailangan mong itakda ang bilang ng mga decimal place at rounding rules:

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

Ang BigDecimal ay mayroon ding mga panloob na int na variable na idinisenyo upang itakda ang rounding mode ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...) Ang mga ito ay kumakatawan sa pag-ikot ng mga panuntunan na katulad ng ipinakita sa RoundingMode na klase at katulad na ginagamit sa setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

Magbasa nang higit pa tungkol sa klase ng BigDecimal sa artikulong ito .