Java Language
BigInteger

Introduktion

Syntax

• BigInteger variable_name = new BigInteger ("12345678901234567890"); // ett decimaltal som en sträng
• BigInteger variable_name = new BigInteger ("1010101101010100101010011000110011101011000111110000101011010010", 2) // ett binärt heltal som en sträng
• BigInteger variable_name = nytt BigInteger ("ab54a98ceb1f0800", 16) // ett hexadecimalt heltal som en sträng
• BigInteger variable_name = new BigInteger (64, new Random ()); // en pseudorandomnummergenerator som tillhandahåller 64 bitar för att konstruera ett heltal
• BigInteger variable_name = new BigInteger (ny byte [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // undertecknade två komplementrepresentation av ett heltal (big endian)
• BigInteger variabelnamn = nytt BigInteger (1, ny byte [] {- 85, 84, -87, -116, -21, 31, 10, -46}); // osignerade två komplementrepresentation av ett positivt heltal (big endian)

Anmärkningar

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

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

initiering

java.math.BigInteger ger operationsanaloger till alla Java: s primitiva heltalsoperatörer och för alla relevanta metoder från java.lang.Math . Eftersom java.math paketet inte automatiskt görs tillgängligt kan du behöva importera java.math.BigInteger innan du kan använda det enkla klassnamnet.

För att konvertera long eller int värden till BigInteger använd:

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

eller för heltal:

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

vilket kommer att utvidga intValue heltalet till långt med hjälp av teckenbitförlängning för negativa värden, så att negativa värden kommer att förbli negativa.

För att konvertera en numerisk String till BigInteger använd:

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

Följande konstruktör används för att översätta BigInteger av ett BigInteger i den angivna radix till ett BigInteger .

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

Java stöder också direkt konvertering av byte till en instans av BigInteger . För närvarande får endast signerad och osignerad stor endian-kodning användas:

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

Detta genererar en BigInteger instans med värdet -128 eftersom den första biten tolkas som teckenbiten.

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

Detta kommer att generera en BigInteger instans med värdet 128 eftersom byte tolkas som osignerat nummer, och tecknet är uttryckligen inställt på 1, ett positivt tal.

Det finns fördefinierade konstanter för vanliga värden:

• BigInteger.ZERO - värde på "0".
• BigInteger.ONE - värdet på "1".
• BigInteger.TEN - värdet på "10".

Det finns också BigInteger.TWO (värdet på "2"), men du kan inte använda det i din kod eftersom det är private .

Jämför BigIntegers

Du kan jämföra BigIntegers samma sätt som du jämför String eller andra objekt i Java.

Till exempel:

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

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

Produktion:

Not Equal

Notera:

Använd i allmänhet inte använd operatorn == att jämföra BigIntegers

• == operatör: jämför referenser; dvs. om två värden avser samma objekt
• equals() -metod: jämför innehållet i två BigIntegers.

Till exempel bör BigIntegers inte jämföras på följande sätt:

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

Om du gör det kan det leda till oväntat beteende, eftersom operatören == bara kontrollerar referenslikhet. Om båda BigIntegers innehåller samma innehåll, men inte hänvisar till samma objekt, kommer detta att misslyckas. Jämför istället BigIntegers med hjälp av equals metoder, som förklarats ovan.

Du kan också jämföra ditt BigInteger med konstanta värden som 0,1,10.

till exempel:

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

Du kan också jämföra två BigIntegers med compareTo() enligt följande: compareTo() ger 3 värden.

• 0: När båda är lika .
• 1: När den första är större än den andra (den inom parentes).
• -1: När första är mindre än sekund.

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 matematiska exempel

BigInteger finns i ett immutable-objekt, så du måste tilldela resultaten av alla matematiska operationer till en ny BigInteger-instans.

Tillägg: 10 + 10 = 20

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

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

utgång: 20

Substraktion: 10 - 9 = 1

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

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

utgång: 1

Uppdelning: 10/5 = 2

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

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

utgång: 2

Uppdelning: 17/4 = 4

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

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

utgång: 4

Multiplikation: 10 * 5 = 50

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

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

utgång: 50

Effekt: 10 ^ 3 = 1000

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

utgång: 1000

Resten: 10% 6 = 4

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

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

utgång: 4

GCD: Greatest Common Divisor (GCD) för 12 och 18 är 6 .

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

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

Utgång: 6

Maximalt två BigIntegers:

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

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

Utgång: 11

Minst två BigIntegers:

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

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

Utgång: 10

Binära logikoperationer på BigInteger

BigInteger stöder de binära logikoperationerna som också är tillgängliga för Number . Som med alla operationer implementeras de genom att anropa en metod.

Binary Eller:

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

val1.or(val2);

Utgång: 11 (vilket motsvarar 10 | 9 )

Binary Och:

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

val1.and(val2);

Utgång: 8 (vilket motsvarar 10 & 9 )

Binary Xor:

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

val1.xor(val2);

Utgång: 3 (vilket motsvarar 10 ^ 9 )

RightShift:

BigInteger val1 = new BigInteger("10");

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

Utgång: 5 (motsvarande 10 >> 1 )

Vänster Shift:

BigInteger val1 = new BigInteger("10");

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

Utgång: 20 (motsvarande 10 << 1 )

Binär inversion (inte):

BigInteger val1 = new BigInteger("10");

val1.not();

Utgång: 5

NAND (And-Not): *

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

val1.andNot(val2);

Utgång: 7

Generera slumpmässiga BigIntegers

BigInteger har en konstruktör avsedd att generera slumpmässiga BigIntegers , givet en instans av java.util.Random och en int som anger hur många bitar som BigInteger har. Användningen är ganska enkel - när du ringer konstruktören BigInteger(int, Random) så här:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

då kommer du att få ett BigInteger vars värde är mellan 0 (inklusive) och 2 ^bitCount (exklusivt).

Detta innebär också att new BigInteger(2147483647, sourceOfRandomness) kan returnera alla positiva BigInteger s som ges tillräckligt med tid.

Vad kommer sourceOfRandomness vara är upp till dig. Till exempel är en new Random() tillräckligt bra i de flesta fall:

new BigInteger(32, new Random());

Om du är villig att ge upp hastigheten för slumpmässiga nummer med högre kvalitet kan du använda ett new SecureRandom () istället:

import java.security.SecureRandom;

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

Du kan till och med implementera en algoritm on-the-fly med en anonym klass! Observera att rullning av din egen RNG-algoritm kommer att sluta dig med slumpmässighet av låg kvalitet , så se alltid till att använda en algoritm som har visat sig vara anständig om du inte vill att de resulterande BigInteger (erna) ska vara förutsägbara.

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