BigInteger und BigDecimal

In Java besteht eine Anwendung aus Klassen und Klassen bestehen aus Methoden und Variablen. Variablen wiederum werden in Primitiv- und Referenzvariablen unterteilt. In Java gibt es 8 Arten von Variablen, die mit Ausnahme von booleanund charin die folgenden Typen unterteilt sind:

• ganze Zahlen: byte, short, intund long;
• Gleitkommazahlen (auch reelle Zahlen genannt): floatund double.

Innerhalb dieser kleinen Gruppen bestehen Unterschiede nur im Bereich der Werte, die enthalten sein können (und dementsprechend variiert der von einer solchen Variablen eingenommene Raum). Der größte der Ganzzahltypen ist long, mit einem Bereich von -9223372036854775808 bis 9223372036854775807. Von den Gleitkommazahlen ist , doublemit einem Bereich von 1,7e-308 bis 1,7e+308. Weitere Informationen zu reellen Zahlen finden Sie in diesem Artikel . Was aber, wenn wir Zahlen speichern müssen, die größer als der akzeptable Bereich sind? In diesem Fall benötigen wir BigIntegerund BigDecimal.

BigInteger in Java

Die Java-Klasse BigIntegerwird als Analogon zu ganzzahligen Werten beliebiger Länge verwendet, für die es nicht die 64-Bit-Beschränkung von long gibt. Darüber hinaus ist es ein Nachkomme der Klasse , Numberwie Standard-Wrapper für numerische einfache Typen – Integer, Long, usw. – und verfügt daher über Implementierungen von Methoden, die zu einfachen Typen führen: ByteDouble

BigInteger value = new BigInteger("32145");

int intValue = value.intValue();//32145

long longValue = value.longValue();//32145

double doubleValue = value.doubleValue();//32145.0

Wir sehen sofort die Erstellung eines solchen Objekts, BigIntegerbei dem unser Wert an den Konstruktor übergeben wird, jedoch im String-Format. Es ist erwähnenswert, dass er mehr als einen Designer hat, allerdings für alle Gelegenheiten. Wenn primitive Typen nicht die gesamte Datenmenge von aufnehmen können BigInteger, werden die Daten auf den Bereich dieses primitiven Typs gekürzt. Gleichzeitig gibt es jedoch Analoga dieser Methoden ( intValueExact()usw. ), mit dem einzigen Unterschied, dass eine ArithmeticExceptionlongValueExact() ausgelöst wird, wenn der einfache Typ, in den die Konvertierung erfolgt, den Datenbereich nicht unterstützt .

BigInteger-Konstanten

Für den internen Gebrauch verfügt die Klasse über Konstanten:

BigInteger.ZERO
BigInteger.ONE
BigInteger.TEN

Dies sind konstante Objekte mit den BigIntegerWerten , 0und 1.10

BigInteger-Methoden

Eines der Hauptmerkmale dieser Klasse besteht darin, dass sie voller Methoden ist, die Standardarithmetikoperationen in Java implementieren. Zum Beispiel:

• Summationsoperationen:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.add(secondValue);//73461

• Multiplikationsoperationen:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.multiply(secondValue);//1347530670

• Operationen zur Ermittlung des Restes bei der Division einer Zahl durch eine andere:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.remainder(secondValue);//2529

• Ermitteln des absoluten Werts einer Zahl (d. h. Modulo, ohne Vorzeichen):

  BigInteger firstValue = new BigInteger("-37995");
  BigInteger resultValue =  firstValue.abs();//37995

Es gibt auch Methoden für komplexere (spezifische) Operationen:

• Operationen mit Mod -Berechnung :

  BigInteger firstValue = new BigInteger("-34");
  BigInteger secondValue = new BigInteger("5");
  BigInteger resultValue = firstValue.mod(secondValue); //1

Es gibt verschiedene Variationen dieser Funktion:

• Erhalten einer Zufallszahl und Angeben der Anzahl der Bits, die der resultierende Wert verwenden wird:

  BigInteger firstValue = BigInteger.probablePrime(8, new Random());//211
  BigInteger secondValue = BigInteger.probablePrime(16, new Random());//42571

• Bitweise Schiebeoperationen (dies >> n)

  Nach links verschieben:

  BigInteger firstValue = new BigInteger("5");
  BigInteger firstResultValue = firstValue.shiftLeft(3);//40

  Nach rechts verschieben:

  BigInteger secondValue = new BigInteger("34");
  BigInteger secondResultValue = secondValue.shiftRight(2); //8

Natürlich ist es besser, sich die vollständige Liste der Methoden in der Dokumentation anzusehen .

BigDecimal in Java

Wenn wir eine reelle Zahl beliebiger Länge benötigen, wird die Java-Klasse verwendet BigDecimal. In der Regel wird es für die Arbeit mit Finanzen anstelle von verwendet double, da es mehr Anpassungsmöglichkeiten bietet. Like und BigIntegerist BigDecimalein Nachkomme einer Klasse Numberund verfügt über Methoden, die den Wert eines Objekts als einen bestimmten primitiven Typ zurückgeben:

