Jinsi ya Kukokotoa Nambari katika Java: Math.round(), Nafasi za Desimali, BigDecimal, na RoundingMode

.

1. Maana ya “Rounding (四捨五入)” katika Java

Unapohitaji kufanya “rounding (四捨五入)” katika Java, kwa hakika hakuna njia moja inayozungusha kila wakati kama unavyotarajia.
Hii ni kwa sababu katika Java, njia sahihi ya kusafisha inategemea aina ya nambari (int / double / BigDecimal, n.k.) na lengo (hesabu vs onyesho).

Katika sehemu hii, kwanza tutaandaa dhana kuu na kufafanua kwa nini kusafisha katika Java kunaweza kuwa na mkanganyiko.

1.1 Sheria ya Msingi ya Kusafisha (5 na Juu Zinazungusha Juu)

Sheria ya jumla ya kusafisha ni kama ifuatavyo:

• Ikiwa nambari inayofuata ni 5 au zaidi → zingusha juu
• Ikiwa nambari inayofuata ni 4 au chini → zingusha chini

Mfano (kusafisha hadi sehemu ya vitengo)

• 1.4 → 1
• 1.5 → 2

Sheria hii ni sawa katika Java, lakini changamoto halisi ni “ni njia gani inatekeleza sheria hii” na “ni tarakimu ngapi unaweza kushughulikia”.

Katika Java, kusafisha kwa kawaida hutenganishwa kwa madhumuni, kama vile:

• Unataka tu kusafisha nambari rahisi
• Unataka kusafisha hadi sehemu ya desimali ya n
• Unahitaji toleransi sifuri kwa makosa (kwa mfano, mahesabu ya fedha)

Ukijaribu kushughulikia haya yote kwa njia moja, mara nyingi utapata matokeo yasiyotakiwa.

1.2 Kwa Nini Kusafisha katika Java Kunaweza Kuwa na Mkanganyiko

Sababu kuu ambazo kusafisha katika Java mara nyingi huelezewa kama “ngumu” au “hakifanyi kazi kama inavyotarajiwa” ni hoja hizi tatu:

Sababu 1: Makosa ya usahihi wa pointi-yozito (double)

double ni aina inayowakilisha desimali katika binary.
Kwa hiyo, hata nambari ambazo zinaonekana safi katika desimali zinaweza kuwa na makosa ya usahihi ya ndani.

Mfano:

double x = 0.1 + 0.2;
System.out.println(x); // 0.30000000000000004

Ukizungusha katika hali hii, unaweza kupata matokeo ambayo hayalingani na hisia za binadamu.

Sababu 2: Huwezi moja kwa moja “kusafisha hadi sehemu ya desimali ya n”

Java haina njia maalum kama:
“zungusha hadi desimali 2”
kwa moja kwa moja.

Hivyo katika hali nyingi, unahitaji marekebisho kwa kutumia hesabu, kama vile:

• Zidisha kwa 10 au 100
• Zungusha
• Rudisha ukubwa wa awali

Ukikosea hatua, matokeo yatakuwa yasiyo sahihi.

Sababu 3: Njia hutofautiana katika tabia na aina za kurudisha

Kwa mfano, Math.round() ni rahisi, lakini inarejesha aina ya integer (int / long).
Ukitaka kusafisha huku ukibakia na sehemu za desimali, huwezi kuitumia kama ilivyo.

Makosa ya Kawaida na Mambo ya Kuangalia

• Kudhani “kusafisha = Math.round()” → Mara nyingi haitoshi kwa desimali 2+ au mahesabu ya fedha
• Kufanya mahesabu ya fedha kwa double na kisha kusafisha → Makosa yanaweza kukusanyika na kuwa hatari katika mifumo ya ulimwengu halisi**
• Kutumia kusafisha sawa kwa onyesho na hesabu → Unaweza kupoteza usahihi kwa kusafisha mahesabu ya ndani**

Kusafisha ni mchakato wa “kusafisha matokeo ya mwisho,” na wakati na aina ya data unayotumia ni muhimu sana.

2. Kusafisha kwa Math.round() (Njia ya Msingi Zaidi)

Math.round() ni moja ya njia za msingi na rahisi zaidi za kusafisha katika Java.
Ni njia nzuri ya kwanza kwa wanaoanza, lakini unahitaji kuelewa matumizi sahihi na vikwazo ili kuepuka matumizi mabovu.

