|
|
Julkaistu 7.4.2015 14.53.05
|
|
|
Suurten lukujen operaatioluokat on javalla, nimittäin java.math.BinInteger -luokka ja java.math.BigDecimal-luokka. Näitä kahta luokkaa käytetään korkean tarkkuuden laskentaan, jossa BigIntegur-luokka on suurten kokonaislukujen käsittelyluokka ja BigDecimal-luokka suurten ja pienten lukujen käsittelyluokka. Alla esittelemme BigDecimal-luokan:
BigDecimalin toteutus hyödyntää BigIntegeria, paitsi että BigDecimal lisää desimaalien käsitteen. Yleistä float- ja kaksoistyyppidataa voidaan käyttää vain tieteellisiin tai teknisiin laskelmiin, koska kaupallisessa laskennassa vaadittu numeerinen tarkkuus on suhteellisen korkea, joten käytetään java.math.BigDecimal -luokkaa, joka tukee kiintopisteiden tarkkuutta ja voidaan käyttää valuutan arvojen tarkkaan laskemiseen. Alla esittelemme lyhyesti sen käytön esimerkein
java.math.BigDecimal
Tänään kirjoitin ohjelman binääri- ja desimaalimuunnoksesta viitaten oppikirjaan, ja ohjelman algoritmi ei ole vaikea, mutta kirjoitettuani huomasin, että olipa se 2–10 tai 10–2, se ei ole hyvä muunnos luvuille, jotka ovat yli 2,1 miljardia, eli enemmän kuin kokonaislukualue. tulee olemaan nolla.
Hakuteoksissa on havaittu, että BigIntegerin käyttö ratkaisee tämän ongelman.
Joten etsin JDK:ta, testasin sitä useita kertoja ja lopulta kirjoitin sen onnistuneesti!
Käyttökokemus on seuraava:
1. BigInteger kuuluu java.math.BigIntegeriin, joten tuo tämä luokka ennen jokaista käyttöä. Joskus unohdin tuoda viestin alussa, jolloin kehotetta ei löydy vakiokehotteesta.
2. Rakennusmenetelmiä on monia, mutta nykyään niitä käytetään ajoittain:
BigInteger (String val)
Muunna BigIntegerin desimaalimerkkijonoesitys BigIntegeriksi.
BigInteger (Merkkijonon val, int radix)
Muuntaa BigIntearin merkkijonoesityksen määritellyn kardinaaliteetin osalta BigIntegeriksi.
Muuntaaksesi 2 int-tyyppistä BigInteger-tyypiksi, kirjoita BigInteger two=new BigInteger("2"); Huomautus 2: kaksoislainausmerkkejä ei saa jättää pois
3. BigInteger-luokka simuloi kaikkia int-tyypin matemaattisia operaatioita, kuten add()=="+", divide()=="-" jne., mutta huomaa, että sen sisältöä ei voi suoraan käyttää matemaattisiin operaatioihin matemaattisia operaatioita suorittaessa, vaan sen on käytettävä sen sisäisiä menetelmiä. Ja sen operandin täytyy myös olla tyyppiä BigInteger.
Esimerkiksi: two.add(2) on virheellinen operaatio, koska 2 ei muutu BigInteger -tyypiksi.
4. Kun haluat tuottaa laskentatulokset, sinun tulisi käyttää .toString-menetelmää muuntaaksesi ne desimaalimerkkijonoksi, seuraavasti:
String toString()
Palauttaa tämän BigIntegerin desimaalimerkkijonon esityksen.
Tulostusmenetelmä: System.out.print(two.toString());
5. Selitä käytetyt kolme funktiota.
BigInteger remainder (BigInteger val)
Palauttaa BigIntearin, jonka arvo on (tämä % val).
BigInteger negate()
BigInteger palauttaa arvon (-this).
int compareTo(BigInteger val)
Vertaa tätä BigIntearia määritettyyn BigIntegeriin.
Remainderis etsi loput.
Negate muuttaa operandin päinvastaiseksi.
Vertailu selitetään yksityiskohtaisesti seuraavasti:
vertaile
public int compareTo(BigInteger val)
Vertaa tätä BigIntearia määritettyyn BigIntegeriin. Tätä menetelmää suositaan jokaiselle kuudesta Boolen vertailuoperaattorista (<, ==, >, >=, !=, <=). Ehdotettu väite näiden vertailujen suorittamiseksi on: (x.compareTo(y) <op> 0), missä on <op> yksi kuudesta vertailuoperaattorista.
Tarkennus:
<BigInteger> Rajapinta Vertailukelpoinen
Parametrit:
val – BigIntear, joka vertaa tätä BigIntearia.
Takaisin:
Otsikko: Suoritetaan tarkat laskelmat liukulukuluvuista Javalla AYellow (alkuperäinen) muokkaus
Avainsanat: Java liukulukujen tarkka laskenta
Kysymys:
Mitä näkisimme, jos kääntäisimme ja ajaisimme seuraavan ohjelman?
public class Test{
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);
}
};
Luit oikein! Tulos on todellakin
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Yksinkertaisia kelluvia ja kaksoistyyppejä Javassa ei voi käyttää. Tätä ongelmaa ei löydy vain Javasta, vaan myös monista muista ohjelmointikielistä. Useimmissa tapauksissa laskelmat ovat tarkkoja, mutta voit yrittää vielä muutaman kerran (voit tehdä silmukan) kokeilla virheitä kuten yllä. Nyt ymmärrän vihdoin, miksi BCD-koodi on olemassa.
Tämä ongelma on melko vakava: jos sinulla on 9,99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
Jotkut ohjelmointikielet tarjoavat erikoistuneita valuuttatyyppejä tämän tilanteen hoitamiseksi, mutta Java ei. Nyt katsotaan, miten tämän voi korjata.
Pyöristys
Ensimmäinen reaktiomme on pyöristys. Matematiikan kurssin kierrosmenetelmää ei voi asettaa säilyttämään muutamaa desimaalia, voimme tehdä vain tämän (pitää kaksi paikkaa):
Julkinen kaksoiskierros (kaksoisarvo){
return Math.round(value*100)/100.0;
}
Valitettavasti yllä oleva koodi ei toimi, ja 4.015:n siirtäminen tälle menetelmälle palauttaa 4.01:n 4.02:n sijaan, kuten yllä näimme
4.015*100=401.4999999999999
Siksi, jos haluamme tehdä tarkan pyöristyksen, emme voi käyttää yksinkertaisia tyyppejä operaatioiden tekemiseen
java.text.DecimalFormat ei ratkaise tätä ongelmaa myöskään:
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
Lähtöarvo on 4,02
BigDecimal
Tämä periaate mainitaan myös kirjassa "Effective Java", float ja double voidaan käyttää vain tieteellisiin tai teknisiin laskelmiin, ja liiketalouden laskennassa tarvitaan java.math.BigDecimal. BigDecimalin rakentamiseen on neljä tapaa, emme välitä kahdesta, jotka tehdään BigIntegerillä, joten on kaksi muuta, jotka ovat:
BigDecimal (kaksoisval)
Kääntää kaksoisnumeron suureksi desimaaliksi.
BigDecimal (String val)
Kääntää BigDesimalin String repre -sentaation BigDesimaaliksi.
API on lyhyesti kuvattu ja se on yleensä helpompi käyttää. Saatamme käyttää sitä ajattelematta asiaa, mikä on ongelma? Kun jokin meni pieleen, huomasin, että yksityiskohtaisessa kuvauksessa oli tällainen kappale siitä, mikä yllä mainituista menetelmistä riitti:
Huomautus: tämän konstruktorin tulokset voivat olla melko arvaamattomia. Voisi olettaa, että uusi BigDecimal(.1) on täsmälleen yhtä kuin .1, mutta todellisuudessa se on .1000000000000000055511151231257827021181583404541015625. Tämä johtuu siitä, että 0,1 ei voida esittää tarkasti kaksoislukuna (tai kaksoismurto-osuutena, jolla on mikä tahansa äärellinen pituus). Näin ollen konstruktoriin siirretty pitkä arvo ei ole täsmälleen yhtä suuri kuin 0,1, ulkonäöstä huolimatta.
(String)konstruktori puolestaan on täysin ennustettavissa: uusi BigDecimal(".1") on täsmälleen yhtä kuin .1, kuten odottaa saattaa. Siksi yleisesti suositellaan, että (String)-konstruktoria käytetään tämän sijaan.
Käy ilmi, että jos meidän täytyy laskea tarkasti, meidän täytyy käyttää merkkijonoa luodaksemme BigDecimal! Kirjan Effective Java esimerkki käyttää Stringiä luodakseen BigDecimalin, mutta kirja ei korosta tätä, mikä saattaa olla pieni virhe.
Ratkaisu
Nyt kun tämä ongelma on ratkaistu, periaate on käyttää BigDesimaalia ja varmistaa, että käytät Stringiä.
Mutta kuvittele, että jos haluamme tehdä yhteenlaskuoperaation, meidän täytyy ensin muuntaa kaksi liukulukua merkkijonoksi, sitten luoda BigDecimal, kutsua yhteenlaskumenetelmä toiselle niistä, välittää toinen argumenttina ja muuntaa operaation tulos (BigDecimal) liukulukuluvuksi. Pystytkö kestämään näin tylsää prosessia? Alla esittelemme työkaluluokan Arith operaatiota yksinkertaistamiseksi. Se tarjoaa seuraavat staattiset menetelmät, kuten yhteenlaskun, vähennyksen, kertolaskun ja jakamisen sekä pyöristyksen:
Julkinen staattinen kaksoislisä (kaksoisv1, kaksoisv2)
Julkinen staattinen kaksoissub (kaksoisv1, kaksoisv2)
Julkinen staattinen kaksoismul (kaksoisv1, kaksoisv2)
Julkinen staattinen kaksoisdivisioona (kaksoisv1, kaksoisv2)
Julkinen staattinen kaksoisdiv (kaksoisv1, kaksoisv2, älykkyysasteikko)
Julkinen staattinen kaksoiskierros (kaksoisv, älykkyysasteikko)
Liite
Lähdetiedosto Arith.java:
tuo java.math.BigDecimal;
/**
* Koska Javan yksinkertaiset tyypit eivät pysty suorittamaan liukulukutoimintoja tarkasti, tämä työkaluluokka tarjoaa sakkoja
* Tarkat liukulukutoiminnot, mukaan lukien yhteenlasku, vähennyslasku, kertolasku, jakaminen ja pyöristys.
*/
public class Arith{
Oletusjakotoiminnan tarkkuus
yksityinen staattinen lopullinen älykkyys DEF_DIV_SCALE = 10;
Tätä luokkaa ei voi instansoitua
private Arith(){
}
/**
* Tarjoaa tarkat yhteenlaskuoperaatiot.
* @param v1 lisätään
* @param v2-lisäys
* @return Kahden parametrin summa
*/
julkinen staattinen double add(double v1, double v2){
BigDecimal b1 = uusi BigDecimal (Double.toString(v1));
BigDecimal b2 = uusi BigDecimal (Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Tarjoaa tarkat vähennyslaskut.
* @param v1 vähennetään
* @param v2 miinus
* @return Näiden kahden parametrin ero
*/
Julkinen staattinen double sub(double v1, double v2){
BigDecimal b1 = uusi BigDecimal (Double.toString(v1));
BigDecimal b2 = uusi BigDecimal (Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* Tarjoaa tarkat kertolaskuoperaatiot.
* @param v1 kerrotaan
* @param v2-kerroin
* @return Kahden parametrin tulo
*/
Julkinen staattinen kaksoismul(kaksoisv1, kaksoisv2){
BigDecimal b1 = uusi BigDecimal (Double.toString(v1));
BigDecimal b2 = uusi BigDecimal (Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* Tarjoaa (suhteellisen) tarkat jakotoiminnot, kun ehtymätön jako tapahtuu
* 10 desimaalia ja seuraavat numerot pyöristetään.
* @param v1 on jaettu
* @param v2-jakaja
* @return Kahden parametrin osamäärä
*/
Public static double div(double v1,double v2){
paluudivisioona (v1, v2, DEF_DIV_SCALE);
}
/**
* Tarjoaa (suhteellisen) tarkat divisioonaoperaatiot. Kun ehtymätön tilanne ilmenee, se ilmaistaan asteikkoparametrilla
* Määritä tarkkuus ja luvut, jotka pyöristetään sen jälkeen.
* @param v1 on jaettu
* @param v2-jakaja
* @param asteikko osoittaa, että sen täytyy olla tarkka muutamaan desimaaliin asti.
* @return Kahden parametrin osamäärä
*/
Public static double div(double v1,double v2,int scale){
if(scale<0){
heitä uusi IllegalArgumentException(
"Asteikon on oltava positiivinen kokonaisluku tai nolla");
}
BigDecimal b1 = uusi BigDecimal (Double.toString(v1));
BigDecimal b2 = uusi BigDecimal (Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Tarjoaa tarkan desimaalipyöristyksen.
* @param v vaatii lukujen pyöristystä
* @param asteikko varataan desimaalipisteen jälkeen
* @return Pyöristetyt tulokset
*/
Julkinen staattinen kaksoiskierros (kaksoisv, älykkyysasteikko){
if(scale<0){
heitä uusi IllegalArgumentException(
"Asteikon on oltava positiivinen kokonaisluku tai nolla");
}
BigDecimal b = uusi BigDecimal(Double.toString(v));
BigDesimaali yksi = uusi BigDesimaali("1");
return b.divide(one, scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Edellinen:On parasta olla asettamatta merkitystä sisältävää merkkijonoa ensisijaiseksi sävellaciksiSeuraava:JDK, JRE, JVM erot ja yhteydet
|