BigDecimal value = new BigDecimal(35563.3);

long longValue = value.longValue();//35563

double doubleValue = value.doubleValue();//35563.3

Wie wir beim Reduzieren auf sehen können long, bleibt nur der ganzzahlige Teil übrig und die Nachkommastellen werden verworfen.

BigDecimal-Konstruktoren

Wir werden uns die Konstruktoren genauer ansehen BigDecimal, da die Klasse eine viel größere Auswahl davon hat. Es gibt Konstruktoren, mit denen Sie den Wert eines Objekts auf unterschiedliche Weise festlegen können (durch Übergabe von int, long, doubleund Stringsogar BigInteger), und es gibt solche, die dies ermöglichen. Legen Sie die Einstellungen des erstellten Objekts fest (Rundungsmethoden, Anzahl der Dezimalstellen):

BigDecimal firstValue = new BigDecimal("455656.545");//455656.545

Hier ist alles klar, wir stellen direkt den Wert und die Anzahl der Dezimalstellen ein, die wir sehen möchten.

BigDecimal secondValue = new BigDecimal(3445.54);//3445.5399999999999636202119290828704833984375

Die Ergebnisse dieses Konstruktors können ziemlich unvorhersehbar sein, da wir Double angeben, was seiner Natur nach ein sehr mehrdeutiger Typ ist. Daher wird generell die Verwendung in einem Konstruktor empfohlen String.

BigDecimal thirdValue = new BigDecimal(3445.554645675444, MathContext.DECIMAL32);//3445.555

Wir setzen double, aber gleichzeitig setzen wir auch einen Parameter, der die Rundungsregel beschreibt (die die Anzahl der Nachkommastellen und den Algorithmus zum Runden enthält).

char[] arr = new String("455656.545").toCharArray();

BigDecimal fourthValue = new BigDecimal(arr, 2, 6);//5656.5

Wir legen ein Array von Zeichen fest, von welchem ​​Element wir die Werte für das Objekt übernehmen und wie viele dieser Elemente wir übernehmen.

BigDecimal fifthValue = new BigDecimal(new BigInteger("44554"), 3);//44.554

Wir nehmen ein bereits vorhandenes Objekt BigIntegerund legen die Anzahl der Dezimalstellen fest.

BigDecimal-Methoden

Die Klasse BigDecimalenthält auch Methoden für verschiedene arithmetische Operationen, jedoch BigIntegerkeine Methoden für die Arbeit mit Bits, wie z. Das Hauptmerkmal ist jedoch BigDecimaldie Flexibilität beim Arbeiten mit Gleitkommazahlen. Schauen wir uns einige Techniken an, die uns die Möglichkeit geben, die reellen Zahlen zu beherrschen:

• Wir erhalten die Präzision (Anzahl der Zahlen):

  BigDecimal value = new BigDecimal("454334.34334");
  int result = value.precision();//11

• Legen Sie die Anzahl der Dezimalstellen und die Rundungsregel fest:

  BigDecimal firstValue = new BigDecimal(3445.544445);
  
  BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_CEILING);//3445.545

  Im Folgenden werden wir uns die Konstanten zum Festlegen von Rundungsregeln genauer ansehen.

• dividieren Sie BigDecimaldurch ein anderes BigDecimalund geben Sie dabei die erforderliche Anzahl an Dezimalstellen und die Rundungsregel an:

  BigDecimal firstValue = new BigDecimal("455656.545");
  
  BigDecimal secondValue = new BigDecimal(3445.544445);
  
  BigDecimal result = firstValue.divide(secondValue, 2,RoundingMode.DOWN);//132.24

• Verschieben eines Dezimalpunkts um eine bestimmte Anzahl von Stellen nach rechts/links:

  BigDecimal value = new BigDecimal("455656.545");
  BigDecimal firstResult = value.movePointRight (2);//45565654.5
  BigDecimal secondResult = value.movePointLeft (2);//4556.56545

• Nachgestellte Nullen kürzen:

  BigDecimal value = new BigDecimal("45056.5000");
  BigDecimal result = value.stripTrailingZeros();//45056.5

  Wenn wir im Realteil nur Nullen haben und es auch im ganzen Teil Nullen gibt (oder wir überhaupt keine Nachkommastellen haben), dann:

  BigDecimal value = new BigDecimal("450000.000");
  BigDecimal result = value.stripTrailingZeros();//4.5E+5

BigDecimal-Rundungsregeln

Um Rundungsregeln festzulegen, BigDecimalkönnen wir im Inneren spezielle Konstanten sehen, die Rundungsalgorithmen beschreiben: ROUND_UP- Runden von Null, Runden in Richtung des Realteils:

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_UP );//2.6
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_UP );//-2.5