Katika sehemu hii, tutaandaa matumizi sahihi ya Math.round() na makosa ya kawaida ambayo unaweza kukutana nayo katika maendeleo halisi.

2.1 Matumizi ya Msingi ya Math.round()

Math.round() inazungusha nambari iliyotolewa hadi integer ya karibu zaidi.

double a = 1.4;
double b = 1.5;

System.out.println(Math.round(a)); // 1
System.out.println(Math.round(b)); // 2

• Zungusha juu wakati sehemu ya sehemu ndogo ni 0.5 au zaidi
• Zungusha chini wakati ni chini ya 0.5
• Inafuata sheria ya kawaida ya round-half-up

Inaonekana ya kimahiri, lakini aina ya kurudisha ni jambo muhimu la kuangalia.

2.2 Angalizo: Aina ya Kurudisha Ni int / long

Math.round() hubadilisha aina ya kurudisha kulingana na aina ya hoja.

double x = 3.7;
long result = Math.round(x);

The key point is: thamani inayorudi ni aina ya nambari kamili kila wakati.

Mbali na hilo, haifai kama ilivyo kwa hali kama:

• Unataka kuhifadhi sehemu za desimali katika matokeo
• Unataka kuhifadhi nafasi 1 au 2 za desimali

kwa sababu Math.round() yenyewe hutengeneza nambari kamili.

Mfano wa Kosa la Kawaida

double price = 12.34;
double rounded = Math.round(price); // actually long → assigned to double

Kodisi hii haileti kosa la kuandika, lakini
sehemu ya kawaida inapotea kabisa na inakuwa 12.0, kwa hivyo kuwa makini.

2.3 Jinsi ya Kupunguza hadi Nafasi ya 2 ya Desimali au Zaidi (Mbinu ya ×10 / ×100)

Ikiwa unataka kutumia Math.round() ili kupunguza hadi nafasi ya n ya desimali,
kawaida hufuata mchakato huu:

Hatua

1. Zidu thamani ya lengo kwa 10ⁿ
2. Punguza hadi nambari kamili kwa Math.round()
3. Gawa kwa 10ⁿ ili kurudi katika kiwango cha asili

Mfano: Punguza hadi Nafasi 2 za Desimali

double value = 1.234;
double rounded = Math.round(value * 100) / 100.0;

System.out.println(rounded); // 1.23

Mfano: Punguza hadi Nafasi 1 ya Desimali

double value = 1.25;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(rounded); // 1.3

Mbinu hii ni rahisi, lakini haiondoa kabisa matatizo maalum ya usahihi wa mara mbili.

Matatizo, Maonyo, na Makosa ya Kawaida

• Kufanya mgawanyo wa nambari kamili kwa bahati mbaya Math.round(value * 100) / 100; // 100 ni int → sehemu za desimali zinapotea → Tumia mara mbili kama 100.0 kila wakati
• Kuitumia moja kwa moja kwa hesabu za pesa → Inafaa kwa kuonyesha, lakini mara nyingi haifai kwa hesabu
• Kupunguza mapema sana → Ikiwa utapunguza matokeo ya kati, thamani ya mwisho inaweza kushuka

Math.round() ni nzuri wakati “unataka nambari kamili tu” au “unataka kupunguza kwa kuonyesha,” lakini lazima ukumbuke kuwa
ina mipaka wakati usahihi ni muhimu.

3. Njia ya Kawaida ya Kupunguza hadi Nafasi ya N ya Desimali

Maombi kama “nataka kupunguza hadi nafasi 2 za desimali” au “nataka kuhifadhi nafasi 3 za desimali” ni ya kawaida sana, na
hii pia ni nia kuu ya utafutaji nyuma ya neno la ufunguo java 四捨五入.

Katika sehemu hii, tutaeleza njia ya kawaida ya kupunguza hadi nafasi ya n ya desimali kwa kutumia Math.round(),
na kuonyesha wazi mipaka yake.

3.1 Mfumo wa Msingi wa Fomula

Kwa sababu Java haatoi njia maalum ya kupunguza hadi nafasi ya n ya desimali,
njia inayotumiwa sana ni kuweka nambari katika kiwango, kupunguza, na kisha kuirejesha katika kiwango.

Fomula ya msingi

