boolean
und char
in die folgenden Typen unterteilt sind:
- ganze Zahlen:
byte
,short
,int
undlong
; - Gleitkommazahlen (auch reelle Zahlen genannt):
float
unddouble
.
long
, mit einem Bereich von -9223372036854775808 bis 9223372036854775807. Von den Gleitkommazahlen ist , double
mit 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 BigInteger
und BigDecimal
.
BigInteger in Java
Die Java-KlasseBigInteger
wird 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 , Number
wie Standard-Wrapper für numerische einfache Typen – Integer
, Long
, usw. – und verfügt daher über Implementierungen von Methoden, die zu einfachen Typen führen: Byte
Double
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, BigInteger
bei 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 BigInteger
Werten , 0
und 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
-
Operationen mit Mod -Berechnung :
BigInteger firstValue = new BigInteger("-34"); BigInteger secondValue = new BigInteger("5"); BigInteger resultValue = firstValue.mod(secondValue); //1
-
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
BigDecimal in Java
Wenn wir eine reelle Zahl beliebiger Länge benötigen, wird die Java-Klasse verwendetBigDecimal
. In der Regel wird es für die Arbeit mit Finanzen anstelle von verwendet double
, da es mehr Anpassungsmöglichkeiten bietet. Like und BigInteger
ist BigDecimal
ein Nachkomme einer Klasse Number
und 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 ansehenBigDecimal
, 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
, double
und String
sogar 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 BigInteger
und legen die Anzahl der Dezimalstellen fest.
BigDecimal-Methoden
Die KlasseBigDecimal
enthält auch Methoden für verschiedene arithmetische Operationen, jedoch BigInteger
keine Methoden für die Arbeit mit Bits, wie z. Das Hauptmerkmal ist jedoch BigDecimal
die 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
BigDecimal
durch ein anderesBigDecimal
und 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,BigDecimal
kö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 ZERO
ONE
TEN
BigInteger
BigDecimal
immutable
String
GO TO FULL VERSION