Java Language
BigInteger

Einführung

Syntax

• BigInteger Variablenname = neuer BigInteger ("12345678901234567890"); // eine dezimale Ganzzahl als Zeichenfolge
• BigInteger Variablenname = new BigInteger ("10101011010101001010100110001100111010110001111100001010101010010"), 2) // eine binäre Ganzzahl als Zeichenfolge
• BigInteger Variablenname = new BigInteger ("ab54a98ceb1f0800", 16) // eine hexadezimale Ganzzahl als Zeichenfolge
• BigInteger Variablenname = new BigInteger (64, new Random ()); // ein Pseudozufallszahlengenerator, der 64 Bits liefert, um eine Ganzzahl zu konstruieren
• BigInteger Variablenname = new BigInteger (neues Byte [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // signierte Zweierkomplementdarstellung einer Ganzzahl (Big Endian)
• BigInteger Variablenname = new BigInteger (1, neues Byte [] {- ​​85, 84, -87, -116, -21, 31, 10, -46}); // vorzeichenlose Zweierkomplementdarstellung einer positiven Ganzzahl (Big Endian)

Bemerkungen

BigInteger sum = BigInteger.ZERO;
for(int i = 1; i < 5000; i++) {
   sum.add(BigInteger.valueOf(i));  
}

sum = sum.add(BigInteger.valueOf(i));

Initialisierung

Die Klasse java.math.BigInteger stellt Operationsanaloga für alle primitiven Ganzzahloperatoren von Java und für alle relevanten Methoden aus java.lang.Math . Da das Paket java.math nicht automatisch verfügbar ist, müssen Sie möglicherweise java.math.BigInteger importieren, bevor Sie den einfachen Klassennamen verwenden können.

Um long oder int Werte in BigInteger zu konvertieren, verwenden Sie:

long longValue = Long.MAX_VALUE;
BigInteger valueFromLong = BigInteger.valueOf(longValue); 

oder für ganze Zahlen:

int intValue = Integer.MIN_VALUE; // negative
BigInteger valueFromInt = BigInteger.valueOf(intValue);

der das verbreitern intValue Ganzzahl zu langen, Vorzeichenbit - Erweiterung für negative Werte verwendet, so dass negative Werte negativ bleiben.

So konvertieren Sie einen numerischen String in BigInteger :

String decimalString = "-1";
BigInteger valueFromDecimalString = new BigInteger(decimalString);

Der folgende Konstruktor wird verwendet, um die String-Darstellung eines BigInteger in der angegebenen Basis in einen BigInteger .

String binaryString = "10";
int binaryRadix = 2;
BigInteger valueFromBinaryString = new BigInteger(binaryString , binaryRadix);

Java unterstützt auch die direkte Konvertierung von Bytes in eine Instanz von BigInteger . Derzeit können nur signierte und nicht signierte Big Endian-Codierungen verwendet werden:

byte[] bytes = new byte[] { (byte) 0x80 }; 
BigInteger valueFromBytes = new BigInteger(bytes);

Dadurch wird eine BigInteger Instanz mit dem Wert -128 generiert, da das erste Bit als Vorzeichenbit interpretiert wird.

byte[] unsignedBytes = new byte[] { (byte) 0x80 };
int sign = 1; // positive
BigInteger valueFromUnsignedBytes = new BigInteger(sign, unsignedBytes);

Dadurch wird eine BigInteger Instanz mit dem Wert 128 generiert, da die Bytes als vorzeichenlose Zahl interpretiert werden und das Vorzeichen explizit auf 1 (positive Zahl) gesetzt wird.

Es gibt vordefinierte Konstanten für allgemeine Werte:

• BigInteger.ZERO - Wert von "0".
• BigInteger.ONE - Wert von "1".
• BigInteger.TEN - Wert von "10".

Es gibt auch BigInteger.TWO (Wert von "2"), aber Sie können es nicht in Ihrem Code verwenden, da es private .

BigIntegers vergleichen

Sie können BigIntegers genauso vergleichen, wie Sie String oder andere Objekte in Java vergleichen.

Zum Beispiel:

BigInteger one = BigInteger.valueOf(1);
BigInteger two = BigInteger.valueOf(2);

if(one.equals(two)){
    System.out.println("Equal");
}
else{
    System.out.println("Not Equal");
}

Ausgabe:

Not Equal

Hinweis:

Verwenden Sie im Allgemeinen nicht den Operator == , um BigIntegers zu vergleichen

• == Operator: vergleicht Referenzen; ob sich zwei Werte auf dasselbe Objekt beziehen
• equals() -Methode: vergleicht den Inhalt von zwei BigIntegers.

Beispielsweise sollten BigIntegers nicht auf folgende Weise verglichen werden:

if (firstBigInteger == secondBigInteger) {
  // Only checks for reference equality, not content equality!
}

Dies kann zu einem unerwarteten Verhalten führen, da der Operator == nur die Referenzgleichheit überprüft. Wenn beide BigIntegers denselben Inhalt enthalten, sich aber nicht auf dasselbe Objekt beziehen, schlägt dies fehl. Vergleichen Sie stattdessen BigIntegers mithilfe der Methoden equals (siehe oben).

Sie können Ihren BigInteger mit konstanten Werten wie 0,1,10 vergleichen.

zum Beispiel:

BigInteger reallyBig = BigInteger.valueOf(1);
if(BigInteger.ONE.equals(reallyBig)){
    //code when they are equal.
}    

Sie können auch zwei BigIntegers mit der Methode compareTo() wie folgt vergleichen: compareTo() liefert 3 Werte.

• 0: Wenn beide gleich sind .
• 1: Wenn der erste Wert größer als der zweite ist (der in Klammern).
• -1: Wenn erster als weniger ist .

BigInteger reallyBig = BigInteger.valueOf(10);
BigInteger reallyBig1 = BigInteger.valueOf(100);

if(reallyBig.compareTo(reallyBig1) == 0){
    //code when both are equal.
}
else if(reallyBig.compareTo(reallyBig1) == 1){
    //code when reallyBig is greater than reallyBig1.
}
else if(reallyBig.compareTo(reallyBig1) == -1){
    //code when reallyBig is less than reallyBig1.
}

BigInteger-Beispiele für mathematische Operationen

BigInteger befindet sich in einem unveränderlichen Objekt. Sie müssen also die Ergebnisse aller mathematischen Operationen einer neuen BigInteger-Instanz zuordnen.

Zugabe: 10 + 10 = 20

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("10");

BigInteger sum = value1.add(value2);
System.out.println(sum);

Ausgabe: 20

Substraktion: 10 - 9 = 1

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("9");

BigInteger sub = value1.subtract(value2);
System.out.println(sub);

Ausgabe: 1

Division: 10/5 = 2

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger div = value1.divide(value2);
System.out.println(div);

Ausgabe: 2

Division: 17/4 = 4

BigInteger value1 = new BigInteger("17");
BigInteger value2 = new BigInteger("4");

BigInteger div = value1.divide(value2);
System.out.println(div);

Ausgabe: 4

Multiplikation: 10 * 5 = 50

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger mul = value1.multiply(value2);
System.out.println(mul);

Ausgabe: 50

Leistung: 10 ^ 3 = 1000

BigInteger value1 = new BigInteger("10");
BigInteger power = value1.pow(3);
System.out.println(power);

Ausgabe: 1000

Rest: 10% 6 = 4

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("6");

BigInteger power = value1.remainder(value2);
System.out.println(power);

Ausgabe: 4

GCD: Der größte gemeinsame Teiler (GCD) für 12 und 18 ist 6 .

BigInteger value1 = new BigInteger("12");
BigInteger value2 = new BigInteger("18");

System.out.println(value1.gcd(value2));

Ausgabe: 6

Maximal zwei BigIntegers:

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.max(value2));

Ausgabe: 11

Minimum von zwei BigIntegers:

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.min(value2));