Math.round(value × 10^n) ÷ 10^n

Mfano: Punguza hadi nafasi 2 za desimali

double value = 12.345;
double rounded = Math.round(value * 100) / 100.0;

System.out.println(rounded); // 12.35

Mfano: Punguza hadi nafasi 3 za desimali

double value = 12.34567;
double rounded = Math.round(value * 1000) / 1000.0;

System.out.println(rounded); // 12.346

Njia hii ni rahisi kuelewa na inatosha kwa usindikaji wa nambari ya kuonyesha pekee.

3.2 Kesi Ambapo Haifanyi Vizuri (Tatizo la 0.1 + 0.2)

Hata hivyo, njia hii haiwezi kuepuka kabisa makosa ya usahihi wa mara mbili.

Mfano wa kawaida ni kesi ifuatayo:

double value = 0.1 + 0.2;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(value);   // 0.30000000000000004
System.out.println(rounded); // 0.3

Inaweza kuonekana sawa hapa, lakini kulingana na hesabu na idadi ya tarakimu, bado unaweza kupata matokeo ya kupunguza yasiyotarajiwa.

Kesi zifuatazo ni hatari hasa:

• Hesabu za pesa
• Hesabu za kuunganisha kwa viwango vya kodi au asilimia
• Kupunguza mara kwa mara ndani ya peti

3.3 Kwa Nini Makosa Yanatokea (Maelezo Mafupi Sana)

double ni aina ya nambari zinazoelea ambazo zinawakilisha desimali katika binary.
Kwa hivyo hata thamani zinazokuwa sahihi katika msingi-10 zinaweza kujumuisha makosa madogo katika uwakilishi wao wa ndani.

Hii ni maelezo maalum ya Java, si hitilafu.

Mifahamu potofu ya kawaida

• “Fomula yangu si sahihi” → ❌
• “Java imevunjika” → ❌
• “Ni kutokana na asili ya double” → ✅

Vizingiti, Onyo, na Makosa ya Kawaida

• Kupata mpangilio wa upanuzi/gawanyiko vibaya Math.round(value) * 100 / 100.0; // isiyo na maana
• Kutumia integer katika mgawanyiko Math.round(value * 100) / 100; // desimali zinaondoka
• Kukokotoa mara kwa mara katika hatua za kati → husababisha makosa kukusanyika kwa urahisi

Njia hii ni “rahisi na haraka,” lakini lazima uelewe kwamba inaweza kuwa isiyotosha wakati usahihi unahitajika.

4. Kukokotoa Sahihi kwa BigDecimal (Inashauriwa)

Kwa mahesabu ya fedha, mahesabu ya ushuru, na mtiririko mwingine ambapo makosa hayakubaliwa, kukokotoa kwa double na Math.round() si sahihi.

Katika hali hizo, njia inayopendekezwa ni kutumia BigDecimal.
BigDecimal ni darasa linaloweza kushughulikia nambari za msingi-10 kwa usahihi, na ni suluhisho la kawaida katika Java kwa “kukokotoa sahihi.”

4.1 Wakati Unapaswa Kutumia BigDecimal

Unapaswa kutumia BigDecimal kwa hali kama hizi:

• Mahesabu ya fedha (bei, ankara, salio)
• Mahesabu ya viwango kama viwango vya ushuru na viwango vya riba
• Uhasibu, fedha, na mifumo ya biashara
• Ushughulikiaji ambapo matokeo ya kukokotoa lazima yawe yanarudiwa

Kama matokeo ya mahesabu yenyewe yanahitajika (si tu onyesho), ni salama zaidi kuchagua BigDecimal badala ya double.

4.2 Njia Sahihi ya Kuunda BigDecimal (new vs valueOf)

Kosa la kawaida zaidi na BigDecimal ni kuilaunda kwa njia isiyo sahihi.

❌ Mfano usio sahihi (haipendekezwi)

BigDecimal bd = new BigDecimal(1.23);

Hii inabeba kosa la usahihi kutoka double.

✅ Mifano sahihi (inashauriwa)

BigDecimal bd1 = new BigDecimal("1.23");
BigDecimal bd2 = BigDecimal.valueOf(1.23);

• Kijenga cha String: chaguo salama zaidi
• valueOf : salama kwa sababu hubadilisha ndani kupitia String

