|
|
Veröffentlicht am 07.04.2015 14:53:05
|
|
|
Operationsklassen für große Zahlen werden in Java bereitgestellt, nämlich die java.math.BinInteger-Klasse und die java.math.BigDecimal-Klasse. Diese beiden Klassen werden für hochpräzise Berechnungen verwendet, wobei die BigInteger-Klasse die Verarbeitungsklasse für große ganze Zahlen und die BigDecimal-Klasse die Verarbeitungsklasse für große und kleine Zahlen darstellt. Im Folgenden stellen wir die BigDecimal-Klasse vor:
Die Implementierung von BigDecimal nutzt BigInteger, außer dass BigDecimal das Konzept der Dezimalzahlen hinzufügt. Allgemeine Gleit- und Doppeltypdaten können nur für wissenschaftliche oder technische Berechnungen verwendet werden, da im kommerziellen Rechnen die erforderliche numerische Genauigkeit relativ hoch ist, daher wird die Klasse java.math.BigDecimal verwendet, die jede Genauigkeit von Fixpunkten unterstützt und zur genauen Berechnung von Währungswerten verwendet werden kann. Im Folgenden stellen wir ihre Verwendung kurz mit Beispielen vor.
java.math.BigDecimal
Heute habe ich ein Programm über binäre und dezimale Umrechnung mit Bezug auf das Lehrbuch geschrieben, und der Programmalgorithmus ist nicht schwierig, aber nach dem Schreiben stellte ich fest, dass es egal ob 2 bis 10 oder 10 zu 2 ist, keine gute Umrechnung für Zahlen größer als 2,1 Milliarden ist, also mehr als der ganzzahlige Bereich. wird 0 werden.
Nachschlagewerke haben festgestellt, dass die Verwendung von BigInteger dieses Problem löst.
Also habe ich das JDK nachgeschlagen, es dann mehrmals getestet und schließlich erfolgreich geschrieben!
Die Nutzungserfahrung ist wie folgt:
1. BigInteger gehört zu java.math.BigInteger, importiere diese Klasse also vor jeder Benutzung. Gelegentlich habe ich vergessen, am Anfang zu importieren, sodass der Prompt im konstanten Prompt nicht gefunden werden kann.
2. Es gibt viele Baumethoden, aber heute werden sie gelegentlich verwendet:
BigInteger (String val)
Konvertiere die dezimale String-Darstellung von BigInteger in BigInteger.
BigInteger(String-Val, int radix)
Wandelt die String-Darstellung der BigInteger für die angegebene Kardinalität in die BigInteger um.
Um 2 des Int Typs in BigInteger-Typ umzuwandeln, schreibe BigInteger two=new BigInteger("2"); Anmerkung 2: Doppelte Anführungszeichen dürfen nicht weggelassen werden
3. Die BigInteger-Klasse simuliert alle mathematischen Operationen vom Int-Typ, wie add()=="+", divide()="-" usw., aber beachten Sie, dass ihr Inhalt nicht direkt für mathematische Operationen bei der Durchführung mathematischer Operationen verwendet werden kann und ihre internen Methoden verwendet werden muss. Und sein Operand muss ebenfalls vom Typ BigInteger sein.
Zum Beispiel: two.add(2) ist eine falsche Operation, weil 2 kein BigInteger-Typ wird.
4. Wenn Sie die Berechnungsergebnisse ausgeben möchten, sollten Sie die .toString-Methode verwenden, um sie in eine Dezimalzeichenkette umzuwandeln, die wie folgt detailliert ist:
String toString()
Gibt die dezimale String-Darstellung dieses BigInteger zurück.
Ausgabemethode: System.out.print(two.toString());
5. Erklären Sie die drei verwendeten Funktionen.
BigInteger Rest(BigInteger val)
Gibt eine BigInteger mit dem Wert von (diesem % Val) zurück.
BigInteger-Negate()
BigInteger gibt einen Wert von (-this) zurück.
int compareTo(BigInteger val)
Vergleichen Sie dieses BigInteger mit dem angegebenen BigInteger.
Der Rest wird verwendet, um den Rest zu finden.
Negate verwandelt den Operanden in das Gegenteil.
Compare wird im Detail wie folgt erklärt:
vergleichenZu
public int compareTo(BigInteger val)
Vergleichen Sie dieses BigInteger mit dem angegebenen BigInteger. Diese Methode wird für jeden der sechs boolesche Vergleichsoperatoren bevorzugt (<, ==, >, >=, !=, <=). Die vorgeschlagene Aussage zur Durchführung dieser Vergleiche lautet: (x.compareTo(y) <op> 0), wobei <op> einer der sechs Vergleichsoperatoren ist.
Spezifizator:
<BigInteger> Schnittstelle Vergleichbar
Parameter:
val – Das BigInteger, das dieses BigInteger damit vergleicht.
Zurück:
Titel Implementierung präziser Berechnungen von Gleitkommazahlen in Java AYellow (Original) Modifikation
Schlüsselwörter: Java Gleitkomma-Präzisionsberechnung
Frage gestellt:
Was würden wir sehen, wenn wir das folgende Programm kompilieren und ausführen würden?
öffentliche Klasse 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);
}
};
Du hast richtig gelesen! Das Ergebnis ist:
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Einfache Float- und Double-Types in Java können nicht betrieben werden. Dieses Problem tritt nicht nur in Java auf, sondern auch in vielen anderen Programmiersprachen. In den meisten Fällen sind die Berechnungen genau, aber du kannst es noch ein paar Mal versuchen (du kannst eine Schleife machen), um Fehler wie den oben genannten zu überprüfen. Jetzt verstehe ich endlich, warum es einen BCD-Code gibt.
Dieses Problem ist ziemlich ernst: Wenn Sie 9,99999999999999999999999 Yuan haben, denkt Ihr Computer nicht, dass Sie 10 Yuan an Waren kaufen können.
Einige Programmiersprachen bieten spezielle Währungstypen an, um diese Situation zu bewältigen, aber Java nicht. Mal sehen, wie wir das beheben können.
Rundung
Unsere erste Reaktion ist, Runden zu machen. Die Rundmethode im Mathematikkurs kann nicht so eingestellt werden, dass sie ein paar Dezimalstellen beibehält, wir können nur dies tun (zwei Stellen beibehalten):
öffentliche Doppelrunde(Doppelwert){
return Math.round(value*100)/100.0;
}
Leider funktioniert der obige Code nicht, das Eingeben von 4.015 an diese Methode ergibt 4.01 statt 4.02, wie oben gesehen
4,015*100=401,49999999999999994
Daher können wir, wenn wir eine genaue Rundung durchführen wollen, keine einfachen Typen verwenden, um irgendwelche Operationen durchzuführen
java.text.DecimalFormat löst dieses Problem auch nicht:
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
Die Ausgabe beträgt 4,02
BigDecimal
Dieses Prinzip wird auch im Buch "Effective Java" erwähnt: Float und Double können nur für wissenschaftliche oder technische Berechnungen verwendet werden, und im Business Computing müssen wir java.math.BigDecimal verwenden. Es gibt 4 Möglichkeiten, BigDecimal zu bauen, uns sind die beiden egal, die mit BigInteger erstellt werden, daher gibt es zwei weitere, nämlich:
BigDecimal (Doppelval)
Übersetzt ein Double in ein BigDecimal.
BigDecimal (String-Val)
Übersetzt die String-Repre-Sentation eines BigDecimal in ein BigDecimal.
Die API wird kurz beschrieben und ist in der Regel einfacher zu bedienen. Wir könnten es verwenden, ohne darüber nachzudenken – was wird das Problem sein? Als etwas schiefging, stellte ich fest, dass es einen solchen Absatz in der detaillierten Beschreibung gab, welche der oben genannten Methoden ausreichend war:
Hinweis: Die Ergebnisse dieses Konstruktors können etwas unvorhersehbar sein. Man könnte annehmen, dass das neue BigDecimal(.1) genau gleich 0,1 ist, aber tatsächlich ist es gleich 0,1000000000000000055511151231257827021181583404541015625. Dies liegt daran, dass 0,1 nicht exakt als Doppelgänger dargestellt werden kann (oder übrigens als binärer Bruchteil beliebiger endlicher Länge). Daher ist der lange Wert, der an den Konstruktor weitergegeben wird, nicht exakt gleich 0,1, unabhängig von den Erscheinungen.
Der (String-)Konstruktor hingegen ist vollkommen vorhersehbar: Der neue BigDecimal(".1") entspricht genau .1, wie zu erwarten. Daher wird allgemein empfohlen, den (String-)Konstruktor diesem vorzuziehen.
Es stellt sich heraus, dass wir, wenn wir genau rechnen müssen, String verwenden müssen, um BigDecimal zu erzeugen! Das Beispiel im Buch Effective Java verwendet String, um BigDecimal zu erstellen, aber das Buch betont dies nicht, was ein kleiner Fehler sein könnte.
Lösung
Jetzt, da wir dieses Problem gelöst haben, besteht das Prinzip darin, BigDecimal zu verwenden und sicherzustellen, dass String verwendet wird.
Aber stellen Sie sich vor, wenn wir eine Additionsoperation durchführen wollen, müssen wir zunächst zwei Gleitkommazahlen in eine String umwandeln, dann eine BigDecimal erstellen, die Addiermethode für eine davon aufrufen, die andere als Argument weitergeben und dann das Ergebnis der Operation (BigDecimal) in eine Gleitkommazahl umwandeln. Kannst du einen so mühsamen Prozess ertragen? Im Folgenden stellen wir eine Werkzeugklasse Arith zur Verfügung, um den Vorgang zu vereinfachen. Sie bietet folgende statische Methoden an, darunter Addition, Subtraktion, Multiplikation und Division sowie Rundung:
Öffentliche statische doppelte ADD (doppelte v1, doppelte v2)
Öffentliche statische Doppelsub (Doppel V1, Doppel V2)
Öffentliche statische Doppelmul (Doppel V1, Doppel V2)
Öffentliche statische Doppeldivision (Doppel V1, Doppel V2)
Öffentliche statische Doppeldivision (Doppel V1, Doppel V2, Int Skala)
Öffentliche statische Doppelrunde (doppelte V, Int Skala)
Anhang
Quelldatei Arith.java:
import java.math.BigDecimal;
/**
* Da die einfachen Typen von Java keine Gleitkommaoperationen genau ausführen können, bietet diese Werkzeugklasse Feinheiten
* Exakte Gleitkommaoperationen, einschließlich Addition, Subtraktion, Multiplikation, Division und Rundung.
*/
öffentliche Klasse Arith{
Standardgenauigkeit der Divisionsoperationen
Private Static Final Int DEF_DIV_SCALE = 10;
Diese Klasse kann nicht instanziiert werden
private Arith(){
}
/**
* Bietet präzise Additionsoperationen.
* @param v1 wird hinzugefügt
* @param v2-Addition
* @return Die Summe der beiden Parameter
*/
Public Static Double Add(double v1,double v2){
BigDecimal b1 = neuer BigDecimal(Double.toString(v1));
BigDecimal b2 = neuer BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Bietet präzise Subtraktionsoperationen.
* @param v1 wird subtrahiert
* @param v2 minus
* @return Der Unterschied zwischen den beiden Parametern
*/
Public Static Double Sub(double v1,double v2){
BigDecimal b1 = neuer BigDecimal(Double.toString(v1));
BigDecimal b2 = neuer BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* Liefert präzise Multiplikationsoperationen.
* @param v1 wird multipliziert
* @param v2-Multiplikator
* @return Das Produkt der beiden Parameter
*/
Public Static Double MUL(Double v1,double v2){
BigDecimal b1 = neuer BigDecimal(Double.toString(v1));
BigDecimal b2 = neuer BigDecimal(Double.toString(v2));
return b1.multipliply(b2).doubleValue();
}
/**
* Liefert (relativ) genaue Divisionsoperationen, wenn unerschöpfliche Division auftritt
* 10 Dezimalstellen und die folgenden Ziffern werden gerundet.
* @param v1 wird geteilt
* @param v2 Teiler
* @return Der Quotient der beiden Parameter
*/
Public Static Double Div(double v1,double v2){
Return Div(v1,v2,DEF_DIV_SCALE);
}
/**
* Bietet (relativ) genaue Divisionsoperationen. Wenn eine unerschöpfliche Situation eintritt, wird dies durch den Skalenparameter angezeigt
* Bestimmen Sie die Genauigkeit, und die Zahlen danach werden gerundet.
* @param v1 wird geteilt
* @param v2 Teiler
* @param Skala zeigt an, dass sie auf einige Dezimalstellen genau sein muss.
* @return Der Quotient der beiden Parameter
*/
Public Static Double Div(double v1,double v2,int scale){
if(scale<0){
Neue IllegalArgumentException(
"Die Skala muss eine positive ganze Zahl oder Null sein");
}
BigDecimal b1 = neuer BigDecimal(Double.toString(v1));
BigDecimal b2 = neuer BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Liefert präzise Dezimalrundung.
* @param v erfordert Rundungszahlen
* @param Tonleiter ist nach dem Dezimalpunkt reserviert
* @return Abgerundete Ergebnisse
*/
öffentliche statische Doppelrunde (doppelte V,Int-Skala){
if(scale<0){
Neue IllegalArgumentException(
"Die Skala muss eine positive ganze Zahl oder Null sein");
}
BigDecimal b = neuer BigDecimal(Double.toString(v));
BigDecimal eins = neuer BigDecimal ("1");
return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Vorhergehend:Es ist am besten, eine Zeichenkette mit Bedeutung nicht als Primärton zu setzenNächster:JDK, JRE, JVM Unterschiede und Verbindungen
|
