Java Language
BigInteger

소개

통사론

• BigInteger variable_name = 새 BigInteger ( "12345678901234567890"); // 문자열로 된 10 진 정수
• BigInteger variable_name = new BigInteger ( "1010101101010100101010011000110011101011000111110000101011010010", 2) // 이진 정수를 문자열로 지정합니다.
• BigInteger variable_name = new BigInteger ( "ab54a98ceb1f0800", 16) // 문자열로서의 16 진 정수
• BigInteger variable_name = 새 BigInteger (64, 새로운 임의 ()); // 정수를 구성하기 위해 64 비트를 공급하는 의사 난수 생성기
• BigInteger variable_name = new BigInteger (새 바이트 [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // 정수의 부호있는 2의 보수 표현 (빅 엔디안)
• BigInteger variable_name = new BigInteger (1, 새 바이트 [] {- ​​85, 84, -87, -116, -21, 31, 10, -46}); // 양의 정수의 부호없는 2의 보수 표현 (빅 엔디안)

비고

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.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 이 음의 값이 음수있을 것입니다, 그래서 음수 값에 대한 부호 비트 확장을 사용, 긴에 정수를.

숫자 String 을 BigInteger 로 변환하려면 다음을 사용하십시오.

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

생성자를 따라하는 것은 a의 문자열 표현을 변환하는 데 사용되는 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);

첫 번째 비트가 부호 비트로 해석되므로 값이 -128 인 BigInteger 인스턴스가 생성됩니다.

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

바이트가 부호 없음 숫자로 해석되고 부호가 명시 적으로 1, 양수로 설정되므로 값 128 인 BigInteger 인스턴스가 생성됩니다.

공통 값에 대해 미리 정의 된 상수가 있습니다.

• BigInteger.ZERO - 값이 "0"입니다.
• BigInteger.ONE - 값은 "1"입니다.
• BigInteger.TEN - 값이 "10"입니다.

또한 BigInteger.TWO (값 "2")가 있지만 private 이므로 코드에서 사용할 수 없습니다.

BigIntegers 비교하기

Java에서 String 이나 다른 객체를 비교할 때와 마찬가지로 BigIntegers 를 비교할 수 있습니다.

예 :

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를 비교하지 마십시오.

• == 연산자 : 참조를 비교합니다. 즉, 두 값이 동일한 객체를 참조하는지 여부
• equals() 메소드 : 2 개의 BigInteger의 내용을 비교합니다.

예를 들어, BigInteger를 다음과 같은 방법으로 비교해서는 안된다 :

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

이렇게하면 == 연산자가 참조 평등 만 검사하기 때문에 예기치 않은 동작이 발생할 수 있습니다. 양쪽 모두의 BigInteger에 같은 내용이 포함되어 있어도, 같은 오브젝트를 참조하지 않는 경우는 실패합니다. 대신 위에 설명한 것처럼 equals 메서드를 사용하여 BigIntegers를 비교하십시오.

BigInteger 를 0,1,10과 같은 상수 값과 비교할 수도 있습니다.

예 :

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

다음과 같이 compareTo() 메서드를 사용하여 두 BigInteger를 비교할 수도 있습니다. 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

Division : 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 : 12 및 18 대한 GCD (Greatest Divisor)는 6 입니다.

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

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

산출 : 6

최대 2 개의 BigInteger :

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

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

출력 : 11

최소 2 개의 BigInteger :

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 )

이진 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 )

LeftShift :

BigInteger val1 = new BigInteger("10");

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

출력 : 20 ( 10 << 1 )

바이너리 반전 (Not) :

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 클래스에는, java.util.Random 의 인스턴스 및 BigInteger 비트 수를 지정하는 int 를 지정해, random BigIntegers 를 생성하기 위해서 사용되는 BigInteger 있습니다. 그 사용법은 매우 간단합니다. 다음과 같이 BigInteger(int, Random) 생성자를 호출 할 때 :

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

값이 0 (포함)과 2 ^bitCount (포함되지 않음) 사이에있는 BigInteger 로 끝납니다.

이것은 또한 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());

익명의 클래스로 즉석에서 알고리즘을 구현할 수도 있습니다! 독자적인 RNG 알고리즘을 구현 하면 (자) , 품질의 난잡함 이 없어 질 가능성이 있으므로, 결과의 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;
    }
});