|
|
Publicēts 07.04.2015 14:53:05
|
|
|
Lielu skaitļu darbības klases tiek nodrošinātas java, proti, java.math.BinInteger klase un java.math.BigDecimal klase. Šīs divas klases tiek izmantotas augstas precizitātes skaitļošanai, kur BigInteger klase ir lielu veselu skaitļu apstrādes klase un BigDecimal klase ir lielu un mazu skaitļu apstrādes klase. Zemāk mēs iepazīstinām ar BigDecimal klasi:
BigDecimal ieviešana izmanto BigInteger priekšrocības, izņemot to, ka BigDecimal pievieno decimāldaļu jēdzienu. Vispārīgos pludiņa un dubultā tipa datus var izmantot tikai zinātniskiem aprēķiniem vai inženiertehniskiem aprēķiniem, jo komerciālajā skaitļošanā nepieciešamā skaitliskā precizitāte ir salīdzinoši augsta, tāpēc tiek izmantota java.math.BigDecimal klase, kas atbalsta jebkuru fiksēto punktu precizitāti, un to var izmantot, lai precīzi aprēķinātu valūtas vērtības. Zemāk mēs īsumā iepazīstināsim ar tā izmantošanu ar piemēriem
java.math.BigDecimal
Šodien es uzrakstīju programmu par bināro un decimālo konvertēšanu, atsaucoties uz mācību grāmatu, un programmas algoritms nav grūti, bet pēc rakstīšanas es atklāju, ka neatkarīgi no tā, vai tas ir no 2 līdz 10 vai no 10 līdz 2, tas nav labs konvertējums skaitļiem, kas lielāki par 2,1 miljardu, tas ir, vairāk nekā veselu skaitļu diapazonu. kļūs par 0.
Uzziņu grāmatas ir atklājušas, ka BigInteger izmantošana atrisina šo problēmu.
Tāpēc es meklēju JDK, pēc tam pārbaudīju to vairākas reizes un beidzot veiksmīgi uzrakstīju!
Lietošanas pieredze ir šāda:
1. BigInteger pieder java.math.BigInteger, tāpēc importējiet šo klasi pirms katras lietošanas reizes. Reizēm sākumā aizmirsu importēt, tāpēc uzvedni nevar atrast pastāvīgajā uzvednē.
2. Ir daudz būvniecības metožu, bet tagad tās reizēm tiek izmantotas:
BigInteger(Virknes vērtība)
Konvertējiet BigInteger decimālo virknes attēlojumu par BigInteger.
BigInteger(String val, int radix)
Pārvērš norādītās kardinālitātes BigInteger virknes attēlojumu par BigInteger.
Lai konvertētu 2 no int tipa uz BigInteger tipu, rakstiet BigInteger two=new BigInteger("2"); 2. piezīme Dubultpēdiņas nevar izlaist
3. BigInteger klase simulē visas int tipa matemātiskās operācijas, piemēram, add()=="+", divide()=="-" utt., bet ņemiet vērā, ka tās saturu nevar tieši izmantot matemātiskām operācijām, veicot matemātiskās operācijas, un tai ir jāizmanto tās iekšējās metodes. Un tā operandam jābūt arī BigInteger tipam.
Piemēram: two.add(2) ir nepareiza operācija, jo 2 nekļūst par BigInteger tipu.
4. Ja vēlaties izvadīt aprēķina rezultātus, jāizmanto .toString metode, lai to pārvērstu decimālajā virknē, kā norādīts tālāk:
Virkne uz virkni()
Atgriež šī BigInteger decimāldaļas virknes attēlojumu.
Izvades metode: System.out.print(two.toString());
5. Izskaidrojiet trīs izmantotās funkcijas.
BigInteger atlikums(BigInteger val)
Atgriež BigInteger ar vērtību (šī % vērtība).
BigInteger noraidīt()
Funkcija BigInteger atgriež vērtību (-this).
int compareTo(BigInteger val)
Salīdziniet šo BigInteger ar norādīto BigInteger.
Atlikums tiek izmantots, lai atrastu atlikumu.
Negate pārvērš operandu pretējā virzienā.
Salīdzinājums ir detalizēti izskaidrots šādi:
salīdzināt ar
public int compareTo(BigInteger val)
Salīdziniet šo BigInteger ar norādīto BigInteger. Šī metode ir vēlama katram no sešiem Būla salīdzināšanas operatoriem (<, ==, >, >=, !=, <=). Ieteicamais apgalvojums šo salīdzinājumu veikšanai ir: (x.compareTo(y) <op> 0), kur ir <op> viens no sešiem salīdzināšanas operatoriem.
Norādītājs:
saskarne<BigInteger> Salīdzināms
Parametri:
val - BigInteger, kas salīdzina šo BigInteger ar to.
Atpakaļ:
Nosaukums: Peldošā komata skaitļu precīzu aprēķinu ieviešana Java AYellow (oriģinālā) modifikācijā
Atslēgvārdi: Java peldošā komata skaitļa precīzs aprēķins
Uzdotais jautājums:
Ko mēs redzētu, ja mēs apkopotu un palaistu šādu programmu?
publiskās klases tests{
public static void main(String args[]){
System.out.println(0.05+0.01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println(123.3/100);
}
};
Jūs izlasījāt pareizi! Rezultāts patiešām ir
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Vienkāršus pludiņus un dubultos tipus Java nevar izmantot. Šī problēma ir sastopama ne tikai Java, bet arī daudzās citās programmēšanas valodās. Vairumā gadījumu aprēķini ir precīzi, bet jūs varat mēģināt vēl dažas reizes (jūs varat veikt cilpu), lai izmēģinātu tādas kļūdas kā iepriekš minētā. Tagad es beidzot saprotu, kāpēc ir BCD kods.
Šī problēma ir diezgan nopietna, ja jums ir 9,99999999999999999 juaņas, jūsu dators nedomās, ka jūs varat iegādāties 10 juaņas preces.
Dažas programmēšanas valodas nodrošina specializētus valūtas veidus, lai risinātu šo situāciju, bet Java to nedara. Tagad redzēsim, kā to novērst.
Noapaļošana
Mūsu pirmā reakcija ir noapaļošana. Apaļo metodi matemātikas klasē nevar iestatīt, lai saglabātu dažas zīmes aiz komata, mēs to varam izdarīt tikai (saglabāt divas vietas):
publiskā dubultā kārta(dubultā vērtība){
atgriezt Math.round(vērtība*100)/100.0;
}
Diemžēl iepriekš minētais kods nedarbojas, nododot 4.015 uz šo metodi, atgriezīsies 4.01, nevis 4.02, kā mēs redzējām iepriekš
4.015*100=401.49999999999994
Tāpēc, ja mēs vēlamies veikt precīzu noapaļošanu, mēs nevaram izmantot vienkāršus veidus, lai veiktu jebkādas darbības
java.text.DecimalFormat arī neatrisina šo problēmu:
System.out.println(jauns java.text.DecimalFormat("0.00").format(4.025));
Izeja ir 4.02
Lielais decimālais skaitlis
Šis princips ir minēts arī grāmatā "Efektīva Java", pludiņš un dubultā var tikt izmantoti tikai zinātniskiem vai inženiertehniskiem aprēķiniem, un biznesa skaitļošanā mums jāizmanto java.math.BigDecimal. Ir 4 veidi, kā izveidot BigDecimal, mēs nerūpējamies par diviem, kas ir izgatavoti ar BigInteger, tāpēc ir vēl divi, kas ir:
BigDecimal(dubultā val)
Tulko dubultu par BigDecimal.
BigDecimal(Virknes val)
Tulko BigDecimal virknes attēlojumu par BigDecimal.
API ir īsi aprakstīts, un to parasti ir vieglāk izmantot. Mēs varam to izmantot, pat nedomājot par to, kāda būs problēma? Kad kaut kas nogāja greizi, es uzzināju, ka detalizētā aprakstā bija šāds punkts par to, kura no iepriekš minētajām metodēm bija pietiekama:
Piezīme: šī konstruktora rezultāti var būt nedaudz neparedzami. Varētu pieņemt, ka jaunais BigDecimal(.1) ir precīzi vienāds ar .1, bet patiesībā tas ir vienāds ar .1000000000000000055511151231257827021181583404541015625. Tas tā ir tāpēc, ka .1 nevar attēlot precīzi kā dubultu (vai kā jebkura ierobežota garuma bināru daļu). Tādējādi garā vērtība, kas tiek nodota konstruktoram, nav precīzi vienāda ar .1, neskatoties uz izskatu.
No otras puses, (String) konstruktors ir pilnīgi paredzams: jaunais BigDecimal(".1") ir precīzi vienāds ar .1, kā varētu sagaidīt. Tāpēc parasti ieteicams izmantot (virknes) konstruktoru, dodot priekšroku šim.
Izrādās, ka, ja mums ir nepieciešams precīzi aprēķināt, mums ir jāizmanto virkne, lai izveidotu BigDecimal! Piemērs grāmatā Effective Java izmanto virkni, lai izveidotu BigDecimal, bet grāmatā tas nav uzsvērts, kas var būt neliela kļūda.
Risinājums
Tagad, kad mēs esam atrisinājuši šo problēmu, princips ir izmantot BigDecimal un noteikti izmantot virkni.
Bet iedomājieties, ja mēs vēlamies veikt saskaitīšanas operāciju, mums vispirms jāpārvērš divi peldošā komata skaitļi uz virkni, pēc tam jāizveido BigDecimal, jāizsauc pievienošanas metode vienā no tiem, jānodod otrs kā arguments un pēc tam jāpārvērš operācijas rezultāts (BigDecimal) par peldošā komata skaitli. Vai jūs varat izturēt tik garlaicīgu procesu? Zemāk mēs piedāvājam rīku klasi Arith, lai vienkāršotu darbību. Tas piedāvā šādas statiskās metodes, ieskaitot saskaitīšanu, atņemšanu, reizināšanu un dalīšanu un noapaļošanu:
publiskā statiskā dubultā pievienošana (dubultā v1, dubultā v2)
Publiskais statiskais dubultais apakšpunkts (dubultā V1, dubultā V2)
Publiskais statiskais dubultais MUL (dubultais V1, dubultais V2)
publiskais statiskais dubultais div (dubultais v1, dubultais v2)
publiskais statiskais dubultais div (dubultā v1, dubultā v2, int skala)
Publiskā statiskā dubultā kārta (dubultā V, int skala)
Papildinājums
Avota faila Arith.java:
importēt java.math.BigDecimal;
/**
* Tā kā Java vienkāršie veidi nevar precīzi veikt peldošā komata operācijas, šī rīku klase nodrošina naudas sodus
* Precīzas peldošā komata operācijas, ieskaitot saskaitīšanu, atņemšanu, reizināšanu, dalīšanu un noapaļošanu.
*/
publiskās klases aritms{
Noklusējuma sadalīšanas operācijas precizitāte
privātais statiskais galīgais int DEF_DIV_SCALE = 10;
Šo klasi nevar instancēt
privātais Arith(){
}
/**
* Nodrošina precīzas pievienošanas operācijas.
* Tiek pievienots @param v1
* @param v2 papildinājums
* @return Abu parametru summa
*/
publiskā statiskā dubultā pievienošana(dubultā v1,dubultā v2){
BigDecimal b1 = jauns BigDecimal(Double.toString(v1));
BigDecimal b2 = jauns BigDecimal(Double.toString(v2));
atgriezt b1.add(b2).doubleValue();
}
/**
* Nodrošina precīzas atņemšanas operācijas.
* @param v1 tiek atņemts
* @param v2 mīnus
* @return Atšķirība starp abiem parametriem
*/
publiskais statiskais dubultais sub(dubultais v1, dubultais v2){
BigDecimal b1 = jauns BigDecimal(Double.toString(v1));
BigDecimal b2 = jauns BigDecimal(Double.toString(v2));
atgriezt b1.subtract(b2).doubleValue();
}
/**
* Nodrošina precīzas reizināšanas operācijas.
* @param v1 tiek reizināts
* @param v2 reizinātājs
* @return Abu parametru reizinājums
*/
publiskais statiskais dubultais MUL (dubultā v1, dubultā v2){
BigDecimal b1 = jauns BigDecimal(Double.toString(v1));
BigDecimal b2 = jauns BigDecimal(Double.toString(v2));
atgriezt b1.multiply(b2).doubleValue();
}
/**
* Nodrošina (relatīvi) precīzas sadalīšanas operācijas, kad notiek neizsmeļama sadalīšana
* 10 zīmes aiz komata, un nākamie cipari ir noapaļoti.
* @param v1 ir sadalīts
* @param v2 dalītājs
* @return Abu parametru koeficients
*/
publiskais statiskais dubultais div(dubultais v1, dubultais v2){
atgriezt div(v1;v2;DEF_DIV_SCALE);
}
/**
* Nodrošina (relatīvi) precīzas sadalīšanas operācijas. Ja rodas neizsmeļama situācija, to norāda skalas parametrs
* Nosakiet precizitāti, un skaitļi pēc tā tiks noapaļoti.
* @param v1 ir sadalīts
* @param v2 dalītājs
* @param skala norāda, ka tai jābūt precīzai līdz dažām zīmēm aiz komata.
* @return Abu parametru koeficients
*/
publiskais statiskais dubultais div(dubultā v1,dubultā v2,int skala){
if(mērogs<0){
mest jaunu IllegalArgumentException(
"Skalai jābūt pozitīvam veselam skaitlim vai nullei");
}
BigDecimal b1 = jauns BigDecimal(Double.toString(v1));
BigDecimal b2 = jauns BigDecimal(Double.toString(v2));
atgriezt b1.divide(b2,mērogs;BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Nodrošina precīzu decimāldaļu noapaļošanu.
* @param v ir nepieciešams skaitļu noapaļošana
* @param skala ir rezervēta aiz komata
* @return Noapaļoti rezultāti
*/
publiskais statiskais dubultais apaļš (dubultā v, int skala){
if(mērogs<0){
mest jaunu IllegalArgumentException(
"Skalai jābūt pozitīvam veselam skaitlim vai nullei");
}
BigDecimal b = jauns BigDecimal(Double.toString(v));
BigDecimal one = jauns BigDecimal("1");
atgriezt b.divide(viens,mērogs,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Iepriekšējo:Vislabāk nav iestatīt virkni ar nozīmi kā primāro atslēguNākamo:JDK, JRE, JVM atšķirības un savienojumi
|
