Java Language
BigInteger

Вступление

Синтаксис

• BigInteger variable_name = new BigInteger ("12345678901234567890"); // десятичное целое в виде строки
• BigInteger variable_name = new BigInteger ("1010101101010100101010011000110011101011000111110000101011010010", 2) // двоичное целое в виде строки
• BigInteger variable_name = new BigInteger ("ab54a98ceb1f0800", 16) // шестнадцатеричное целое число в виде строки
• BigInteger variable_name = new BigInteger (64, new Random ()); // генератор псевдослучайных чисел, обеспечивающий 64 бита для построения целого числа
• BigInteger variable_name = new BigInteger (новый байт [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // подписали двухдополнительное представление целого (big endian)
• BigInteger variable_name = new BigInteger (1, новый байт [] {- ​​85, 84, -87, -116, -21, 31, 10, -46}); // Непрерывное представление целых чисел без знака (положительное целое число)

замечания

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

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

инициализация

Класс java.math.BigInteger обеспечивает аналоги операций для всех примитивных целочисленных операторов Java и для всех соответствующих методов из java.lang.Math . Поскольку пакет java.math не будет автоматически доступен, вам может потребоваться импортировать java.math.BigInteger прежде чем вы сможете использовать простое имя класса.

Чтобы преобразовать значения long или int в BigInteger используйте:

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

или, для целых чисел:

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

который расширит целое число intValue до long, используя расширение бита знака для отрицательных значений, так что отрицательные значения останутся отрицательными.

Чтобы преобразовать числовую String в BigInteger используйте:

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

Следующий конструктор используется для преобразования строкового представления BigInteger в указанном радиусе в BigInteger .

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

Java также поддерживает прямое преобразование байтов в экземпляр BigInteger . В настоящее время может использоваться только подписанная и беззнаковая кодировка большого конца:

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

Это будет генерировать экземпляр BigInteger со значением -128, поскольку первый бит интерпретируется как бит знака.

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

Это будет генерировать экземпляр BigInteger со значением 128, поскольку байты интерпретируются как беззнаковое число, а знак явно установлен в 1, положительное число.

Существуют предопределенные константы для общих значений:

• BigInteger.ZERO - значение «0».
• BigInteger.ONE - значение «1».
• BigInteger.TEN - значение «10».

Существует также BigInteger.TWO (значение «2»), но вы не можете использовать его в своем коде, потому что он является private .

Сравнение BigIntegers

Вы можете сравнить BigIntegers же, как вы сравниваете String или другие объекты в Java.

Например:

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

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

Выход:

Not Equal

Замечания:

В общем, не используйте использование оператора == для сравнения BigIntegers

• == operator: сравнивает ссылки; т.е. имеют ли два значения один и тот же объект
• Метод equals() : сравнивает содержимое двух BigIntegers.

Например, BigIntegers не следует сравнивать следующим образом:

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

Это может привести к неожиданному поведению, поскольку оператор == проверяет только ссылочное равенство. Если оба BigIntegers содержат один и тот же контент, но не относятся к одному и тому же объекту, это не сработает. Вместо этого сравните BigIntegers, используя методы equals , как описано выше.

Вы также можете сравнить свой BigInteger с постоянными значениями, такими как 0,1,10.

например:

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

Вы также можете сравнить два BigIntegers с помощью метода compareTo() , как compareTo() ниже: compareTo() возвращает 3 значения.

• 0: Когда оба равны .
• 1: Когда первое больше второго (одно в скобках).
• -1: Когда первое меньше секунды.

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

BigInteger находится в неизменяемом объекте, поэтому вам нужно назначить результаты любой математической операции новому экземпляру BigInteger.

Дополнение: 10 + 10 = 20

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

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

выход: 20

Субстрат: 10 - 9 = 1

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

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

выход: 1

Отдел: 10/5 = 2

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

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

выход: 2

Отдел: 17/4 = 4

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

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

выход: 4

Умножение: 10 * 5 = 50

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

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

выход: 50

Мощность: 10 ^ 3 = 1000

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

выход: 1000

Остаток: 10% 6 = 4

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

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

выход: 4

GCD: наибольший общий делитель (GCD) для 12 и 18 - 6 .

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

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

Выход: 6

Максимум два BigIntegers:

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

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

Выход: 11

Минимум двух BigIntegers:

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

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

Выход: 10

Двоичные логические операции на BigInteger

BigInteger поддерживает двоичные логические операции, доступные также для типов Number . Как и во всех операциях, они реализуются путем вызова метода.

Двоичный или:

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

val1.or(val2);

Выход: 11 (что эквивалентно 10 | 9 )

Двоичные и:

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

val1.and(val2);

Выход: 8 (что эквивалентно 10 & 9 )

Binary Xor:

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

val1.xor(val2);

Выход: 3 (что эквивалентно 10 ^ 9 )

RightShift:

BigInteger val1 = new BigInteger("10");

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

Выход: 5 (эквивалентно 10 >> 1 )

Сдвиг влево:

BigInteger val1 = new BigInteger("10");

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

Выход: 20 (эквивалентно 10 << 1 )

Двоичная инверсия (нет):

BigInteger val1 = new BigInteger("10");

val1.not();

Выход: 5

NAND (And-Not): *

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

val1.andNot(val2);

Выход: 7

Создание случайных BigIntegers

Класс BigInteger имеет конструктор, предназначенный для генерации случайных BigIntegers , учитывая экземпляр java.util.Random и int который определяет, сколько бит будет иметь BigInteger . Его использование довольно просто - когда вы вызываете конструктор BigInteger(int, Random) следующим образом:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

то вы получите BigInteger , значение которого находится в ^bitCount от 0 (включительно) и до 2 ^bitCount (исключение).

Это также означает, что new BigInteger(2147483647, sourceOfRandomness) может вернуть все положительные значения BigInteger с достаточным временем.

Какова будет sourceOfRandomness ? Например, new Random() достаточно хорош в большинстве случаев:

new BigInteger(32, new Random());

Если вы хотите отказаться от скорости для более качественных случайных чисел, вместо этого вы можете использовать new SecureRandom () :

import java.security.SecureRandom;

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

Вы даже можете реализовать алгоритм «на лету» с анонимным классом! Обратите внимание , что выкатывает свой собственный алгоритм ГСЧ закончится вас с низким качеством случайностью, поэтому всегда обязательно использовать алгоритм , который , как доказано , чтобы быть достойной , если вы не хотите, чтобы в результате BigInteger (ы) быть предсказуемым.

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