|
|
Zveřejněno 07.04.2015 14:53:05
|
|
|
V Javě jsou poskytovány operační třídy pro velká čísla, konkrétně třída java.math.BinInteger a třída java.math.BigDecimal. Tyto dvě třídy se používají pro vysoce přesné výpočty, přičemž třída BigInteger je třída zpracování pro velká celá čísla a třída BigDecimal je třída pro zpracování velkých a malých čísel. Níže představujeme třídu BigDecimal:
Implementace BigDecimal využívá BigInteger, ale BigDecimal přidává koncept desetinných čísel. Obecná plovoucí a dvojitá data lze použít pouze pro vědecké nebo inženýrské výpočty, protože v komerční výpočetní technice je požadovaná numerická přesnost relativně vysoká, proto se používá třída java.math.BigDecimal, která podporuje jakoukoli přesnost pevných bodů a může být použita k přesnému výpočtu měnových hodnot. Níže stručně představíme jeho použití s příklady
java.math.BigDecimal
Dnes jsem napsal program o binárním a desetinném převodu s odkazem na učebnici, a algoritmus programu není obtížný, ale po jeho napsání jsem zjistil, že ať už je to 2 ku 10 nebo 10 ku 2, není to dobrý převod pro čísla větší než 2,1 miliardy, tedy více než celočíselný rozsah. se stane 0.
Odborné knihy zjistily, že použití BigInteger tento problém řeší.
Tak jsem si JDK vyhledal, několikrát ho otestoval a nakonec jsem ho úspěšně napsal!
Zážitek z používání je následující:
1. BigInteger patří do java.math.BigInteger, proto tuto třídu importujte před každým použitím. Občas jsem zapomněl importovat na začátku, takže prompt nelze najít v neustálém promptu.
2. Existuje mnoho stavebních metod, ale nyní se občas používají:
BigInteger(hodnota řetězce)
Převeďte desetinnou reprezentaci řetězce BigInteger na BigInteger.
BigInteger(Hodnota řetězce, int radix)
Převede řetězcovou reprezentaci BigInteger pro určenou kardinálnost na BigInteger.
Pro převod 2 int typu na BigInteger typ zapisujeme BigInteger two=new BigInteger("2"); Poznámka 2: dvojité uvozovky nelze vynechat
3. Třída BigInteger simuluje všechny int-typ matematické operace, jako je add()=="+", divide()=="-" atd., ale je třeba poznamenat, že její obsah nelze přímo použít pro matematické operace při provádění matematických operací a musí použít své interní metody. A jeho operand musí být také typu BigInteger.
Například: two.add(2) je nesprávná operace, protože 2 se nestává typem BigInteger.
4. Když chcete výstup výsledků výpočtu, měli byste použít metodu .toString k jejich převodu na desetinný řetězec, jak je popsáno následovně:
String toString()
Vrátí desetinnou reprezentaci řetězce tohoto BigInteger.
Metoda výstupu: System.out.print(two.toString());
5. Vysvětlete tři použité funkce.
BigInteger remainder(BigInteger val)
Vrací BigInteger s hodnotou (toto % hodnota).
BigInteger negate()
BigInteger vrací hodnotu (-this).
int compareTo(BigInteger val)
Porovnejte toto BigInteger s zadaným BigInteger.
Zbytk se používá k nalezení zbytku.
Negace mění operand v opak.
Compare je podrobně vysvětlen následovně:
compareTo
public int compareTo(BigInteger val)
Porovnejte toto BigInteger s zadaným BigInteger. Tato metoda je preferována pro každý ze šesti Booleovských srovnávacích operátorů (<, ==, >, >=, !=, <=). Navrhované tvrzení pro provedení těchto porovnání je: (x.compareTo(y) <op> 0), kde je <op> jedním ze šesti operátorů porovnání.
Specifikátor:
rozhraní<BigInteger> Srovnatelné
Parametry:
val – Velké celé číslo, které toto Velké celé číslo s ním srovnává.
Záda:
Název Implementace přesných výpočtů čísel s plovoucí desetinnou čárkou v Java AYellow (původní) modifikaci
Klíčová slova: Java přesný výpočet počtu s plovoucí desetinnou čárkou
Otázka:
Co bychom viděli, kdybychom zkompilovali a spustili následující program?
test veřejné třídy{
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);
}
};
Čtete správně! Výsledek je skutečně
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Jednoduché plovoucí a dvojité typy v Javě nelze provozovat. Tento problém se nevyskytuje pouze v Javě, ale i v mnoha dalších programovacích jazycích. Ve většině případů jsou výpočty přesné, ale můžete to zkusit ještě několikrát (můžete udělat smyčku) a zkusit chyby jako ta výše. Teď konečně chápu, proč existuje BCD kód.
Tento problém je poměrně vážný, pokud máte 9,99999999999999999 jüanů, váš počítač si nebude myslet, že můžete koupit zboží za 10 jüanů.
Některé programovací jazyky poskytují specializované typy měn pro řešení této situace, ale Java nikoliv. Teď se podíváme, jak to opravit.
Zaokrouhlování
Naše první reakce je zaokrouhlování. Metoda zaokružování v matematické třídě nemůže být nastavena tak, aby udržovala několik desetinných míst, můžeme pouze toto (ponechat dvě místa):
veřejné dvojité kolo (dvojnásobná hodnota){
return Math.round(value*100)/100.0;
}
Bohužel výše uvedený kód nefunguje, předání 4.015 této metodě vrátí 4.01 místo 4.02, jak jsme viděli výše
4.015*100=401.4999999999999994
Proto pokud chceme provádět přesné zaokrouhlování, nemůžeme použít jednoduché typy k provádění operací
java.text.DecimalFormat tento problém také neřeší:
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
Výstup je 4,02
BigDecimal
Tento princip je zmíněn také v knize "Effective Java", float a double lze použít pouze pro vědecké nebo inženýrské výpočty, a v business computingu je třeba použít java.math.BigDecimal. Existují 4 způsoby, jak BigDecimal postavit, nám nevadí ty dva, které jsou vytvořeny pomocí BigInteger, takže jsou tu ještě dva další, a to:
BigDecimal (dvojitá hodnota)
Překládá dvojnásobek na BigDecimal.
BigDecimal (hodnota řetězce)
Překládá řetězec representace velkého desetinného čísla na velké desetinné číslo.
API je stručně popsáno a obvykle je jednodušší na používání. Můžeme ho použít, aniž bychom o tom přemýšleli, jaký bude problém? Když se něco pokazilo, zjistil jsem, že v podrobném popisu je takový odstavec, který z výše uvedených metod je dostačující:
Poznámka: výsledky tohoto konstruktoru mohou být poněkud nepředvídatelné. Dalo by se předpokládat, že nový BigDecimal(.1) je přesně roven 0,1, ale ve skutečnosti je roven 0,1000000000000000055511151231257827021181583404541015625. Je tomu tak proto, že .1 nelze přesně reprezentovat jako dvojnásobek (ani, mimochodem, jako binární zlomek jakékoli konečné délky). Tedy dlouhá hodnota, která je předávána konstruktérovi, není přesně rovna 0,1, bez ohledu na vzhled.
Konstruktor (String) je naopak dokonale předvídatelný: nový BigDecimal(".1") je přesně roven .1, jak by se dalo očekávat. Proto se obecně doporučuje použít konstruktor (String) před tímto konstruktorem.
Ukazuje se, že pokud potřebujeme přesně počítat, musíme použít String k vytvoření BigDecimal! Příklad v knize Effective Java používá řetězec k vytvoření BigDecimal, ale kniha to nezdůrazňuje, což může být drobná chyba.
Řešení
Nyní, když jsme tento problém vyřešili, princip je používat BigDecimal a ujistit se, že použijeme String.
Ale představte si, že pokud chceme provést operaci sčítání, musíme nejprve převést dvě čísla s plovoucí desetinnou čárkou na String, pak vytvořit BigDecimal, zavolat metodu sčítání na jedno z nich, předat druhé jako argument a nakonec převést výsledek operace (BigDecimal) na číslo s plovoucí desetinnou čárkou. Dokážete vydržet tak únavný proces? Níže uvádíme třídu nástrojů Arith, která zjednodušuje operaci. Nabízí následující statické metody, včetně sčítání, odečítání, násobení a dělení a zaokrouhlování:
Veřejné statické dvojité sčítání (dvojité v1, dvojité v2)
Veřejný statický dvojitý subwoofer (dvojitý v1, dvojitý v2)
Veřejný statický dvojitý mul (dvojitý v1, dvojitý v2)
Veřejný statický dvojitý div (dvojitý v1, dvojitý v2)
Veřejný statický dvojitý rozděl (dvojitý v1, dvojitý v2, int škála)
Veřejné statické dvojité kolo (dvojité V, INT měřítko)
Příloha
Zdrojový soubor Arith.java:
import java.math.BigDecimal;
/**
* Protože jednoduché typy v Javě nemohou přesně provádět operace s plovoucí desetinnou čárkou, tato třída nástrojů poskytuje pokuty
* Přesné operace s plovoucí desetinnou čárkou, včetně sčítání, odečítání, násobení, dělení a zaokrouhlování.
*/
aritha{
Výchozí přesnost dělení
soukromý statický finální int DEF_DIV_SCALE = 10;
Tuto třídu nelze instancovat
soukromý Arith(){
}
/**
* Poskytuje přesné sčítání.
* @param je přidán v1
* @param přidání v2
* @return Součet dvou parametrů
*/
Veřejné statické dvojité sčítání (double v1,double v2){
BigDecimal b1 = nový BigDecimal(Double.toString(v1));
BigDecimal b2 = nový BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Poskytuje přesné operace odčítání.
* @param se v1 odečítá
* @param v2 minus
* @return Rozdíl mezi těmito dvěma parametry
*/
Veřejný statický dvojitý sub(double v1,double v2){
BigDecimal b1 = nový BigDecimal(Double.toString(v1));
BigDecimal b2 = nový BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* Poskytuje přesné násobení.
* @param v1 se násobí
* @param násobič v2
* @return Součin obou parametrů
*/
Veřejný statický double mul(double v1,double v2){
BigDecimal b1 = nový BigDecimal(Double.toString(v1));
BigDecimal b2 = nový BigDecimal(Double.toString(v2));
return b1.násobení(b2).doubleValue();
}
/**
* Zajišťuje (relativně) přesné operace dělení, když dojde k nevyčerpatelnému dělení
* 10 desetinných míst a následující číslice jsou zaokrouhlené.
* @param v1 je dělený
* @param dělitel v2
* @return Podíl dvou parametrů
*/
Veřejný statický double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* Zajišťuje (relativně) přesné divizní operace. Když nastane nevyčerpatelná situace, je indikována parametrem škály
* Určte přesnost a čísla po ní budou zaokrouhlena.
* @param v1 je dělený
* @param dělitel v2
* @param stupnice ukazuje, že musí být přesná na několik desetinných míst.
* @return Podíl dvou parametrů
*/
Veřejný statický dvojitý div (dvojitý v1, dvojitý v2, int škála){
if(scale<0){
throw new IllegalArgumentException(
"Stupnice musí být kladné celé číslo nebo nula");
}
BigDecimal b1 = nový BigDecimal(Double.toString(v1));
BigDecimal b2 = nový BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Poskytuje přesné zaokrouhlování po desetinném místě.
* @param v vyžaduje zaokrouhlování čísel
* @param stupnice je vyhrazena za desetinnou čárkou
* @return Zaokrouhlené výsledky
*/
veřejné statické dvojité kolo (dvojité V, int škála){
if(scale<0){
throw new IllegalArgumentException(
"Stupnice musí být kladné celé číslo nebo nula");
}
BigDecimal b = nový BigDecimal(Double.toString(v));
BigDecimal jedna = nový BigDecimal ("1");
return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Předchozí:Nejlepší je nenastavovat řetězec s významem jako primární tóninouDalší:Rozdíly a vazby na JDK, JRE, JVM
|
