Noen rare ting om Java Math - dummies

Tro det eller ikke, datamaskiner - selv de sterkeste - har visse begrensninger når det gjelder å utføre matteberegninger. Disse begrensningene er vanligvis ubetydelige, men noen ganger sniker de seg og biter deg. Her er de tingene du trenger å passe på når du gjør matte i Java.

Integer overflow

Det grunnleggende problemet med heltalltyper er at de har en fast størrelse. Som et resultat er det en grense for størrelsen på tallene som kan lagres i variabler av typen kort , int eller lang . Selv om lange -variabler kan inneholde tall som er store, kommer du før eller senere over et tall som er for stort til å passe inn i en lang -variabel.

Ok, vurder dette (admittedly contrived) eksempelet:

int a = 1000000000;

System. ute. println (a);

a + = 1000000000;

System. ute. println (a);

a + = 1000000000;

System. ute. println (a);

a + = 1000000000;

System. ute. println (a);

Her forventer du verdien av a for å bli større etter hvert tillegg. Men her er resultatet som vises:

1000000000

2000000000

-1294967296

-294967296

Den første tilsetningen ser ut til å fungere, men etter dette blir nummeret negativt! Det er fordi verdien har nådd størrelsesgrensen for datatypen int . Dessverre sier Java ikke deg at denne feilen har skjedd. Den smelter bare int -variabelen så full av biter som mulig, kasserer hvilke biter som ikke passer, og håper at du ikke merker. På grunn av måten int lagrer negative verdier, blir store positive verdier plutselig store negative verdier.

Historien er at hvis du jobber med store heltall, bør du bruke lang i stedet for int , fordi lang kan lagre mye større tall enn int . Hvis programmene dine håndterer tall som er store nok til å være et problem for lang , bør du vurdere å bruke flytende punkttyper i stedet. Flytende typer kan håndtere enda større verdier enn lang , og de forteller deg når du overskrider deres kapasitet.

Flytende punktethet

Flytepunktstall har egne problemer. Til å begynne med lagres flytende punktnumre ved hjelp av det binære talesystemet (base 2), men mennesker arbeider med tall i desimalnummersystemet (base 10). Dessverre er det noen ganger umulig å omregne tall mellom disse to systemene. Det er fordi enkelte fraksjoner ikke kan representere nøyaktig i noen tallbase.

Ett eksempel: Base 10 har ingen måte å presisere fraksjonen 1/3. Du kan omtrentlige den som 0. 3333333, men til slutt når du grensen for hvor mange sifre du kan lagre, så du må slutte. I base 2 skjer det at en av de brøkdelene du ikke kan representere nøyaktig, er desimalverdien 1/10. Med andre ord kan en float eller dobbel variabel ikke representere nøyaktig 0. 1 .

Prøv å kjøre denne koden:

float x = 0. 1f;

NumberFormat nf = NumberFormat. getNumberInstance ();

nf. setMinimumFractionDigits (10);

System. ute. println (nf. format (x));

Resultatet er dette:

0. 1000000015

Selv 0. 1000000015 er lukk i 0. 1 , det er ikke eksakt.

I de fleste tilfeller er Java's flytende punktmatematikk nær nok, ikke noe å si noe om. Feilmarginen er ekstremt liten. Hvis du bruker Java til å måle størrelsen på huset ditt, trenger du et elektronmikroskop for å legge merke til feilen. Hvis du skriver programmer som omhandler finansielle transaksjoner, kan normal avrunding noen ganger forstørre feilene for å gjøre dem signifikante. Du kan kreve en krone for mye eller for liten omsetningsavgift. Og i ekstreme tilfeller kan fakturaene dine faktisk ha åpenbare tilleggsfeil.

Heltall er også lagret i binær, selvfølgelig. Men heltallene er ikke underlagt de samme feilene som flytende punkttyper er - fordi heltall ikke representerer brøker i det hele tatt - så du trenger ikke å bekymre deg for denne typen feil for heltall typer.

Divisjon med null