ROUND_DOWN— Rundung auf Null, d. h. Kürzung des Realteils:

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_DOWN  );//2.5
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_DOWN  );//-2.6

ROUND_CEILING— Aufrunden auf positive Unendlichkeit. Das heißt, wenn unsere Zahl positiv ist, dann -> ROUND_UP, wenn negativ, dann ->ROUND_DOWN

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_CEILING);//2.6
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_CEILING);//-2.5

ROUND_FLOOR- Aufrunden auf negative Unendlichkeit, das heißt, wenn unsere Zahl positiv ist, dann -> ROUND_DOWN, wenn negativ, dann ->ROUND_UP

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_FLOOR);//2.5
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_FLOOR);//-2.6

Für den betrachteten Wert betrachten wir diese nächste Zahl mit einer abgeschnittenen Dezimalstelle als nächsten Nachbarn der betrachteten Zahl. Beispielsweise liegt 2,43 näher bei 2,4 als 2,5, aber 2,48 liegt eher bei 2,5. ROUND_HALF_DOWN— Rundung auf den „nächsten Nachbarn“. Wenn beide Nachbarn den gleichen Abstand von einem bestimmten Wert haben, wird auf Null gerundet. Äquidistant ist beispielsweise, wenn die zu rundende Zahl 5 ist und der Abstand zwischen 0 und 10 gleich ist):

BigDecimal firstValue = new BigDecimal("2.58");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_HALF_DOWN );//2.6
BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_HALF_DOWN );//2.5

ROUND_HALF_UP— Modus zum Runden auf den „nächsten Nachbarn“. Wenn beide Nachbarn den gleichen Abstand haben, wird aufgerundet (dies ist das gleiche Runden, das uns in der Schule beigebracht wurde):

BigDecimal firstValue = new BigDecimal("2.53");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_HALF_UP  );//2.5
BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_HALF_UP  );//2.6

ROUND_HALF_EVEN— Runden auf den „nächsten Nachbarn“, wenn beide Nachbarn nicht den gleichen Abstand haben. Wenn in diesem Fall vor der zu rundenden Zahl eine ungerade Zahl steht, wird sie aufgerundet, und wenn sie gerade ist, wird sie abgerundet:

BigDecimal firstValue = new BigDecimal("2222.2225");
BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_HALF_EVEN );//2222.222

Wir erhalten dieses Ergebnis, weil beim Runden 5 die vorherige Zahl 2 betrachtet und, da sie gerade ist, abgerundet wird. Aber falls:

BigDecimal firstValue = new BigDecimal("2222.22255");
BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_HALF_EVEN );//2222.223

Diese Rundung erhöht sich, da die letzten 5 den vorherigen Wert betrachten und eine ungerade Zahl sehen. Dadurch wird die Zahl auf 6 aufgerundet, danach wird auch die nächste 6 gerundet. Die Sechs schaut aber nicht mehr auf die Zahl links, da die Zahl deutlich weiter oben liegt, und dadurch wird die letzte 2 um 1 erhöht. ROUND_UNNECESSARY- Wird verwendet, um zu überprüfen, ob die Zahl nicht gerundet werden muss. Das heißt, wir prüfen, ob die Zahl die erforderliche Anzahl an Dezimalstellen hat:

BigDecimal firstValue = new BigDecimal("2.55");
BigDecimal firstResult =  firstValue.setScale(2, BigDecimal.ROUND_UNNECESSARY);//2.55

Hier ist alles in Ordnung, der Wert ist zweistellig und wir prüfen, dass es nur zwei Nachkommastellen gibt. Aber falls:

BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_UNNECESSARY);

Dann erhalten wir - ArithmeticException, da der getestete Wert die angegebene Anzahl von Dezimalstellen überschreitet. Wenn wir aber zwei Dezimalstellen prüfen, tatsächlich aber eine da ist, dann wird die Ausnahme nicht geworfen und die fehlenden Ziffern werden einfach durch Nullen ergänzt:

BigDecimal thirdValue = new BigDecimal("2.5");
BigDecimal thirdResult = thirdValue.setScale(3, BigDecimal.ROUND_UNNECESSARY   );//2.500

Ich möchte auch darauf hinweisen, dass y Konstanten hat, die den Konstanten , und BigDecimalähneln . Hier ist ein Link zur Dokumentation . Und schließlich: Wie Sie wahrscheinlich bemerkt haben, ändern wir bei Operationen mit Objekten und nicht die alten, sondern erhalten immer neue. Dies sagt uns, dass sie , also nach ihrer Entstehung unveränderlich sind, genau wie . Mit anderen Worten: Alle ihre Methoden können den internen Zustand des Objekts nicht ändern; sie können höchstens ein neues Objekt mit den Parametern zurückgeben, die von der von uns verwendeten Funktion angegeben werden. BigInteger ZEROONETENBigIntegerBigDecimalimmutableString