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