通过这道习题，你会更加了解浮点数

《写给大忙人看的java核心技术》的第一章的第一题，题目很简单，但其中有一个问题,涉及到浮点数中的0到底有多大的问题。浮点数其实并不能简单理解为小数，浮点数是一个是一个稀疏的、不连续的数集，因此我们用的浮点数除了某些值是精确表示，剩下的大部分都是近似表示。详细可参看迷渡大神的这篇文章:代码之谜（四）- 浮点数（从惊讶到思考）。

所以在编程的过程当中就会出现两个需要注意的点：

1. 除以 Int 0会报错，但是除以 float 0会得到Infinity。
   -浮点数的零是由一个极小的小数近似得到的，所以用1去除 float 0得到的是一个极大的值，表现为Infinity

//测试1%0.0
    private static float zeroTest(int decimal){
        float flo = 1 / (float) decimal;
        return flo;
    }

得到的结果为
RES = Infinity

2. 因为浮点数数值不精确，求两个浮点数的值是否相等是一个近似的判断，而且判断的精度不定。同样的原因，浮点数的数学运算得到的都是近似结果。需要更高精度的运算需要使用BigDecimal。

    //测试浮点数相等
    private static boolean equalTest1(){
        float a=0.000000008f;
        float b=0.000000009f;
        return a==b;
    }
    //测试浮点数相等
    private static boolean equalTest2(){
        float a=10.000000000f;
        float b=10.000000009f;
        return a==b;
    }

得到的结果为
RES1 = false
RES2 = true
后者相差更大但后者相等前者不相等。

最后是我对习题的解答，有写的不好的地方希望得到指教。

第一章，第一题
读一个整数并以二进制、八进制、十六进制输出。 以十六进制浮点数输出倒数。

package chapter1;

/**
 * 读一个整数并以二进制、八进制、十六进制输出。 以十六进制浮点数输出倒数。
 * 2017/1/6
 * @author 游韧八荒
 *
 */
public class Demo1 {
    // 十进制转二进制
    private static String toBinary(int decimal) {
        int binary = 0;
        int digit = 0;
        for (int temp = decimal; temp >= 1; digit++) {
            int remainder = temp % 2;
            temp = temp / 2;
            binary = binary + (int) Math.pow(10, digit) * remainder;
        }
        return Integer.toString(binary);
    }

    // 十进制转八进制
    private static String toOctonary(int decimal) {
        int octonary = 0;
        int digit = 0;
        int temp = decimal;
        while (temp >= 1) {
            int remainder = temp % 8;
            temp = temp / 8;
            octonary = octonary + (int) Math.pow(10, digit) * remainder;
            digit++;
        }
        return Integer.toString(octonary);
    }

    // 十进制转十六进制
    private static String toHexadecimal(int decimal) {
        String hexadecimal = "";
        for (int temp = decimal; temp >= 1;) {
            int remainder = temp % 16;
            temp = temp / 16;
            String remainderStr = "";
            
            switch (remainder) {
            case 10:
                remainderStr = "A";
                break;
            case 11:
                remainderStr = "B";
                break;
            case 12:
                remainderStr = "C";
                break;
            case 13:
                remainderStr = "D";
                break;
            case 14:
                remainderStr = "E";
                break;
            case 15:
                remainderStr = "F";
                break;
            default:
                remainderStr = Integer.toString(remainder);
            }
            
            hexadecimal = remainderStr + hexadecimal;
        }
        return hexadecimal;
    }

    // 以十六进制浮点数输出倒数
    /*
     * 第一次将小数乘以十六，得到的数的整数部分就是小数的第一位，然后，去掉整数后的小数又乘以十六，
     * 又将得到的数的整数作为小数点后的第二位。依次乘下去。直到都乘为整数，到最后一位。
     */
    private static String toReciprocal(int decimal) {
        if(decimal == 0){
            return "参数不能为0";
        }
        float flo = 1 / (float) decimal;
        String reciprocal = "0.";
        for (int i = 0; i<10; i++) {
            if(flo == 0){
                break;
            }
            float temp = flo * 16;
            int inte = (int) Math.floor(temp);
            flo = temp - inte;
            String inteStr = "";
            
            switch (inte) {
            case 10:
                inteStr = "A";
                break;
            case 11:
                inteStr = "B";
                break;
            case 12:
                inteStr = "C";
                break;
            case 13:
                inteStr = "D";
                break;
            case 14:
                inteStr = "E";
                break;
            case 15:
                inteStr = "F";
                break;
            default:
                inteStr = Integer.toString(inte);
            }
            reciprocal = reciprocal + inteStr;
        }
        return reciprocal;
    }

    public static void main(String[] args) {
        System.out.println(toBinary(10));
        System.out.println(Integer.toBinaryString(10));
        System.out.println(toOctonary(10));
        System.out.println(Integer.toOctalString(10));
        System.out.println(toHexadecimal(111));
        System.out.println(Integer.toHexString(111));
        System.out.println(toReciprocal(111));
    }
}
/*
 * 现有方法
 * 
 * 十进制转成十六进制： Integer.toHexString(int i) 十进制转成八进制 Integer.toOctalString(int i)
 * 十进制转成二进制 Integer.toBinaryString(int i) 十六进制转成十进制
 * Integer.valueOf("FFFF",16).toString() 八进制转成十进制
 * Integer.valueOf("876",8).toString() 二进制转十进制
 * Integer.valueOf("0101",2).toString()
 * 
 * long整形：数字+L，float：数字+F，double：数字+D
 * 
 * 二进制：0b+数字，八进制：0+数字，十六进制：0x+数字
 * 
 */