Ausgabe: 10

Binäre Logikoperationen auf BigInteger

BigInteger unterstützt die binären Verknüpfungen, die auch für Number Typen verfügbar sind. Wie bei allen Operationen werden sie durch Aufrufen einer Methode implementiert.

Binär oder:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.or(val2);

Ausgabe: 11 (entspricht 10 | 9 )

Binär und:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.and(val2);

Ausgabe: 8 (entspricht 10 & 9 )

Binäres Xor:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.xor(val2);

Ausgabe: 3 (entspricht 10 ^ 9 )

Rechte Shifttaste:

BigInteger val1 = new BigInteger("10");

val1.shiftRight(1);   // the argument be an Integer    

Ausgabe: 5 (entspricht 10 >> 1 )

Linksverschiebung:

BigInteger val1 = new BigInteger("10");

val1.shiftLeft(1);   // here parameter should be Integer    

Ausgabe: 20 (entspricht 10 << 1 )

Binäre Inversion (nicht):

BigInteger val1 = new BigInteger("10");

val1.not();

Ausgabe: 5

NAND (And-Not): *

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.andNot(val2);

Ausgabe: 7

Zufällige BigIntegers generieren

Die BigInteger Klasse verfügt über einen Konstruktor, der zum Generieren von zufälligen BigIntegers , wenn eine Instanz von java.util.Random und ein int angegeben wird, die angibt, wie viele Bits BigInteger soll. Die Verwendung ist recht einfach - wenn Sie den Konstruktor BigInteger(int, Random) wie folgt aufrufen:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

Dann erhalten Sie einen BigInteger dessen Wert zwischen 0 (einschließlich) und 2 ^bitCount (exklusiv) liegt.

Dies bedeutet auch, dass der new BigInteger(2147483647, sourceOfRandomness) alle positiven BigInteger new BigInteger(2147483647, sourceOfRandomness) kann, wenn er genügend Zeit hat.

Was wird der sourceOfRandomness sein, liegt bei Ihnen. Zum Beispiel ist ein new Random() in den meisten Fällen gut genug:

new BigInteger(32, new Random());

Wenn Sie bereit sind, Geschwindigkeit für Zufallszahlen höherer Qualität aufzugeben, können Sie stattdessen ein new SecureRandom () verwenden:

import java.security.SecureRandom;

// somewhere in the code...
new BigInteger(32, new SecureRandom());

Sie können sogar einen Algorithmus mit einer anonymen Klasse direkt implementieren! Beachten Sie, dass Sie Ihren eigenen RNG - Algorithmus Ausrollen werden Sie mit geringer Qualität Zufälligkeit am Ende, also immer sicher sein , einen Algorithmus zu verwenden , die anständig erwiesen ist , wenn Sie die resultierende wollen BigInteger (n) berechenbar sein.

new BigInteger(32, new Random() {
    int seed = 0;

    @Override
    protected int next(int bits) {
        seed = ((22695477 * seed) + 1) & 2147483647; // Values shamelessly stolen from Wikipedia
        return seed;
    }
});