Java Language
BigInteger

Invoering

Syntaxis

• BigInteger variable_name = new BigInteger ("12345678901234567890"); // een decimaal geheel getal als een tekenreeks
• BigInteger variable_name = new BigInteger ("1010101101010100101010011000110011101011000111110000101011010010", 2) // een binair geheel getal als een tekenreeks
• BigInteger variable_name = new BigInteger ("ab54a98ceb1f0800", 16) // een hexadecimaal geheel getal als een tekenreeks
• BigInteger variable_name = new BigInteger (64, new Random ()); // een pseudorandom-nummergenerator die 64 bits levert om een geheel getal te construeren
• BigInteger variable_name = new BigInteger (nieuwe byte [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // ondertekende twee's complementrepresentatie van een geheel getal (big endian)
• BigInteger variable_name = new BigInteger (1, new byte [] {- 85, 84, -87, -116, -21, 31, 10, -46}); // niet-ondertekende twee-complementrepresentatie van een positief geheel getal (big endian)

Opmerkingen

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

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

initialisatie

De klasse java.math.BigInteger biedt bewerkingsanalogen aan alle primitieve integer-operators van Java en voor alle relevante methoden van java.lang.Math . Omdat het pakket java.math niet automatisch beschikbaar wordt gesteld, moet u mogelijk java.math.BigInteger importeren voordat u de eenvoudige klassenaam kunt gebruiken.

Om long of int waarden naar BigInteger te BigInteger :

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

of, voor gehele getallen:

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

die zal verbreden intValue integer lang gebruik tekenbit extensie voor negatieve waarden, waardoor negatieve waarden negatief blijft.

Gebruik een numerieke String naar BigInteger :

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

De volgende constructor wordt gebruikt om de String-weergave van een BigInteger in de opgegeven radix te vertalen in een BigInteger .

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

Java ondersteunt ook directe conversie van bytes naar een instantie van BigInteger . Momenteel mogen alleen ondertekende en niet-ondertekende big endian-codering worden gebruikt:

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

Dit genereert een BigInteger instantie met waarde -128 wanneer het eerste bit wordt geïnterpreteerd als het tekenbit.

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

Dit genereert een BigInteger instantie met waarde 128, omdat de bytes worden geïnterpreteerd als niet-ondertekend nummer en het teken expliciet is ingesteld op 1, een positief getal.

Er zijn vooraf gedefinieerde constanten voor algemene waarden:

• BigInteger.ZERO - waarde van "0".
• BigInteger.ONE - waarde van "1".
• BigInteger.TEN - waarde van "10".

Er is ook BigInteger.TWO (waarde van "2"), maar u kunt deze niet gebruiken in uw code omdat deze private .

BigIntegers vergelijken

U kunt BigIntegers dezelfde manier vergelijken als String of andere objecten in Java.

Bijvoorbeeld:

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

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

Output:

Not Equal

Notitie:

In het algemeen geen gebruik maken gebruik maken van de == operator BigIntegers vergelijken

• == operator: vergelijkt referenties; dat wil zeggen of twee waarden naar hetzelfde object verwijzen
• equals() -methode: vergelijkt de inhoud van twee BigIntegers.

BigIntegers moet bijvoorbeeld niet op de volgende manier worden vergeleken:

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

Dit kan leiden tot onverwacht gedrag, aangezien de operator == alleen controleert op referentiegelijkheid. Als beide BigIntegers dezelfde inhoud bevatten, maar niet naar hetzelfde object verwijzen, zal dit mislukken. Vergelijk in plaats daarvan BigIntegers met de equals methoden, zoals hierboven uitgelegd.

U kunt uw BigInteger ook vergelijken met constante waarden zoals 0,1,10.

bijvoorbeeld:

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

U kunt ook twee BigIntegers vergelijken met de methode compareTo() , als volgt: compareTo() retourneert 3 waarden.

• 0: Wanneer beide gelijk zijn .
• 1: Wanneer de eerste groter is dan de tweede (die tussen haakjes).
• -1: Wanneer eerste minder is dan seconde.

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 wiskundige bewerkingsvoorbeelden

BigInteger bevindt zich in een onveranderlijk object, dus u moet de resultaten van een wiskundige bewerking toewijzen aan een nieuwe BigInteger-instantie.

Toevoeging: 10 + 10 = 20

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

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

uitgang: 20

Aftrekking: 10 - 9 = 1

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

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

uitgang: 1

Divisie: 10/5 = 2

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

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

uitgang: 2

Divisie: 17/4 = 4

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

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

uitgang: 4

Vermenigvuldiging: 10 * 5 = 50

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

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

uitgang: 50

Vermogen: 10 ^ 3 = 1000

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

uitgang: 1000

Rest: 10% 6 = 4

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

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

uitgang: 4

GCD: Greatest Common Divisor (GCD) voor 12 en 18 is 6 .

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

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

Uitgang: 6

Maximaal twee BigIntegers:

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

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

Uitgang: 11

Minimaal twee BigIntegers:

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

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

Uitgang: 10

Binaire logische bewerkingen op BigInteger

BigInteger ondersteunt de binaire logische bewerkingen die beschikbaar zijn voor Number types ook. Zoals bij alle bewerkingen worden ze geïmplementeerd door een methode aan te roepen.

Binair Of:

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

val1.or(val2);

Uitgang: 11 (wat overeenkomt met 10 | 9 )

Binair En:

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

val1.and(val2);

Uitgang: 8 (wat overeenkomt met 10 & 9 )

Binaire Xor:

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

val1.xor(val2);

Uitgang: 3 (wat overeenkomt met 10 ^ 9 )

RightShift:

BigInteger val1 = new BigInteger("10");

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

Uitgang: 5 (gelijk aan 10 >> 1 )

Linker shift:

BigInteger val1 = new BigInteger("10");

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

Uitgang: 20 (gelijk aan 10 << 1 )

Binaire inversie (niet):

BigInteger val1 = new BigInteger("10");

val1.not();

Uitgang: 5

NAND (en-niet): *

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

val1.andNot(val2);

Uitgang: 7

Willekeurige BigIntegers genereren

De klasse BigInteger heeft een constructor die is gewijd aan het genereren van willekeurige BigIntegers , gegeven een exemplaar van java.util.Random en een int die aangeeft hoeveel bits de BigInteger hebben. Het gebruik ervan is vrij eenvoudig - wanneer u de constructor BigInteger(int, Random) als volgt BigInteger(int, Random) :

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

dan krijg je een BigInteger met een waarde tussen 0 (inclusief) en 2 ^bitCount (exclusief).

Dit betekent ook dat new BigInteger(2147483647, sourceOfRandomness) alle positieve BigInteger 's voldoende tijd kan geven.

Wat is de sourceOfRandomness is aan jou. Een new Random() is bijvoorbeeld in de meeste gevallen goed genoeg:

new BigInteger(32, new Random());

Als u bereid bent snelheid op te geven voor willekeurige getallen van hogere kwaliteit, kunt u in plaats daarvan een new SecureRandom () gebruiken:

import java.security.SecureRandom;

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

Je kunt zelfs een algoritme on-the-fly implementeren met een anonieme klasse! Merk op dat het uitrollen van je eigen RNG-algoritme je zal eindigen met een lage willekeurigheid , dus zorg er altijd voor dat je een algoritme gebruikt dat bewezen fatsoenlijk is, tenzij je wilt dat de resulterende BigInteger (s) voorspelbaar zijn.

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;
    }
});