java十进制转二进制（输入一个十进制数将其转换成二进制）

      十进制数转二进制数，跟据不同的开发语言其转换方式有很多，在Java中如果相把一个十进制的整数来转换成二进制那是举手之劳，非常简单，只要用Integer.toBinaryString(int)方法就可以得到结果。但如果转换的不是一个整数，而是一个带小数部分的十进制数，那就没有那么容易了。由于整数和小数的转换方式不同，所以先将十进制数的整数部分和小数部分分别转换后，再合并转换后的结果即得到想要的结果。 

十进制数转二进制数的算法如下：
        1. 十进制整数转换为二进制整数  
         十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
        2．十进制小数转换为二进制小数  
          十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。

    下面就给出根据十进制数转二进制数的算法所写的一段Java程序以供大家参考：（输入一个十进制数将其转换成二进制）

import java.math.BigDecimal;
import java.util.Scanner;

public class JZchange {

    public static void main(String[] args) {
        JZchange t = new JZchange();
        Scanner input=new Scanner(System.in);
      
        System.out.println("Please input d:"); 
        double d=input.nextDouble();
        String s = t.decimal2BinaryStr(d);
        System.out.println("十进制数"+d+"转成二进制数为："+s);
    }

    /**
     * 十进制数转二进制数
     * @param d 十进制数
     * @return 十进制数转换成二进制的字符串
     */
    public String decimal2BinaryStr(double d){
        String result = decimal2BinaryStr_Inte(d);
        result += decimal2BinaryStr_Deci(d);
        return result;
    }
    
    /**
     * 十进制整数部分转二进制数
     * @param d 十进制数
     * @return 十进制整数部分转换成二进制的字符串
     */
    public String decimal2BinaryStr_Inte(double d){
//      return Integer.toBinaryString((int)d);
        /*
         * 本来利用上面的Integer.toBinaryString(int)就可以得到整数部分的二进制结果，
         * 但为了展示十进制转二进制的算法，现选择以下程序来进行转换
         */
        String result = "";
        long inte = (long)d;
        int index = 0;
        while(true){
            result += inte%2;
            inte = inte/2;
            index++;
            if(index%4 == 0){
                result+=" ";
            }
            if(inte==0){
                while(index%4!=0){
                    result+="0";
                    index++;
                }
                break;
            }
        }
        char[] c = result.toCharArray();
        char[] cc = new char[c.length]; 
        for(int i=c.length; i>0; i--){
            cc[cc.length-i] = c[i-1];
        }
        return new String(cc);
    }
         /**
     * 十进制小数部分转二进制
     * @param d 十进制数
     * @return 十进制小数部分转换成二进制小数的字符串
     */
    public String decimal2BinaryStr_Deci(double d){
        return decimal2BinaryStr_Deci(d, 0);
    }
    
    /**
     * 十进制小数部分转二进制
     * @param d 十进制数
     * @param scale 小数部分精确的位数
     * @return 十进制小数部分转换成二进制小数的字符串
     */
    public String decimal2BinaryStr_Deci(double d, int scale){
        double deci = sub(d,(long)d);
        if(deci==0){
            return "";
        }
         //为了防止程序因所转换的数据转换后的结果是一个无限循环的二进制小数，因此给其一个默认的精确度
        if(scale==0){
            scale = (String.valueOf(deci).length()-2)*4;
        }
        int index = 0;
        StringBuilder inteStr = new StringBuilder();
        double tempD = 0.d;
        while(true){
            if(deci==0 || index==scale){
                while(index%4!=0){
                    inteStr.append("0");
                    index++;
                }
                break;
            }
            if(index==0){
                inteStr.append("."); 
            }
            tempD = deci*2;
            inteStr.append((int)tempD);
            deci = sub(tempD ,(int)tempD);
            index++;
            if(index%4 == 0){
                inteStr.append(" ");
            } 
        }
        return inteStr.toString();
    }
    
    
    /**
     * 提供精确的减法运算。
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }
}

 运行结果：

Please input d:
1234.5
十进制数1234.5转成二进制数为：0100 1101 0010.1000