Java的BigInteger的应用

BigInteger 任意大的整数，原则上是，只要你的计算机的内存足够大，可以有无限位的

BigInteger 任意大的实数，可以处理小数精度问题。

BigInteger中一些常见的函数：

A=BigInteger.ONE

B=BigInteger.TEN

C=BigInteger.ZERO

一些常见的数的赋初值。将int型的数赋值给BigInteger，BigInteger.valueOf(k);

基本的函数：

valueOf:赋初值

add:+ a.add(b);

subtract:-

multiply:*

divide:/

remainder：this % val

divideAndRemainder：a[0]=this / val; a[1]=this % val

pow：a.pow(b)=a^b

gcd,abs:公约数，绝对值

negate：取负数

signum：符号函数

mod：a.mod(b)=a%b;

shiftLeft:左移，this << n ，this*2^n;

shiftRight:右移，this >> n，this/2^n;

and:等同于c++的&&,且；

or：||，或;

xor:异或，BigInteger xor(BigInteger val),this^val

not:!,非；

isProbablePrime：如果该 BigInteger 可能是素数，则返回 true ；如果它很明确是一个合数，则返回 false 。 参数 certainty 是对调用者愿意忍受的不确定性的度量：如果该数是素数的概率超过了 1 - 1/2**certainty方法，则该方法返回 true 。执行时间正比于参数确定性的值。

compareTo：根据该数值是小于、等于、或大于 val 返回 -1、0 或 1；

equals：判断两数是否相等，也可以用compareTo来代替；

min，max：取两个数的较小、大者；

intValue，longValue，floatValue，doublue：把该数转换为该类型的数的值。

 

字段详细信息

ZERO

public static final BigInteger ZERO

BigInteger 的常量 0。 

从以下版本开始：

1.2

ONE

public static final BigInteger ONE

BigInteger 的常量 1。 

从以下版本开始：

1.2

TEN

public static final BigInteger TEN

BigInteger 的常量 10。 

从以下版本开始：

1.5

probablePrime

public static BigInteger probablePrime(int bitLength,

                                       Random rnd)

返回有可能是素数的、具有指定长度的正 BigInteger。此方法返回的 BigInteger 是合数的概率不超出 2-100。 

参数：bitLength - 返回的 BigInteger 的 bitLength。

rnd - 随机比特源，用这些随机比特选择用来进行质数测试的候选数。 

返回：可能是素数的 bitLength 个位的 BigInteger 

抛出：ArithmeticException - bitLength < 2。

从以下版本开始：

1.4

另请参见：

bitLength()

nextProbablePrime

public BigInteger nextProbablePrime():返回大于此 BigInteger 的可能为素数的第一个整数。此方法返回的数是合数的概率不超出 2-100。此方法在执行以下搜索时将始终不会跳过素数：如果它返回 p，则不存在 this < q < p 的素数 q。 

返回：返回大于此 BigInteger 的可能为素数的第一个整数。 

抛出：ArithmeticException - this < 0。

从以下版本开始：

1.5

函数参考:http://www.apihome.cn/api/java/BigInteger.html

具体应用案例:

import java.math.BigInteger;
import javax.swing.JOptionPane;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
public class Prime extends Frame implements ActionListener,ItemListener{
    String st;  
    Label l1=new Label("大素数生成:"),l2=new Label("检测是否是素数：");
    Label l3=new Label("请输入要生成的大素数或大随机数位数:");
    TextArea ta1=new TextArea(3,40);
    TextField ta2=new TextField(70);
    TextField ta3=new TextField(10);
    Button b1=new Button("生成素数"),b2=new Button("检验素数");
    Choice c1;
    Prime()
    {
    super("我是标题 ");
    //标签
    setSize(600,300);
    setLocation(360,220);
    addWindowListener(new WindowAdapter()
    {
        public void windowClosing(WindowEvent c)
        {
            System.exit(0);
        }
    }
    );
    setLayout(null);
    setVisible(true);
    /*添加界面组件以及监听器*/   
    c1=new Choice(); //选择按钮
    c1.add("大素数生成");
    c1.add("大随机数产生");
    add(c1);
    add(l1);
    add(l2);
    add(l3);
    add(ta1);
    add(ta2);
    add(ta3);
    add(b1);
    add(b2);
    c1.addItemListener(this);
    c1.setBounds(50,40,150,20);
    l3.setBounds(50, 75, 225, 20);
    ta3.setBounds(275,75,200,23);
    l1.setBounds(50,100,100,20);
    ta1.setBounds(50,125,400,50);
    b1.setBounds(100,200,60,35);
    b1.addActionListener(this);
    b2.addActionListener(this);
    }
    /*对应不同加密算法的按钮点击事件*/
    public void actionPerformed(ActionEvent e){
        if (e.getSource()==b1&&c1.getSelectedIndex()==0)
        {//第一个按钮
            String str=ta3.getText();
            if(str.equals(""))
            {
                JOptionPane.showMessageDialog(null,"你输入位数为空");
            }
            else
            {
                sushu(str);
            }
        }
        if (e.getSource()==b1&&c1.getSelectedIndex()==1)
        {//第一个按钮
            String str=ta3.getText();
            if(str.equals(""))
            {
                JOptionPane.showMessageDialog(null,"你输入位数为空");
            }
            else
            {
                suijishu(str);
            }
        }
        if(e.getSource()==b2&&c1.getSelectedIndex()==1)
        {//第二个按钮
            jiance();
        }
    }
    public void itemStateChanged(ItemEvent e){
        int index=c1.getSelectedIndex();
        if(index==1)
        {
            ta1.setText("");
            l1.setText("大随机数");
            b1.setLabel("生成大随机数");
            b1.setBounds(100,200,80,35);
            b2.setVisible(true);
            b2.setBounds(230,200,80,35);
        }
        if(index==0)
        {
            ta1.setText("");
            l1.setText("大素数生成");
            b1.setLabel("生成素数");
            l2.setVisible(false);
            b2.setVisible(false);
            ta2.setVisible(false);
        }
    }
    //实现一个大素数生成算法
    public void sushu(String str){
        int numDigits;
        try {
                numDigits = Integer.parseInt(str);
            }
        catch (Exception e) {
                JOptionPane.showMessageDialog(null,"你输入数据非法,默认使用20位");
                numDigits = 20;
            }
        BigInteger start = bigRandom(numDigits);
        start = nextPrime(start);
        st=start.toString();
        ta1.setText(st);
    }
    public void suijishu(String str){
        int numDigits;
        try {
                numDigits = Integer.parseInt(str);
            }
        catch (Exception e) {
                JOptionPane.showMessageDialog(null,"你输入数据非法,默认使用20位");
                numDigits = 20;
            }
        BigInteger start = bigRandom(numDigits);
        st=start.toString();
        ta1.setText(st);
    }
    public void jiance(){
        st=ta1.getText();
        if(st.equals("")){}
        else
        {    
            BigInteger ste = new BigInteger(st);
            String ss=fun1(ste);
            ta1.append("\n"+ss);
        }  
    }
    // 下面的 BigInteger.ZERO 和 BigInteger.ONE 在 JDK 1.1 中是无效的
    private static final BigInteger ZERO = BigInteger.ZERO;
    private static final BigInteger ONE = BigInteger.ONE;
    private static final BigInteger TWO = new BigInteger("2");
    // 产生一个错误素数的概率小于 1/2 的 ERR_VAL 次方，可以将 ERR_VAL 定义为 200，降低其错误率
    // Java 应该使用的是 Miller-Rabin 测试法，这种错误概率基本上可以认为是无错误。
    private static final int ERR_VAL = 100;
    private static StringBuffer[] digits = { new StringBuffer("0"), new StringBuffer("1"), new StringBuffer("2"), new StringBuffer("3"), new StringBuffer("4"), new StringBuffer("5"),
    new StringBuffer("6"), new StringBuffer("7"), new StringBuffer("8"), new StringBuffer("9") };
    private static StringBuffer randomDigit(boolean isZeroOK) {
        // 产生一个随机的数字（字符串形式的），isZeroOK 决定这个数字是否可以为 0
        int index;
        if (isZeroOK)
            index = (int) Math.floor(Math.random() * 10);
        else
            index = 1 + (int) Math.floor(Math.random() * 9);
        return (digits[index]);
    }
 
    public static BigInteger bigRandom(int numDigits) {
    // 产生一个随机大整数，各位上的数字都是随机产生的，首位不为 0
        StringBuffer s = new StringBuffer("");
        for (int i = 0; i < numDigits; i++)
        {
            if (i == 0)
                s.append(randomDigit(false));
            else
                s.append(randomDigit(true));
        }
        return (new BigInteger(s.toString()));
    }
    private static boolean isEven(BigInteger n) {
        // 测试一个大整数是否为偶数
        return (n.mod(TWO).equals(ZERO));
    }
    public static BigInteger nextPrime(BigInteger start) {
        // 产生一个比给定大整数 start大的素数，错误率低于 1/2 的 ERR_VAL 次方
        if (isEven(start))
            start = start.add(ONE);
        else
            start = start.add(TWO);
        if (start.isProbablePrime(ERR_VAL))
            return (start);
        else
            // 采用递归方式（递归的层数会是个天文数字吗？）
        return (nextPrime(start));
    }
    //判断素数
    public String fun1(BigInteger str)
    {
        if(str.isProbablePrime(ERR_VAL))
        {
            return "是素数";
        }
        else
        {
            return "不是素数";
        }
    }
    public static void main(String arg[]){
        Prime ob=new Prime();
    }
}