I henhold til grunnleggende regler for matematikk, kan du ikke dele et tall med null. Årsaken er enkel: Division er invers av multiplikasjon - som betyr at hvis a * b = c , er det også sant at a = c / b . Hvis du skulle tillate b å være null, vil divisjon være meningsløs, fordi noen ganger ganger null er null. Derfor må både a og c også være null. Kort sagt, matematikere løst dette dilemmaet for århundrer siden ved å si at divisjon med null er rett og slett ikke tillatt.

Så hva skjer hvis du gjør forsøker å dele et tall med null i et Java-program? Svaret avhenger av om du deler heltall eller flytende punktnumre. Hvis du deler heltall, slår setningen som forsøker divisjonen med null, opp det som kalles unntak, som er en uheldig måte å krasje programmet på.

Det finnes en måte å fange opp dette unntaket for å la programmet fortsette som du ikke finner ut her. I mellomtiden, et hvilket som helst program du skriver som forsøker et heltall divisjon med null krasjer.

Hvis du prøver å dele en flytende punkt med null, er resultatene ikke så brå. I stedet tilordner Java til flytpunktresultatet en av de spesielle verdiene som er oppført i tabellen nedenfor. Følgende avsnitt forklarer hvordan disse spesielle verdiene bestemmes:

• Hvis du deler et tall med null, og tegnet på begge tallene er det samme, er resultatet en positiv uendelighet. 0. 0 divisjonert med 0. 0 er positiv uendelighet, som er -34. 0 delt med -0. 0 .
• Hvis du deler et tall med null, og tegnene på tallene er forskjellige, er resultatet negativt uendelig. -40. 0 divisjonert med 0. 0 er negativ uendelighet, som er 34. 0 divisjonert med 0. 0 .
• Hvis du deler null med null, er resultatet ikke et tall (NaN), uavhengig av tegnene.

Spesielle konstanter for flottøren og de doble klassene

Konstant	Betydning
POSITIVE_INFINITY	Positiv uendelighet
NEGATIVE_INFINITY	Negativ uendelighet
NaN	Ikke et nummer

Flytende nuller kan være positive eller negative. Java anser positive og negative nuller å være like numerisk.

Hvis du prøver å skrive ut en flytende punktverdi som har en av disse spesielle verdiene, konverterer Java verdien til en passende streng. Anta at du utfører følgende påstander:

double x = Math. sqrt (-50); // Ikke et tall

dobbelt y = x;

hvis (x == y)

System. ute. println ("x er lik y");

Den resulterende konsollutgangen er

Uendelig

Hvis i var -50. 0 , vil konsollen vise -Infinity , og hvis i var null, vil konsollen vise NaN .

De følgende avsnittene beskriver noen siste biter av raritet:

• NaN er ikke lik selv, noe som kan ha noen merkelige konsekvenser. For eksempel:

dobbelt x = matematikk. sqrt (-50); // Ikke et tall

dobbelt y = x;

hvis (x == y)

System. ute. println ("x er lik y");

Bare antar, for argumentets skyld, at hvis -testen tester om variabelen x er lik variabelen y . Fordi denne testen umiddelbart følger en oppgaveoppgave som tilordner verdien av x til y , kan du trygt anta at x er lik y , Ikke sant?

feil. Fordi x er NaN , y også er NaN . NaN anses aldri for å være lik alle andre verdier, inkludert en annen NaN . Dermed mislykkes sammenligningen i hvis setningen.

• En annen merkelig konsekvens: Du kan ikke anta at et tall minus seg selv alltid er null. Vurder denne setningen:

double z = x - x; // ikke nødvendigvis null

Skal ikke denne setningen alltid sette z til null? Ikke hvis x er NaN . I så fall er ikke et tall minus ikke et tall fortsatt et nummer.

• En annen merkelighet: Enhver matematisk operasjon som involverer uendelig, resulterer i en annen uendelighet eller NaN . Infinity + 5, for eksempel, er likevel uendelig, så Buzz Lightyears kall "Til uendelig og utover! "Bare kommer ikke til å skje. Men uendelig minus uendelig gir deg … NaN .