BigInteger

不可变的任意精度的整数。所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

创建一个BigInteger 常用方式

（1）使用构造函数

// 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
BigInteger base = new BigInteger("16");

（2）静态方法

// 返回其值等于指定 long 的值的 BigInteger。
// 返回 BigInteger，如果值在 -16-16 之间，那么返回的 BigInteger是同一个对象。
BigInteger base = BigInteger.valueOf(16);
System.out.println(BigInteger.valueOf(16) == BigInteger.valueOf(16));//true
System.out.println(BigInteger.valueOf(17) == BigInteger.valueOf(17));//false
System.out.println(BigInteger.valueOf(-16) == BigInteger.valueOf(-16));//true
System.out.println(BigInteger.valueOf(-17) == BigInteger.valueOf(-17));//false

常见运算操作方法

import java.math.BigInteger;
public class BigIntegerDemo1 {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("123456789");  // 声明BigInteger对象
        BigInteger bi2 = new BigInteger("987654321");  // 声明BigInteger对象
        System.out.println("加法操作：" + bi2.add(bi1));    // 加法操作
        System.out.println("减法操作：" + bi2.subtract(bi1));   // 减法操作
        System.out.println("乘法操作：" + bi2.multiply(bi1));   // 乘法操作
        System.out.println("除法操作：" + bi2.divide(bi1)); // 除法操作
        BigInteger result[] = bi2.divideAndRemainder(bi1); // 求出余数的除法操作
        System.out.println("商是：" + result[0] + "；余数是：" + result[1]);
        System.out.println("最大数：" + bi2.max(bi1));  // 求出最大数
        System.out.println("最小数：" + bi2.min(bi1));  // 求出最小数
    }
}

BigDecimal

不可变的、任意精度的有符号十进制数。

创建一个BigDecimal常用方式

（1）使用构造函数

BigDecimal b1 = new BigDecimal("12.1");

（2）静态方法

// 参数是 double 类型
BigDecimal b2 = BigDecimal.valueOf(12.1);

常见运算操作方法

import java.math.BigDecimal;
public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("10.345");
        BigDecimal b2 = new BigDecimal("3.333");

        System.out.println("加法运算：" + b1.add(b2)); // 13.678
        System.out.println("减法运算：" + b1.subtract(b2)); // 7.012
        System.out.println("乘法运算：" + b1.multiply(b2)); // 34.479885
        // System.out.println("除法运算：" + b1.divide(b2) // 报错，
            // 返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；
            // 如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。

        System.out.println("除法运算：" + b1.divide(b2, 3, BigDecimal.ROUND_HALF_EVEN)); // 3.104
        System.out.println("除法运算：" + b1.divide(b2, BigDecimal.ROUND_HALF_EVEN)); // 3.104，其标度为 this.scale()。

        System.out.println("加法运算：" + MyMath.round(MyMath.add(10.345, 3.333), 1)); // 13.7
        System.out.println("减法运算：" + MyMath.round(MyMath.sub(10.345, 3.333), 3)); // 7.012
        System.out.println("乘法运算：" + MyMath.round(MyMath.mul(10.345, 3.333), 4)); // 34.4799
        System.out.println("除法运算：" + MyMath.div(10.345, 3.333, 3)); // 3.104
    }
}

class MyMath {
    public static double add(double d1, double d2) { // 进行加法计算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.add(b2).doubleValue(); // 将此 BigDecimal 转换为 double。
    }

    public static double sub(double d1, double d2) { // 进行减法计算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.subtract(b2).doubleValue();
    }

    public static double mul(double d1, double d2) { // 进行乘法计算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.multiply(b2).doubleValue();
    }

    public static double div(double d1, double d2, int len) { // 进行除法计算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.divide(b2, len, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /*
    进行四舍五入
     */
    public static double round(double d, int len) {
        BigDecimal b1 = new BigDecimal(d);
        BigDecimal b2 = new BigDecimal(1); // 技巧
        return b1.divide(b2, len, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

除法

BigDecimal divide(BigDecimal divisor)
          返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；
          如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。
BigDecimal divide(BigDecimal divisor, int roundingMode)
          返回一个 BigDecimal，其值为 (this / divisor)，其标度为 this.scale()。
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
          返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度scale。

舍入模式

static int ROUND_CEILING
          接近正无穷大的舍入模式。
static int ROUND_DOWN
          接近零的舍入模式。
static int ROUND_FLOOR
          接近负无穷大的舍入模式。
static int ROUND_HALF_DOWN
          向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。
static int ROUND_HALF_EVEN
          向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
static int ROUND_HALF_UP
          向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
static int ROUND_UNNECESSARY
          断言请求的操作具有精确的结果，因此不需要舍入。
static int ROUND_UP
          舍入远离零的舍入模式。

华为机试题

写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class BinHexOct {

    public static void main(String[] args) {
        test2();
    }

    /*
    直接使用的JavaAPI--Integer提供的方法，将十六进制进行转换
     */
    private static void test1() {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        String line;
        try {
            while ((line = bufr.readLine()) != null) {
                line = line.substring(2);
                int result = Integer.parseInt(line, 16);
                System.out.println(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
    处理大数的情况
     */
    public static void test2() {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        String line;
        BigInteger base = new BigInteger("16");
        try {
            while ((line = bufr.readLine()) != null) {
                line = line.substring(2);
                //int result = Integer.parseInt(line, 16);
                BigInteger result = new BigInteger("0");
                for (int i = 0; i < line.length(); i++) {
                    char ch = line.charAt(line.length() - 1 - i);
                    if (ch >= 'A' && ch <= 'F') {
                        //pow n的m次幂，返回 BigInteger
                        BigInteger tmp = base.pow(i).multiply(new BigInteger(Integer.toString((ch - 'A' + 10))));
                        result = result.add(tmp);
                    } else {
                        BigInteger tmp = base.pow(i).multiply(new BigInteger(Character.toString(ch)));
                        result = result.add(tmp);
                    }
                }
                System.out.println(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

http://blog.csdn.net/zhongkelee/article/details/52289163
https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html
https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html