Mwelekeo wa jumla: epuka new BigDecimal(double).

4.3 Jinsi ya Kutumia setScale() na RoundingMode

Ili kukokotoa kwa BigDecimal, kawaida unachanganya
setScale() na RoundingMode.

Mfano: Kokotoa hadi sehemu 2 za desimali

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal value = new BigDecimal("12.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 12.35

• Hoja ya 1: idadi ya sehemu za desimali za kuweka
• Hoja ya 2: sheria ya kukokotoa

RoundingMode.HALF_UP inalingana na sheria ya kawaida ya “kukaribia nusu juu” (5 na juu hukaribia juu).

Vizingiti, Onyo, na Makosa ya Kawaida

• Kutokubainisha RoundingMode value.setScale(2); // inaweza kutupa hitilafu
• Kufanya double → BigDecimal → kukokotoa katika mpangilio usio sahihi → Tumia BigDecimal tangu mwanzo
• Kuchanganya onyesho vs mahesabu → Tumia BigDecimal kwa mahesabu; fomatisha tu wakati wa kuonyesha

BigDecimal inaongeza msimbo zaidi, lakini ni muhimu kila wakati usahihi na usalama ni vipaumbele.

5. Aina za RoundingMode na Tofauti

Unapokokotoa kwa BigDecimal, dhana kuu unayopaswa kuelewa ni RoundingMode (hali ya kukokotoa).

RoundingMode inaeleza wazi “sheria gani ya kutumia,” na katika matumizi inapaswa kuchukuliwa kuwa lazima, kwa sababu kutokubainisha inafanya tabia kuwa isiyo wazi.

5.1 HALF_UP (Kokotoa ya Kawaida)

RoundingMode.HALF_UP inalingana na ufafanuzi wa kawaida zaidi wa kukokotoa.

Sheria

• Kama tarakimu inayofuata ni 5 au zaidi → karibia juu
• Kama tarakimu inayofuata ni 4 au chini → karibia chini

Mfano

BigDecimal value = new BigDecimal("2.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 2.35

Kama huna sababu maalum, kuchagua HALF_UP kwa kukokotoa kwa kawaida ni sahihi.

5.2 Jinsi Inavyotofautiana na HALF_DOWN / HALF_EVEN

RoundingMode ina mitindo kadhaa ya kurekebisha yenye majina sawa.
Wengi huchanganyikiwa hapa, kwa hivyo hebu tufafanue tofauti.

HALF_DOWN

• Ikiwa nambari inayofuata ni 5 haswa, rekebisha chini

  2.345 → 2.34
  

HALF_EVEN (Kurekebisha kwa Benki)

• Ikiwa nambari inayofuata ni 5 haswa, rekebisha kuelekea nambari karibu ya hata

  2.345 → 2.34
  2.355 → 2.36
  

HALF_EVEN hutumiwa kupunguza upendeleo wa kimfumo wa kurekebisha na inaweza kutajwa katika viwango vya fedha au takwimu, lakini si lazima kwa hali nyingi za biashara za kawaida na msimbo unaofaa wanaoanza.

5.3 Jinsi ya Kuchagua

Ikiwa hauwezi kuwa na uhakika, sheria ya uamuzi ni rahisi:

• Kurekebisha kawaida → HALF_UP
• Mfumo wa fedha/uliodhibitiwa na kiwango kilichofafanuliwa → fuata maelezo
• Hakuna sababu maalum → HALF_UP pekee

Makosa ya kawaida

• “Kutumia HALF_EVEN kwa sababu tu”
• “Nakili-kunakili bila kuelewa tofauti”

Mitindo ya kurekebisha ni sehemu ya maelezo ya mfumo wako.
Hausalimishwe kubadilisha bila sababu wazi.

Matatizo, Maonyo, na Makosa ya Kawaida

• Kuacha RoundingMode → inaweza kusababisha makosa wakati wa utendaji
• Kudhani kurekebisha daima inamaanish HALF_UP → inaweza kushindana na maelezo ya biashara
• Sheria za kurekebisha hazijawekwa viwango ndani ya timu → inaweza kusababisha matokeo yasiyolingana ya hesabu

6. Matatizo ya Kawaida, Maonyo, na Mifano ya Kushindwa

Kurekebisha katika Java ni eneo ambapo ni rahisi kufanya makosa hata kama unajua sintaksia na API.
Katika sehemu hii, tutahitimisha makosa ambayo watengenezaji wanaoanza hadi wa kati hufanya kwa kawaida, na kueleza wazi “kwa nini ni mbaya” na “jinsi ya kuepuka.”

6.1 Kufanya hesabu za pesa na double

Hii ni makosa ya kawaida zaidi na hatari zaidi.

double price = 1000.0;
double tax = price * 0.1;
double total = price + tax;

Inaweza kuonekana sawa kwa mtazamo wa kwanza, lakini
kwa kuwa double ni aina ambayo inaweza kujumuisha makosa ya usahihi,
inaleta hatari ya matokeo yasiyofaa katika hesabu za pesa.

Mtazamo sahihi

• Kwa hesabu: BigDecimal
• Kwa kuonyesha: kurekebisha/fomati

  BigDecimal price = new BigDecimal("1000");
  BigDecimal tax = price.multiply(new BigDecimal("0.1"));
  BigDecimal total = price.add(tax);
  

6.2 Kupata mpangilio wa kurekebisha vibaya

Na kurekebisha, unapoitumia inahali.

❌ Mfano mbaya

double a = Math.round(x * 100) / 100.0;
double b = Math.round(a * y * 100) / 100.0;

Ikiwa utarekebisha mara kwa mara wakati wa hatua za kati, makosa yanajumuika.

✅ Mwongozo wa msingi

• Kamilisha hesabu zote kwanza
• Tumia kurekebisha marafu mara moja kwa matokeo ya mwisho

6.3 Kuchanganya kurekebisha kwa kuonyesha na kurekebisha kwa hesabu

Ikiwa utachanganya “kurekebisha kwa kuonyesha” na “kurekebisha kwa hesabu za ndani,” muundo wako utavunjika.

Kuelewa vibaya kawaida

• Kutumia thamani iliyorekebishwa kwa kuonyesha katika hesabu inayofuata
• Kubadilisha mantiki ya hesabu ili iendane na mahitaji ya UI

Kutenganisha sahihi

• Hesabu ya ndani : weka kipaumbele usahihi (BigDecimal)
• Kuonyesha : fomati/kurekebisha

6.4 Kutoweza kurekebisha RoundingMode

Ikiwa sehemu tofauti za msimbo wako zinatumia mchanganyiko wa
HALF_UP, HALF_DOWN, na HALF_EVEN,
unaweza kuishia na matokeo yasiyolingana kutoka kwa hesabu sawa.

Hatua za kukabiliana

• Fafanua sheria ya kurekebisha kama thabiti
• Iweke viwango katika timu/mshauri

  static final RoundingMode ROUND_MODE = RoundingMode.HALF_UP;
  

Muhtasari wa Matatizo ya Kawaida

• Kwa sababu tu double “inaweza kuhesabu” haimaanishi ni “sahihi”
• Rekebisha mara moja tu, mwishoni
• Tumia sheria za kurekebisha kama sehemu ya maelezo yako
• Tenga hesabu na kuonyesha

Kuzingatia haya kunaweza kukusaidia kuepuka matatizo mengi yanayohusiana na kurekebisha.

7. Marejeo ya Haraka: Njia Gani ya Kutumia (Kwa Hali ya Matumizi)

Kama ilivyoelezwa hadi sasa, Java ina njia kadhaa za kukunja nambari, na jambo kuu si “ni ipi sahihi,” bali kwamba uchaguzi sahihi unategemea matumizi.

Katika sehemu hii, tutapanga uteuzi wa mbinu za vitendo kulingana na hali ili wasomaji waweze kuamua haraka.

7.1 Ikiwa Unataka Nambari Nzima Rahisi → Math.round()

Matumizi ya kawaida

• Unataka kuonyesha thamani iliyohesabiwa kama nambari nzima
• Hesabu, idadi ya watu, alama za ukadiriaji, n.k.
• Ushughulikiaji ambapo makosa ya usahihi hayako tatizo

Njia iliyopendekezwa

long result = Math.round(value);

Maelezo

• Aina ya kurudi ni int au long
• Haiendani ikiwa unahitaji kuweka desimali

👉 Ukihitaji “nambari nzima tu,” tumia Math.round().

7.2 Ikiwa Unataka Kuonyesha Hadi N Sehemu za Desimali → Math.round() + Scaling

Matumizi ya kawaida

• Nambari kwa ajili ya kuonyesha UI
• Ripoti na matokeo ya logi
• Matukio ambapo usahihi mkali hauhitajiki

Njia iliyopendekezwa (sehemu 2 za desimali)

double rounded = Math.round(value * 100) / 100.0;

Maelezo

• Makosa ya usahihi wa double bado yanabaki
• Usitumie kwa data ya mahesabu

👉 Inakubalika tu kwa ajili ya kuonyesha

7.3 Pesa, Kodi, Logic ya Biashara → BigDecimal + HALF_UP

Matumizi ya kawaida

• Pesa, bili, malipo
• Viwango vya kodi na viwango vya punguzo
• Logic ya biashara na data iliyohifadhiwa

Njia iliyopendekezwa

BigDecimal rounded =
    value.setScale(2, RoundingMode.HALF_UP);

Kwa Nini

• Inashughulikia nambari za msingi-10 kwa usahihi
• Inafanya sheria za kukunja kuwa wazi
• Inahakikisha upatikanaji tena

👉 Hii ni njia ya kawaida katika mifumo ya ulimwengu halisi

7.4 Mtiririko Rahisi wa Uamuzi Ukiwa na Shaka

• “Je, kosa fulani linakubalika?” wp:list /wp:list

  • YES → Math.round() -based approaches
  • NO → BigDecimal

• “Je, utahifadhi/kutumia tena matokeo?” wp:list /wp:list

  • YES → BigDecimal
  • NO (display only) → Math.round()

Makosa ya Kawaida (Uteuzi wa Mbinu)

• Kutumia tena msimbo wa kuonyesha tu katika logic ya biashara
• Kuendelea kutumia double kwa thamani za pesa
• Kutumia kupita kiasi Math.round() “kwa sababu ni rahisi”

Mara baada ya kupanga uteuzi wa mbinu, unaweza kupunguza kwa kiasi kikubwa gharama ya mabadiliko ya mahitaji ya baadaye na marekebisho ya hitilafu.

Maswali Yanayoulizwa Mara kwa Mara (FAQ)

Q1. Ni njia rahisi zaidi ya kukunja katika Java?

A. Ikiwa unataka tu kukunja hadi nambari nzima, Math.round() ndiyo rahisi zaidi. Hata hivyo, aina ya kurudi ni nambari nzima, kwa hivyo huwezi kuweka desimali.

Q2. Ninawezaje kukunja hadi sehemu 2 za desimali (au sehemu ya n?)

A. Kwa madhumuni ya kuonyesha, ongeza ukubwa wa nambari kama:
Math.round(value * 100) / 100.0
Ukihitaji usahihi, tumia BigDecimal.setScale().

Q3. Kwa nini matokeo yanabadilika ingawa ninatumia Math.round()?

A. Hii husababishwa na makosa ya usahihi wa nukta za kuzunguka katika double. Ni tabia ya Java, si hitilafu.

Q4. Je, ninapaswa kuepuka Math.round() kwa mahesabu ya pesa?

A. Ndiyo, haipendekezwi. Kwa mahesabu ya pesa na kodi, ni salama kutumia BigDecimal na kukunja kwa RoundingMode.HALF_UP.

Q5. Ninatumia BigDecimal lakini bado naona makosa wakati mwingine

A. Huenda unatumia new BigDecimal(double).
Tumia new BigDecimal("1.23") au BigDecimal.valueOf(1.23) badala yake.

Q6. Nini RoundingMode ninapaswa kuchagua?

A. Kwa kukunja kawaida, RoundingMode.HALF_UP ni chaguo salama. Ikiwa sekta yako ina viwango/maelekezo maalum, fuata hayo.

Q7. Je, ni sawa kukunja wakati wa mahesabu ya kati?

A. Haipendekezwi. Kukunja katika hatua za kati husababisha makosa kuongezeka, hivyo kanuni ya msingi ni kuitumia tu kwenye matokeo ya mwisho.

Q8. Je, ninapaswa kutenganisha kukunja kwa ajili ya kuonyesha na kukunja kwa mahesabu?

A. Ndiyo.

• Kwa mahesabu: BigDecimal (usahihi kwanza)
• Kwa kuonyesha: Math.round() au uformatishaji Kutenganisha ni muundo sahihi.