|
|
Publisert på 07.04.2015 14:53:05
|
|
|
Operasjonsklasser for store tall tilbys i Java, nemlig java.math.BinInteger-klassen og java.math.BigDecimal-klassen. Disse to klassene brukes til høypresisjonsdatabehandling, hvor BigInteger-klassen er prosesseringsklassen for store heltall og BigDecimal-klassen er prosesseringsklassen for store og små tall. Nedenfor introduserer vi BigDecimal-klassen:
Implementeringen av BigDecimal utnytter BigInteger, bortsett fra at BigDecimal legger til begrepet desimaler. Generelle flyt- og dobbelttypedata kan kun brukes til vitenskapelige eller ingeniørmessige beregninger, fordi den nødvendige numeriske nøyaktigheten i kommersiell databehandling er relativt høy, så java.math.BigDecimal-klassen brukes, som støtter enhver presisjon av faste punkter, og kan brukes til å beregne valutaverdier nøyaktig. Nedenfor vil vi kort introdusere bruken med eksempler
java.math.BigDecimal
I dag skrev jeg et program om binær- og desimalkonvertering med referanse til læreboken, og programalgoritmen er ikke vanskelig, men etter å ha skrevet fant jeg ut at enten det er 2 til 10 eller 10 til 2, er det ikke en god konvertering for tall større enn 2,1 milliarder, altså mer enn heltallsområdet. vil bli 0.
Referansebøker har funnet at bruk av BigInteger løser dette problemet.
Så jeg slo opp JDK-en, testet den flere ganger og skrev den til slutt vellykket!
Bruksopplevelsen er som følger:
1. BigInteger tilhører java.math.BigInteger, så importer denne klassen før hver bruk. Av og til glemte jeg å importere i starten, så prompten kan ikke finnes i konstantprompten.
2. Det finnes mange byggemetoder, men nå brukes de av og til:
BigInteger (Strengval)
Konverter den desimale strengrepresentasjonen av BigInteger til BigInteger.
BigInteger (Strengval, int radix)
Konverterer strengrepresentasjonen til BigInteger for den spesifiserte kardinaliteten til BigInteger.
For å konvertere 2 av int-typen til BigInteger-typen, skriv BigInteger two=new BigInteger("2"); Merknad 2: doble anførselstegn kan ikke utelates
3. BigInteger-klassen simulerer alle int-type matematiske operasjoner, som add()=="+", divide()=="-", osv., men merk at innholdet ikke kan brukes direkte til matematiske operasjoner ved utførelse av matematiske operasjoner, og må bruke dens interne metoder. Og dens operand må også være av typen BigInteger.
For eksempel: two.add(2) er en feil operasjon fordi 2 ikke blir en BigInteger-type.
4. Når du vil gi ut beregningsresultatene, bør du bruke .toString-metoden for å konvertere det til en desimalstreng, så detaljert som følger:
String toString()
Returnerer den desimale strengrepresentasjonen til dette BigInteger.
Utdatametode: System.out.print(two.toString());
5. Forklar de tre funksjonene som brukes.
BigInteger rest(BigInteger val)
Returnerer et BigInteger med verdien (denne % val).
BigInteger negate()
BigInteger returnerer en verdi på (-dette).
int compareTo(BigInteger val)
Sammenlign dette BigInteger med det spesifiserte BigInteger.
Remainderis ble brukt til å finne resten.
Negate gjør operanden til det motsatte.
Sammenligningen forklares i detalj som følger:
sammenlign.
offentlig int compareTo(BigInteger val)
Sammenlign dette BigInteger med det spesifiserte BigInteger. Denne metoden foretrekkes for hver av de seks boolske sammenligningsoperatorene (<, ==, >, >=, !=, <=). Det foreslåtte utsagnet for å utføre disse sammenligningene er: (x.compareTo(y) <op> 0), hvor er <op> en av de seks sammenligningsoperatorene.
Spesifiserer:
<BigInteger> Grensesnitt Sammenlignbart
Parametere:
val - BigInteger som sammenligner dette BigInteger med det.
Bak:
Tittel: Implementering av presise beregninger av flyttallstall i Java AYellow (original) modifikasjon
Nøkkelord Java flyttallsnøyaktig beregning
Spørsmål stilt:
Hva ville vi sett hvis vi kompilerte og kjørte følgende program?
offentlig klasse Test{
offentlig statisk 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);
}
};
Du leste riktig! Resultatet er, faktisk,
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Enkle float- og double types i Java kan ikke opereres. Dette problemet finnes ikke bare i Java, men også i mange andre programmeringsspråk. I de fleste tilfeller er beregningene nøyaktige, men du kan prøve noen ganger til (du kan gjøre en løkke) for å prøve feil som den over. Nå forstår jeg endelig hvorfor det finnes en BCD-kode.
Dette problemet er ganske alvorlig; hvis du har 9,999999999999999999999999 yuan, vil ikke datamaskinen din tro at du kan kjøpe varer for 10 yuan.
Noen programmeringsspråk tilbyr spesialiserte valutatyper for å håndtere denne situasjonen, men det gjør ikke Java. La oss nå se hvordan vi kan fikse dette.
Avrunding
Vår første reaksjon er å gjøre runding. Rundmetoden i matteklassen kan ikke settes til å beholde noen få desimaler, vi kan bare gjøre dette (beholde to plasser):
offentlig dobbel runde(dobbel verdi){
returner Math.round(verdi*100)/100,0;
}
Dessverre fungerer ikke koden ovenfor, og å sende inn 4.015 til denne metoden vil returnere 4.01 i stedet for 4.02, som vi så ovenfor
4.015*100=401.4999999999999994
Derfor, hvis vi vil gjøre nøyaktig avrunding, kan vi ikke bruke enkle typer til å utføre noen operasjoner
java.text.DecimalFormat løser heller ikke dette problemet:
System.out.println(ny java.text.DecimalFormat("0.00").format(4.025));
Utgangen er 4,02
BigDecimal
Dette prinsippet nevnes også i boken "Effective Java", float og double kan kun brukes til vitenskapelige eller tekniske beregninger, og i forretningsdatabehandling må vi bruke java.math.BigDecimal. Det finnes fire måter å bygge BigDecimal på, vi bryr oss ikke om de to som lages med BigInteger, så det finnes to til, som er:
BigDecimal (dobbel val)
Oversetter en dobbel til en stor desimal.
BigDecimal (Strengval)
Oversetter String-repre-setningen til en BigDecimal til en BigDecimal.
API-et er kort beskrevet og er vanligvis enklere å bruke. Vi kan bruke det uten å tenke over det, hva blir problemet? Når noe gikk galt, fant jeg ut at det var et slikt avsnitt i den detaljerte beskrivelsen av hvilken av de ovennevnte metodene som var tilstrekkelig:
Merk: resultatene til denne konstruktøren kan være noe uforutsigbare. Man kan anta at ny BigDecimal(.1) er nøyaktig lik .1, men den er faktisk lik .1000000000000000055511151231257827021181583404541015625. Dette er fordi 0,1 ikke kan representeres nøyaktig som en dobbel (eller, for den saks skyld, som en binær brøk av noen endelig lengde). Dermed er den lange verdien som sendes inn i konstruktøren ikke nøyaktig lik 0,1, utseendene er ikke til side.
(String)-konstruktøren, derimot, er helt forutsigbar: ny BigDecimal(".1") er nøyaktig lik 0,1, som man kan forvente. Derfor anbefales det generelt at (Streng)-konstruktøren brukes fremfor denne.
Det viser seg at hvis vi må regne nøyaktig, må vi bruke String for å lage BigDecimal! Eksempelet i boken Effective Java bruker String for å lage BigDecimal, men boken legger ikke vekt på dette, noe som kan være en liten feil.
Løsning
Nå som vi har løst dette problemet, er prinsippet å bruke BigDecimal og sørge for å bruke String.
Men tenk deg at hvis vi vil gjøre en addisjonsoperasjon, må vi først konvertere to flyttallstall til String, deretter lage en BigDecimal, kalle addimetoden på ett av dem, sende det andre som et argument, og deretter konvertere resultatet av operasjonen (BigDecimal) til et flyttall. Kan du tåle en så kjedelig prosess? Nedenfor gir vi verktøyklassen Arith for å forenkle operasjonen. Den tilbyr følgende statiske metoder, inkludert addisjon, subtraksjon, multiplikasjon og divisjon, samt avrunding:
offentlig statisk dobbel add (dobbel v1, dobbel v2)
offentlig statisk dobbel sub (dobbel v1, dobbel v2)
offentlig statisk dobbel mul (dobbel v1, dobbel v2)
offentlig statisk dobbel div (dobbel v1, dobbel v2)
offentlig statisk dobbel div (dobbel v1, dobbel v2, int-skala)
Offentlig statisk dobbel runde (dobbel V, Int skala)
Vedlegg
Kildefil Arith.java:
import java.math.BigDecimal;
/**
* Siden Javas enkle typer ikke kan utføre flyttallsoperasjoner nøyaktig, gir denne verktøyklassen fines
* Eksakte flyttallsoperasjoner, inkludert addisjon, subtraksjon, multiplikasjon, divisjon og avrunding.
*/
offentlig klasse Arith{
Standard nøyaktighet i divisjonsoperasjoner
privat statisk final int DEF_DIV_SCALE = 10;
Denne klassen kan ikke instansieres
privat Arith(){
}
/**
* Gir presise addisjonsoperasjoner.
* @param v1 legges til
* @param v2-tillegg
* @return Summen av de to parameterne
*/
offentlig statisk dobbel add(dobbel v1,dobbel v2){
BigDecimal b1 = ny BigDecimal(Double.toString(v1));
BigDecimal b2 = ny BigDecimal(Double.toString(v2));
returner b1.add(b2).doubleValue();
}
/**
* Gir presise subtraksjonsoperasjoner.
* @param v1 trekkes fra
* @param v2 minus
* @return Forskjellen mellom de to parameterne
*/
offentlig statisk dobbel sub(dobbel v1,dobbel v2){
BigDecimal b1 = ny BigDecimal(Double.toString(v1));
BigDecimal b2 = ny BigDecimal(Double.toString(v2));
returner b1.subtraher(b2).doubleValue();
}
/**
* Gir presise multiplikasjonsoperasjoner.
* @param v1 multipliseres
* @param v2-multiplikator
* @return Produktet av de to parameterne
*/
offentlig statisk dobbel MUL(dobbel v1,dobbel v2){
BigDecimal b1 = ny BigDecimal(Double.toString(v1));
BigDecimal b2 = ny BigDecimal(Double.toString(v2));
returner b1.multipliser(b2).doubleValue();
}
/**
* Gir (relativt) nøyaktige divisjonsoperasjoner når uuttømmelig divisjon skjer
* 10 desimaler, og følgende sifre avrundes.
* @param v1 deles
* @param v2 divisor
* @return Kvotienten av de to parameterne
*/
offentlig statisk dobbel div(dobbel v1,dobbel v2){
return-div(v1,v2,DEF_DIV_SCALE);
}
/**
* Gir (relativt) nøyaktige divisjonsoperasjoner. Når en uuttømmelig situasjon oppstår, indikeres det med skalaparameteren
* Bestem nøyaktigheten, og tallene etterpå vil bli rundet.
* @param v1 deles
* @param v2 divisor
* @param skala indikerer at den må være nøyaktig til noen desimaler.
* @return Kvotienten av de to parameterne
*/
offentlig statisk dobbel div(dobbel v1,dobbel v2,int-skala){
if(scale<0){
kast nytt UlovligArgumentUnntak(
"Skalaen må være et positivt heltall eller null");
}
BigDecimal b1 = ny BigDecimal(Double.toString(v1));
BigDecimal b2 = ny BigDecimal(Double.toString(v2));
returner b1.divide(b2,skala,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Gir presis desimalavrunding.
* @param v krever avrundingstall
* @param skalaen er reservert etter desimalpunktet
* @return Avrundede resultater
*/
offentlig statisk dobbel runde (dobbel v,int-skala){
if(scale<0){
kast nytt UlovligArgumentUnntak(
"Skalaen må være et positivt heltall eller null");
}
BigDecimal b = ny BigDecimal(Double.toString(v));
BigDecimal én = ny BigDecimal ("1");
returner b.divide(en,skala,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Foregående:Det er best å ikke sette en streng med betydning som primærtoneartNeste:JDK, JRE, JVM forskjeller og forbindelser
|
