JAVA BigInteger类 方法使用

类 BigInteger

java.lang.Object
  java.lang.Number
      java.math.BigInteger

 
 
  
  所有已实现的接口：
 
 
 
 

  
  Serializable, Comparable<BigInteger>

 
 

public class BigInteger
  
  
   
   extends Number
  
  
  
  
   
   implements Comparable<BigInteger>
  
  
  
  

  
  
  
  
   
   
import java.math.BigInteger;  
import java.util.*;  
  
public class Main  
{  
    public static void main(String args[])  
    {  
        Scanner cin = new Scanner(System.in);
        
        //读到EOF
        while(cin.hasNext()){}
        //读入BigInteger
        BigInteger a = cin.nextBigInteger();
        
        //构造方法
        //将十进制字符串转化为BigInteger
        //public BigInteger(String val)
        BigInteger b = new BigInteger("3");
        //byte范围-128到+127 8为2进制数 c为767（1011111111）
        //public BigInteger(byte[] val)
        byte[] bt = new byte[]{2,-1};
        BigInteger c = new BigInteger(bt);
        //将radix进制的字符串转化为BigInteger
        //public BigInteger(String val, int radix)
        BigInteger d = new BigInteger("3", 2);
        //随机生成 0到2的numBits次方 -1的随机数
        //public BigInteger(int numBits, Random rnd)
        BigInteger e = new BigInteger(10, new Random());
        //signum为符号位 1为正 0为0 -1为负
        //public BigInteger(int signum, byte[] magnitude)
        BigInteger f = new BigInteger(-1, bt);
        //随机生成一个 长度为bitLength的 可能性大于(1-1/(2的certainty次方))是素数 的数
        //public BigInteger(int bitLength, int certainty, Random rnd)
        BigInteger g = new BigInteger(10, 1, new Random());
        
        //常量
        //0
        //public static final BigInteger ZERO
        a = BigInteger.ZERO;
        //1
        //public static final BigInteger ONE
        a = BigInteger.ONE;
        //10
        //public static final BigInteger TEN
        a = BigInteger.TEN;
        
        //静态方法
        //随机生成一个 长度为bitLength的可能是素数的数
        //public static BigInteger probablePrime(int bitLength, Random rnd)
        BigInteger.probablePrime(10, new Random());
        //值等于val的值
        //public static BigInteger valueOf(long val)
        BigInteger.valueOf(10);
        
        //加法a+b
        //public BigInteger add(BigInteger val)
        a.add(b);
        //减法a-b
        //public BigInteger subtract(BigInteger val)
        a.subtract(b);
        //乘法a*b
        //public BigInteger subtract(BigInteger val)
        a.multiply(b);
        //除法a/b
        //public BigInteger divide(BigInteger val)
        a.divide(b);
        //取模a%b b需大于0 5mod3=2 -5mod3=1
        //public BigInteger mod(BigInteger m)
        a.mod(b);
        //求余 5rem3=2 -5rem3=-2 5rem-3=2 -5rem-3=-2
        //public BigInteger remainder(BigInteger val)
        a.remainder(b);
        //[0]为a/b [1]为a%b
        //public BigInteger[] divideAndRemainder(BigInteger val)
        a.divideAndRemainder(b);
        
        //a==b?
        //public boolean equals(Object x)
        a.equals(b);
        //a的正负 正为1 0为0 负为-1
        //public int signum()
        a.signum();
        //绝对值|a|
        //public BigInteger abs()
        a.abs();
        //比较a>b返回1 a==b返回0 a<b返回-1
        //public BigInteger andNot(BigInteger val)
        a.compareTo(b);
        //相反数-a
        //public BigInteger negate()
        a.negate();
        //max(a,b)
        //public BigInteger max(BigInteger val)
        a.max(b);
        //min(a,b)
        //public BigInteger min(BigInteger val)
        a.min(b);
        //次方a的3次方
        //public BigInteger pow(int exponent)
        a.pow(3);
        //a的-1次方 %b
        //public BigInteger modInverse(BigInteger m)
        a.modInverse(b);
        //a的b次方 %c
        //public BigInteger modPow(BigInteger exponent,BigInteger m)
        a.modPow(b, c);
        
        //~a
        //public BigInteger not()
        a.not();
        //a^b
        //public BigInteger xor(BigInteger val)
        a.xor(b);
        //a|b
        //public BigInteger or(BigInteger val)
        a.or(b);
        //a&b
        //public BigInteger divide(BigInteger val)
        a.and(b);
        //a左移n位 (a << n)
        //public BigInteger shiftLeft(int n)
        a.shiftLeft(10);
        //a右移n位 (a >> n)
        //public BigInteger shiftRight(int n)
        a.shiftRight(10);
        //a&(~b)
        //public BigInteger andNot(BigInteger val)
        a.andNot(b);
        //二进制形式中把第n位二进制设为0 (a & ~(1<<n))
        //public BigInteger clearBit(int n)
        a.clearBit(10);
        //二进制形式中把第n位二进制设为1 (a | (1<<n))
        //public BigInteger setBit(int n)
        a.setBit(10);
        //二进制形式中第n位二进制是否为1 (a & (1<<n)) != 0)
        //public boolean testBit(int n)
        a.testBit(10);
        //二进制形式中把第n位二进制翻转 (a ^ (1<<n))
        //public BigInteger flipBit(int n)
        a.flipBit(10);
        //二进制形式中最低位1后面0的个数 (a == 0? -1 : log2(a & -a))
        //public int getLowestSetBit()
        a.getLowestSetBit();
        //二进制形式中与符号不同的位的数量 7为3 -7为2
        //public int bitCount()
        a.bitCount();
        //二进制形式中不包括符号位的长度
        //public int bitLength()
        a.bitLength();
        
        //a和b的最大公约数
        //public BigInteger gcd(BigInteger val)
        a.gcd(b);
        //a可能为素数返回true a一定为合数返回false 素数可能性大于(1-1/(2的certainty次方))
        //public boolean isProbablePrime(int certainty)
        a.isProbablePrime(10);
        //大于a的可能为素数的第一个整数。
        //public BigInteger nextProbablePrime()
        a.nextProbablePrime();
        //a的哈希码
        //public int hashCode()
        a.hashCode();
        
        //a的二进制补码形式
        //public byte[] toByteArray()
        a.toByteArray();
        //a的十进制字符串形式
        //public String toString()
        a.toString();
        //a的radix进制字符串形式
        //public String toString(int radix)
        a.toString(2);
        //将a转换为int
        //public int intValue()
        a.intValue();
        //将a转换为long
        //public long longValue()
        a.longValue();
        //将a转换为float
        //public float floatValue()
        a.floatValue();
        //将a转换为double
        //public double doubleValue()
        a.doubleValue();
        
        //JAVA 1.8
        a.byteValueExact();
        a.intValueExact();
        a.longValueExact();
        a.shortValueExact();
        
        //从类 java.lang.Number 继承的方法
        //将a转换为short
        //public short shortValue()
        a.shortValue();
        //将a转换为byte
        //public byte byteValue()
        a.byteValue();
        
        //从类 java.lang.Object 继承的方法
        //public final Class<?> getClass()
        a.getClass();
        //public final void notify()
        a.notify();
        //public final void notifyAll()
        a.notifyAll();
        try {
            //public final void wait() throws InterruptedException
            a.wait();
            //public final void wait(long timeout) throws InterruptedException
            a.wait(10);
            //public final void wait(long timeout, int nanos) throws InterruptedException
            a.wait(10, 10);
        } catch (Exception exception) {
        }

    }  
}