把10进制整数转换成其他进制字符串

10进制转16进制：

public class Test {

    public static void main(String[] args) {

        // 测试数据
        int i1 = 127;
        int i2 = 1000;

        // 输出测试数据
        System.out.println("10进制" + i1 + "的16进制数是：" + toHexString(i1));
        System.out.println("10进制" + i2 + "的16进制数是：" + toHexString(i2));
    }

    /**
     * 把十进制数字转换成16进制
     *
     * @param value
     * @return
     */
    public static String toHexString(int value) {
        // 一个int有4个字节，也就是32位二进制数，一个16进制代表4位二进制数，所以一个int代表8位十六进制数
        char[] buffer = new char[8];
        // 循环8次
        for (int i = buffer.length - 1; i >= 0; i--) {

            // 获得十六进制的个位，由于10进制数字转换成2进制之后最后四位代表16进制的个位，而15代表1111，其余位都是0，所以可以获得最后四位二进制数，这也就是该进制的最后一位
            int bit = value & 15;
            // 将0～9转换为'0'～'9'，将10～15转换为'a'～'f'
            buffer[i] = (char) (bit <= 9 ? bit + '0' : bit + 'a' - 10);

            // 右移4位，即value除以16，和之前获得10进制数最后一位的做法是一致的
            value >>>= 4;
        }

        // 返回由字符数组构造的字符串，字符数组前面填充的是默认值0
        return new String(buffer);
    }
}

结果：

10进制127的16进制数是：0000007f
10进制1000的16进制数是：000003e8

10进制转8进制：

public class Test {

    public static void main(String[] args) {

        // 测试数据
        int i1 = 127;
        int i2 = 1000;

        // 输出测试数据
        System.out.println("10进制" + i1 + "的8进制数是：" + toOctalString(i1));
        System.out.println("10进制" + i2 + "的8进制数是：" + toOctalString(i2));
    }

    /**
     * 将10进制转换成8进制
     *
     * @param value
     * @return
     */
    public static String toOctalString(int value) {
        // 一个int有4个字节，也就是32位二进制数，一个8进制代表3位二进制数，所以一个int代表11位十六进制数
        char[] buffer = new char[11];
        // 循环11次
        for (int i = buffer.length - 1; i >= 0; i--) {

            // 获得八进制的个位，由于10进制数字转换成2进制之后最后三位代表8进制的个位，而7代表111，其余位都是0，所以可以获得最后三位二进制数，这也就是该进制的最后一位
            int bit = value & 7;
            // 将0～7转换为'0'～'7'
            buffer[i] = (char) (bit + '0');

            // 右移3位，即value除以8，和之前获得10进制数最后一位的做法是一致的
            value >>>= 3;
        }

        // 返回由字符数组构造的字符串，字符数组前面填充的是默认值0
        return new String(buffer);
    }
}

结果：

10进制127的8进制数是：00000000177
10进制1000的8进制数是：00000001750

10进制转4进制：

public class Test {

    public static void main(String[] args) {

        // 测试数据
        int i1 = 127;
        int i2 = 1000;

        // 输出测试数据
        System.out.println("10进制" + i1 + "的4进制数是：" + toQuaternaryString(i1));
        System.out.println("10进制" + i2 + "的4进制数是：" + toQuaternaryString(i2));
    }

    /**
     * 把十进制数字转换成4进制
     *
     * @param value
     * @return
     */
    public static String toQuaternaryString(int value) {
        // 一个int有4个字节，也就是32位二进制数，一个4进制是2位，所以一个int类型的整数就是16位
        char[] buffer = new char[16];
        // 循环16次
        for (int i = buffer.length - 1; i >= 0; i--) {

            // 获得四进制的个位，由于10进制数字转换成2进制之后最后2位代表4进制的个位，而3代表11，其余位都是0，所以可以获得最后2位二进制数，这也就是该进制的最后一位
            int bit = value & 3;
            // 将0～3转换为'0'～'3'
            buffer[i] = (char) (bit + '0');

            // 右移2位，即value除以4，和之前获得10进制数最后一位的做法是一致的
            value >>>= 2;
        }

        // 返回由字符数组构造的字符串，字符数组前面填充的是默认值0
        return new String(buffer);
    }
}

结果：

10进制127的4进制数是：0000000000001333
10进制1000的4进制数是：0000000000033220

10进制转2进制：

public class Test {

    public static void main(String[] args) {

        // 测试数据
        int i1 = 127;
        int i2 = 1000;

        // 输出测试数据
        System.out.println("10进制" + i1 + "的2进制数是：" + toBinaryString(i1));
        System.out.println("10进制" + i2 + "的2进制数是：" + toBinaryString(i2));
    }

    /**
     * 把十进制数字转换成2进制
     *
     * @param value
     * @return
     */
    public static String toBinaryString(int value) {
        // 一个int有4个字节，也就是32位二进制数
        char[] buffer = new char[32];
        // 循环32次
        for (int i = buffer.length - 1; i >= 0; i--) {

            // 获得2进制的个位
            int bit = value & 1;
            // 将0～1转换为'0'～'1'
            buffer[i] = (char) (bit + '0');

            // 右移1位，即value除以2，和之前获得10进制数最后一位的做法是一致的
            value >>>= 1;
        }

        // 返回由字符数组构造的字符串，字符数组前面填充的是默认值0
        return new String(buffer);
    }
}

结果：

10进制127的2进制数是：00000000000000000000000001111111
10进制1000的2进制数是：00000000000000000000001111101000

10进制转2/4/8/10/16进制：

public class Test {

    public static void main(String[] args) {

        // 测试数据
        int i1 = 127;
        int i2 = 1000;

        // 需要转换的进制数
        int radix = 16;

        // 输出测试数据
        System.out.println("10进制" + i1 + "的" + radix + "进制数是：" + toString(i1, radix));
        System.out.println("10进制" + i2 + "的" + radix + "进制数是：" + toString(i2, radix));
    }

    /**
     * 把十进制数字转换成radix进制字符数
     *
     * @param value
     * @return
     */
    public static String toString(int value, int radix) {

        if (radix == 10) {
            return value + "";
        }

        // 根据进制数得出字符数组的位数
        int num = radix == 2 ? 32 : (radix == 4 ? 16 : (radix == 8 ? 11 : (radix == 16 ? 8 : 0)));
        // 根据进制数得出右移的位数
        int digit = radix == 2 ? 1 : (radix == 4 ? 2 : (radix == 8 ? 3 : (radix == 16 ? 4 : 0)));

        // 如果是2/4/8/16进制中的，那就进行进制转换
        if (num != 0) {
            // 一个int有4个字节，也就是32位二进制数，一个radix进制代表radix/2^n位二进制数，所以一个int代表32/(radix/2^n)位radix进制数
            char[] buffer = new char[num];
            // 循环num次，例如16进制就是循环8次，保证取到所有的16进制数
            for (int i = buffer.length - 1; i >= 0; i--) {

                // 获得该进制的个位
                int bit = value & (radix - 1);
                // 将0～9转换为'0'～'9'，将10～15转换为'a'～'f'
                buffer[i] = (char) (bit <= 9 ? bit + '0' : bit + 'a' - 10);

                // 右移相关位，和之前获得10进制数最后一位的做法是一致的
                value >>>= digit;
            }

            // 返回由字符数组构造的字符串，字符数组前面填充的是默认值0
            return new String(buffer);

        }

        //无效参数异常
        throw new IllegalArgumentException("radix参数值" + radix + "表示的进制无效。");
    }
}

结果：

10进制127的16进制数是：0000007f
10进制1000的16进制数是：000003e8