请教Java中一个16进制与10进制转换的问题
请教各位一个数据转换的问题，就是在Java中，我现在有4个16进制数，也就是4个字节，请问怎么把这四个字节的16进制数字转换为一个32位的二进制数，然后再把这个32位的二进制数转换为一个十进制数。
举个例子，我现在有四个16进制数，为00,00,00,01，通过代码转换为0000 0000 0000 0001，再转换为十进制就是1。
再举个例子，四个16进制数为00,00,01,01，通过代码转换为0000 0000 0001 0001，再转换为十进制就是17。
这是正向操作，反向操作就是十进制转换为32位的二进制，再转换为四个16进制数字。
请问以上正反向转换怎么通过Java代码实现啊？
真人作答。
运行结果如下：
代码：
public class Test {
//1字节16进制转2进制，输入01，输出00000001
public static String Ox2Bits(String s){
String fx ="0123456789abcdef";
String[] bits = {"0000","0001","0010","0011","0100","0101","0110","0111","1000",
"1001","1010","1011","1100","1101","1110","1111"};
String out="";
for(int i=0;i<2;i++){
char t = Character.toLowerCase(s.charAt(i));
int index = fx.indexOf(t);
out += bits[index];
}
return out;
}
//4字节16进制转32位2进制
public static String FourOX2Bits(String[] s){
String out="";
for(int i=0;i<4;i++){
out += Ox2Bits(s[i]);
}
return out;
}
//32位2进制转无符号int
public static int Bits2Int(String s){
int res = 0;
int jc = 1;
for(int j=s.length()-1;j>=0;j--){
if(s.charAt(j)=='1')
res += jc;
jc *= 2;
}
return res;
}
//int转32位2进制
public static String Int2bits(int n){
String out ="";
while(n>0){
int t = n%2;
if(t==1)
out += '1';
else
out += '0';
n/=2;
}
StringBuffer stringBuffer = new StringBuffer(out);
out = stringBuffer.reverse().toString();
String st="";
for(int i=0;i<32-out.length();i++)
st +='0';
st += out;
return st;
}
//8位2进制转一个16进制字节
public static char bits2Ox(String s){
int t = 0;
int res = 1;
for(int i=s.length()-1;i>=0;i--){
if(s.charAt(i)=='1')
t += res;
res *=2;
}
char out = (char)t;
return out;
}
//32位2进制转4字节
public static char[] bits2OxFour(String s){
int start=0,end=8;
char[] out = new char[5];
for(int i=0;i<4;i++){
out[i] = bits2Ox(s.substring(start,end));
start +=8;
end += 8;
}
return out;
}
public static void main(String[] args){
System.out.println("-----------正向--------------");
String[] ori={"00","00","02","00"};
System.out.print("4字节16进制：");
for(int i=0;i<4;i++)
System.out.print(ori[i]+" ");
System.out.println();
String bits = FourOX2Bits(ori); //4字节16进制转32位2进制
System.out.println("转32位2进制："+bits);
int res = Bits2Int(bits); //32位2进制转int 16*32
System.out.println("转int："+res);
System.out.println("-----------反向--------------");
int n = 40;
System.out.println("整数："+n);
String bs = Int2bits(n); //int转32位2进制
System.out.print("转32位2进制："+bs);
char[] ox = bits2OxFour(bs); //32位2进制转4字节16进制
System.out.println();
System.out.print("转4字节16进制：");
for(int i=0;i<4;i++)
System.out.printf("%02x ",(int)ox[i]);
System.out.println();
}// main end
}
byte b1 = 0x12;
byte b2 = 0x34;
byte b3 = 0x56;
byte b4 = 0x78;
int result = ((b1 & 0xFF) << 24) | ((b2 & 0xFF) << 16) | ((b3 & 0xFF) << 8) | (b4 & 0xFF);
直接合并成int即可，没必要中途先转二进制。如果非要显示二进制，用toBinaryString(int i)
反过来也一样，一个4位数如何取得每一位这种问题你应该做过吧，现在只不过十进制变成16进制，对应的不除以100而是256，其他一样
1、 在本地用html文件提交一个携带json格式数据的post网络请求，可以使用Java中的HttpURLConnection类来实现。以下是一个示例代码：
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class HttpPostExample {
public static void main(String[] args) throws Exception {
String url = "http://example.com/api";
URL obj = new URL(url);
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
// add request header
con.setRequestMethod("POST");
con.setRequestProperty("User-Agent", "Mozilla/5.0");
con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
// set json data
String json = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";
con.setDoOutput(true);
DataOutputStream wr = new DataOutputStream(con.getOutputStream());
wr.writeBytes(json);
wr.flush();
wr.close();
int responseCode = con.getResponseCode();
System.out.println("\nSending 'POST' request to URL : " + url);
System.out.println("Post parameters : " + json);
System.out.println("Response Code : " + responseCode);
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
// print result
System.out.println(response.toString());
}
}
2、将四个16进制数转换为一个32位的二进制数，可以使用Java中的位运算符来实现。以下是一个示例代码：
String hexString = "00000001";
int binary = Integer.parseInt(hexString, 16);
System.out.println(Integer.toBinaryString(binary));
3、 将一个32位的二进制数转换为一个十进制数，可以使用Java中的Integer类来实现。以下是一个示例代码：
String binaryString = "00000000000000000000000000000001";
int decimal = Integer.parseInt(binaryString, 2);
System.out.println(decimal);
4、 将一个十进制数转换为四个16进制数字，可以使用Java中的Integer类和String.format()方法来实现。以下是一个示例代码：
int decimal = 17;
String hexString = String.format("%08X", decimal);
System.out.println(hexString);
主要是通过 Integer 的方法处理, 还有 多数清空都是自己写一些工具方法
public class Test01 {
public static void main(String[] args) {
// 原始的4个16进制数据
byte[] bytes0 = new byte[]{0x00, 0x00, 0x01, 0x01};
ByteBuffer bufferShort0 = ByteBuffer.wrap(bytes0);
System.out.println("16进制字节转换成整数 : " + bufferShort0.getInt());
// 二进制表示
byte[] bytes1 = new byte[]{0b0000_0000, 0b0000_0000, 0b0000_0000, 0b0001_0001};
ByteBuffer bufferShort1 = ByteBuffer.wrap(bytes1);
System.out.println("2进制字节转换成整数 : " + bufferShort1.getInt());
byte[] bytes2 = intToBytes(66);
System.out.println("字节为: " + byteToHex(bytes2,true));
ByteBuffer bufferShort2 = ByteBuffer.wrap(bytes2);
System.out.println("转换成整数 : " + bufferShort2.getInt());
}
/**
* 将int数值转换为占四个字节的byte数组，
*
* @param value 要转换的int值
*
* @return byte数组
*/
private static byte[] intToBytes(int value) {
byte[] src = new byte[4];
src[3] = (byte) ((value >> 0) & 0xFF);
src[2] = (byte) ((value >> 8) & 0xFF);
src[1] = (byte) ((value >> 16) & 0xFF);
src[0] = (byte) ((value >> 24) & 0xFF);
return src;
}
/**
* 将字节翻译成16位字符串
*
* @param bytes 字节组
* @param b 是否补0
* @return
*/
private static String byteToHex(byte[] bytes, boolean b) {
String strHex = "";
StringBuilder sb = new StringBuilder("");
for (int n = 0; n < bytes.length; n++) {
strHex = Integer.toHexString(bytes[n] & 0xFF);
sb.append((strHex.length() == 1) ? "0" + strHex : strHex); // 每个字节由两个字符表示，位数不够，高位补0
sb.append(b ? " " : "");
}
return sb.toString().trim();
}
}
```
不考虑性能,从可读性的角度来写的话,可以参考下
public class Test2 {
@Test
public void test() {
decode(encode(1));
decode(encode(17));
}
private Integer decode(String result) {
final String binaryStr = IntStream.range(0, 4)
.mapToObj(item -> result.substring(item * 2, item * 2 + 2))
.map(item -> Integer.parseInt(item, 16))
.map(Integer::toBinaryString)
.map(item -> StringUtils.leftPad(item, 4, "0"))
.collect(Collectors.joining());
final Integer resultInt = Integer.parseInt(binaryStr, 2);
System.out.println(resultInt);
return resultInt;
}
private String encode(Integer i) {
final String binaryStr = StringUtils.leftPad(Integer.toBinaryString(i), 16, '0');
System.out.println(binaryStr);
final String hexStr = IntStream.range(0, 4)
.mapToObj(item -> binaryStr.substring(item * 4, item * 4 + 4))
.map(item -> StringUtils.leftPad(Integer.toHexString(Integer.parseInt(item)), 2, '0'))
.collect(Collectors.joining());
System.out.println(hexStr);
return hexStr;
}
}
- 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/691656
- 除此之外, 这篇博客: Java程序员必备-数据结构与算法之快速排序（一）中的 OK，现在3已经归位。接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。对序列“2 1”以2为基准数进行调整，处理完毕之后的序列为“1 2”，到此2已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下： 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
1 2 3 4 5 6 9 7 10 8
在Java中，您可以使用Integer类提供的方法来实现16进制和二进制之间的转换。下面是一个示例代码，展示了如何将4个16进制数转换为32位的二进制数，并将其转换为十进制数：
public class HexToBinary {
public static void main(String[] args) {
String[] hexNumbers = {"00", "00", "00", "01"};
// 将4个16进制数合并为一个字符串
String hexString = String.join("", hexNumbers);
// 将16进制转换为32位的二进制字符串
String binaryString = Integer.toBinaryString(Integer.parseInt(hexString, 16));
binaryString = String.format("%32s", binaryString).replace(" ", "0");
System.out.println("32位的二进制数：" + binaryString);
// 将二进制转换为十进制数
int decimalNumber = Integer.parseInt(binaryString, 2);
System.out.println("十进制数：" + decimalNumber);
}
}
运行以上代码，输出结果为：
32位的二进制数：00000000000000000000000000000001
十进制数：1
您可以根据需要修改hexNumbers数组中的16进制数来进行测试。
反向操作，即将十进制数转换为32位的二进制数再转换为四个16进制数字，可以使用相同的逻辑进行处理。以下是一个示例代码：
public class DecimalToHex {
public static void main(String[] args) {
int decimalNumber = 17;
// 将十进制转换为32位的二进制字符串
String binaryString = String.format("%32s", Integer.toBinaryString(decimalNumber)).replace(" ", "0");
System.out.println("32位的二进制数：" + binaryString);
// 将二进制转换为四个16进制数字
String[] hexNumbers = new String[4];
for (int i = 0; i < 4; i++) {
int startIndex = i * 8;
int endIndex = startIndex + 8;
String subBinaryString = binaryString.substring(startIndex, endIndex);
hexNumbers[i] = Integer.toHexString(Integer.parseInt(subBinaryString, 2));
}
System.out.println("四个16进制数：" + String.join(", ", hexNumbers));
}
}
运行以上代码，输出结果为：
32位的二进制数：00000000000000000000000000010001
四个16进制数：00, 00, 01, 01
同样地，您可以根据需要修改decimalNumber变量来进行测试。
希望这可以帮助到您！如果还有任何问题，请随时提问。
java中十六进制转十进制，可以使用Integer类的parseInt()方法直接转换，也可以自己写一个转换函数。
一、 Integer.parseInt()
十六进制转十进制，简单的方法就是使用Integer.parseInt()方法进制转换，一步到位。
1.如果输入的是不带0x表示的十六进制数，直接转换即可。
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine())
{
String str = sc.nextLine();
int x=Integer.parseInt(str,16);
System.out.println(x);
}
2.如果输入的是带有0x标识的十六进制数，需要截去前面两位标识。
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine())
{
String str = sc.nextLine();
int x=Integer.parseInt(str.substring(2),16);
System.out.println(x);
}
同理： 十进制转二进制，八进制，十六进制，可以直接使用Integer类提供的方法直接转换，分别是toBinaryString()，toOctalString()，toHexString()方法
在Java中，你可以使用位运算符来将4个16进制数转换为一个32位的二进制数。具体步骤如下：
- 将每个16进制数转换为一个8位的二进制数，可以使用Java中的Integer类的静态方法toBinaryString()来实现。
例如，对于16进制数0xFF，可以使用以下代码将其转换为一个8位的二进制数：String binary = Integer.toBinaryString(0xFF); - 将这4个8位的二进制数合并成一个32位的二进制数。可以使用位运算符和位移操作来实现。
例如，假设4个16进制数分别为a、b、c、d，则可以使用以下代码将它们合并为一个32位的二进制数：int result = (a << 24) | (b << 16) | (c << 8) | d; - 最后，将32位的二进制数转换为十进制数。可以使用Java中的Integer类的静态方法parseInt()来实现。
例如，可以使用以下代码将32位的二进制数转换为十进制数：int decimal = Integer.parseInt(Integer.toString(result, 10));
综合以上步骤，可以使用以下代码将4个16进制数转换为一个十进制数：
public static int convertHexToDecimal(String hexString) {
int a = Integer.parseInt(hexString.substring(0, 2), 16);
int b = Integer.parseInt(hexString.substring(2, 4), 16);
int c = Integer.parseInt(hexString.substring(4, 6), 16);
int d = Integer.parseInt(hexString.substring(6, 8), 16);
int result = (a << 24) | (b << 16) | (c << 8) | d;
int decimal = Integer.parseInt(Integer.toString(result, 10));
return decimal;
}
其中，参数hexString表示4个16进制数组成的字符串，例如"FFAABBCC"。函数返回一个整数，表示转换后的十进制数。
public class HexToBinToDecimal {
// 16进制到10进制的正向转换
public int hexToDecimal(String hex) {
int decimal = 0;
for (int i = 0; i < hex.length(); i++) {
char hexChar = hex.charAt(i);
int power = hex.length() - 1 - i;
int placeValue = Integer.parseInt(String.valueOf(hexChar), 16);
decimal += placeValue * Math.pow(16, power);
}
return decimal;
}
// 16进制到32位二进制的正向转换
public String hexToBin(String hex) {
String binary = Integer.toBinaryString(hexToDecimal(hex));
StringBuilder builder = new StringBuilder(binary);
while (builder.length() < 32) {
builder.insert(0, '0');
}
return builder.toString();
}
// 10进制到32位二进制的反向转换
public String decimalToBin(int decimal) {
return String.format("%32s", Integer.toBinaryString(decimal)).replace(' ', '0');
}
// 32位二进制到16进制的反向转换
public String binToHex(String binary) {
return Integer.toHexString(Integer.parseInt(binary, 2));
}
}