Java 字节与进制转换

已于 2022-08-22 14:17:02 修改
阅读量1.6k 收藏 7
点赞数 1
分类专栏： Java 文章标签： java 字节 二进制 16进制
于 2022-08-22 14:15:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013066244/article/details/126462975
版权

环境

Java：1.8+

前言

最近研究解析数据报文，总结了一些，经过实践且高效的方法；

代码


import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author yutao
 * @version $Id: ByteUtils.java, v 0.1 2022-07-05 15:26 yutao Exp $$
 */
public class ByteUtils {

    private static final Map<String, String> DIGIT_MAP = new HashMap<>();
    static {
        DIGIT_MAP.put("0","0000");
        DIGIT_MAP.put("1","0001");
        DIGIT_MAP.put("2","0010");
        DIGIT_MAP.put("3","0011");
        DIGIT_MAP.put("4","0100");
        DIGIT_MAP.put("5","0101");
        DIGIT_MAP.put("6","0110");
        DIGIT_MAP.put("7","0111");
        DIGIT_MAP.put("8","1000");
        DIGIT_MAP.put("9","1001");
        DIGIT_MAP.put("a","1010");
        DIGIT_MAP.put("b","1011");
        DIGIT_MAP.put("c","1100");
        DIGIT_MAP.put("d","1101");
        DIGIT_MAP.put("e","1110");
        DIGIT_MAP.put("f","1111");
    }

    private static final char[] HEX_DIGITS = "0123456789abcdef".toCharArray();

    /**
     * 16进制转二进制
     * @param hex
     * @return
     */
    public static String hexToBin(String hex) {
        char[] hexChar = hex.toCharArray();
        StringBuilder binaryStr = new StringBuilder();
        for (char h : hexChar) {
            binaryStr.append(DIGIT_MAP.get(String.valueOf(h)));
        }
        return binaryStr.toString();
    }

    /**
     * 将16进制转换为二进制
     *
     * @param hexString
     * @return
     */
    public static String hexToBinaryString(String hexString) {
        int len = hexString.length() * 4;
        //16进制转10进制
        BigInteger sint = new BigInteger(hexString, 16);
        //10进制转2进制
        String result = sint.toString(2);
        if(result.length() < len){
            int diff = len - result.length();
            String pad ="";
            for(int i = 0; i < diff; ++i){
                pad = pad.concat("0");
            }
            result = pad.concat(result);
        }
        //字符串反转
//        return new StringBuilder(result).reverse().toString();
        return result;
    }

    /**
     * 十六进制转字节数组
     * @param hexStr
     * @return
     */
    public static byte[] hexToBytes(String hexStr) {
        hexStr = hexStr.toLowerCase();
        int length = hexStr.length() / 2;
        char[] hexChars = hexStr.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    /**
     * Convert char to byte
     * @param c char
     * @return byte
     */
    private static byte charToByte(char c) {
        return (byte) "0123456789abcdef".indexOf(c);
    }

    /**
     * 字节数组转16进制
     * @param data
     * @return
     */
    public static String byteToHex(byte[] data) {
        char[] chars = new char[data.length * 2];
        for (int i = 0; i < data.length; i++) {
            chars[i * 2] = HEX_DIGITS[(data[i] >> 4) & 0xf];
            chars[i * 2 + 1] = HEX_DIGITS[data[i] & 0xf];
        }
        return new String(chars);
    }

    /**
     * 字节数组 转 二进制
     * @param bytes 高位 到 低位
     * @return
     */
    public static String byteToBinStr(byte[] bytes) {
        int len = bytes.length * 8;
        StringBuilder s = new StringBuilder(new BigInteger(bytes).toString(2));
//        StringBuilder s = new StringBuilder(new BigInteger(1, bytes).toString(2));
        int diff = len - s.length();
        for (int i = 0; i < diff; i++) {
            s.insert(0, "0");
        }
        return s.toString();
    }

    /**
     * 字节数组 转 二进制字符串
     * @param bytes 高位 到 低位
     * @return
     */
    public static String byteToBinStr2(byte[] bytes) {
        StringBuilder s1 = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            s1.append(Long.toBinaryString((bytes[i] & 0xFF) + 0x100).substring(1));
        }
        return s1.toString();
    }

    /**
     * int 转 byte数组
     * @param n
     * @return
     */
    public static byte[] intToByte(int n) {
        byte[] b = new byte[4];
        b[0] = (byte) (n & 0xff);
        b[1] = (byte) (n >> 8 & 0xff);
        b[2] = (byte) (n >> 16 & 0xff);
        b[3] = (byte) (n >> 24 & 0xff);
        return b;
    }

    /**
     * long 转 byte数组
     * 最低位到最高位，暂时别用，因为byteToLong需要高位到低位。
     * @param n
     * @return
     */
    @Deprecated
    public static byte[] longToByte(long n) {
        byte[] b = new byte[8];
        b[0] = (byte) (n & 0xff);
        b[1] = (byte) (n >>> 8 & 0xff);
        b[2] = (byte) (n >>> 16 & 0xff);
        b[3] = (byte) (n >>> 24 & 0xff);
        b[4] = (byte) (n >>> 32 & 0xff);
        b[5] = (byte) (n >>> 40 & 0xff);
        b[6] = (byte) (n >>> 48 & 0xff);
        b[7] = (byte) (n >>> 56 & 0xff);
        return b;
    }

    /**
     * long 转 byte数组
     * 最高位到最低位
     * @param s
     * @return
     */
    public static byte[] longToByteArray(long s) {
        byte[] targets = new byte[8];
        for (int i = 0; i < 8; i++) {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * byte数组转换为int整数
     *
     * @param bytes byte数组 期望 高位 到 低位
     * @return int整数
     */
    public static int byteToInt(byte[] bytes) {
        if (bytes == null || bytes.length > 4) {
            throw new RuntimeException("byte数组不能为null且长度不能超过4");
        }
        int length = bytes.length;
        int r = 0;
        for (int i = 0; i < length; i++) {
            //左移 8 位
            r = r | (bytes[i] & 0xff) << 8 * (length - 1 - i);
        }
        return r;
    }

    /**
     *
     * 遇到{-25, -15, 51, -90}：值3891344294超过int的上限；这时就需要改用long
     * 之所以要强转，因为Java默认在对byte进行移位操作前会转换为int类型
     * @param bytes 期望的字节数组是 高位 到 低位
     * @return
     */
    public static long byteToLong(byte[] bytes) {
        if (bytes == null || bytes.length > 8) {
            throw new RuntimeException("byte数组不能为null且长度不能超过4");
        }
        int length = bytes.length;
        long r = 0;
        for (int i = 0; i < length; i++) {
            //左移 8 位
            r = r | ((long) bytes[i] & 0xff) << 8 * (length - 1 - i);
        }
        return r;
    }

    public static void main(String[] args) {
        /*byte[] aa = new byte[]{-25, -15, 51, -90};
        System.out.println(byteToHex(aa));
        System.out.println((aa[0] & 0xff) << 8 * 3 | (aa[1] & 0xff) << 8*2 | (aa[2] & 0xff) << 8 | (aa[3] & 0xff));
        System.out.println(byteToInt(aa));
        System.out.println(byteToLong(aa));*/

        System.out.println(byteToBinStr(new byte[]{-128}));
        System.out.println(byteToBinStr2(new byte[]{-128}));
    }

    /**
     * 获取指定的字节数组
     * @param bytes
     * @param len
     * @return
     */
    public static byte[] getByte(byte[] bytes, int offset, int len) {
        byte[] newB = new byte[len];
        System.arraycopy(bytes, offset, newB, 0, newB.length);
        return newB;
    }

    /**
     * 获取指定的字节数组
     * @param bytes
     * @param offset
     * @return
     */
    public static byte[] getByte(byte[] bytes, int offset) {
        int i = bytes.length - offset;
        if (i < 0) {
            return new byte[0];
        }
        byte[] newB = new byte[i];
        System.arraycopy(bytes, offset, newB, 0, newB.length);
        return newB;
    }

    /**
     * 二进制转10进制
     *
     * @param
     * @return
     */
    public static int binaryToInt(String binaryStr) {
//        BigInteger sint = new BigInteger(binaryStr, 2);
//        return sint.intValue();
        return Integer.parseInt(binaryStr, 2);
    }

    /**
     * 二进制转10进制
     * @param binaryStr
     * @return
     */
    public static long binaryToLong(String binaryStr) {
        return Long.parseLong(binaryStr, 2);
    }

}

下面说明下容易出现，但是网上又千篇一律推荐的问题：

字节数组 转 二进制字符串

方法一：强烈推荐

/**
 * 字节数组 转 二进制字符串
 * @param bytes 高位 到 低位
 * @return
 */
public static String byteToBinStr2(byte[] bytes) {
    StringBuilder s1 = new StringBuilder();
    for (int i = 0; i < bytes.length; i++) {
        s1.append(Long.toBinaryString((bytes[i] & 0xFF) + 0x100).substring(1));
    }
    return s1.toString();
}

Long.toBinaryString((bytes[i] & 0xFF) + 0x100).substring(1)的原理是，字节是8位，+0x100即256，那就是9位（二进制），也就是每次用9位来转换。然后将转换后的字符串，截取到最高位（加上去的256），这样就得到了8位的二进制。

如果不这样做的话，上面的方法Long.toBinaryString()，1转为二进制还是1，而不是00000001(期望是这个)。

方法二：一般推荐

注意下面👇🏻：new BigInteger(1, bytes) 这里重点注意，指定了符号位

/**
 * 字节数组 转 二进制
 * @param bytes 高位 到 低位
 * @return
 */
public static String byteToBinStr(byte[] bytes) {
    int len = bytes.length * 8;
    //new BigInteger(1, bytes) 这里重点注意，指定了符号位
    StringBuilder s = new StringBuilder(new BigInteger(1, bytes).toString(2));
    int diff = len - s.length();
    for (int i = 0; i < diff; i++) {
        s.insert(0, "0");
    }
    return s.toString();
}

方法2的基础上不指定符号位

变成如下：

//网上千篇一律是这种写法，但是是错误的。
StringBuilder s = new StringBuilder(new BigInteger(bytes).toString(2));

如果不指定符号位，那么在解析-128时，会解析为负数：

在这里插入图片描述

在这里插入图片描述
所以这里：
强烈建议使用方法一；
强烈建议使用方法一；
强烈建议使用方法一；

参考地址：

How to convert a byte to its binary string representation

Java字节码转换工具—Retrotranslator
03-04
Retrotranslator的网站位于http: //sourceforge.net/projects/retrotranslator，可以在这个网站下载相关的运行程序以及源码，该工具可以实现大多java15的功能转换为java14环境下运行。我测试了一个前端时间开发的一个网络通讯工具，其中用到了很多java15的特性，例如泛形，增强循环，静态引入等功能，以及jdk15独有的类文件，例如StringBuilder等。通过该工具进行转换，可以完美的运行在java14环境下面。当 然，该工具也不是完全可以兼容jdk15的新功能，在其网站上面也谈及了不能够实现的部分，可以作为参考。
把byte转化成2进制字符串
GEOLO的专栏
01-25 1万+
public class ByteToBinary { /** * 把byte数组转化成2进制字符串 * @param bArr * @return */ public String getBinaryStrFromByteArr(byte[] bArr){ String result =""; for(byte b:bArr ){ result += getBinaryStrFromByte(b); } return result; }
java byte转二进制字符串
u011119684的博客
03-27 1万+
今天看同事的代码，看到应用巧妙的地方，故记录下来。 byte类型转二进制字符串的代码，废话不说，先上代码 代码： byte tByte = -2; String tString = Integer.toBinaryString((tByte & 0xFF) + 0x100).substring(1); System.out.println("tString:" + tString);...
java字节码转换_掌握Java字节码(转)
weixin_35717696的博客
02-12 1186
Java是一门设计为运行于虚拟机之上的编程语言，因此它需要一次编译，处处运行(当然也是一次编写，处处测试)。因此，安装到你系统上的JVM是原生的程序，而运行在它之上的代码是平台无关的。Java字节码就是你写的源代码的中间表现形式，也就是你的代码编译后的产物。你的class文件就是字节码。简单点说，字节码就是JVM使用的代码集，它在运行时可能会被JIT编译器编译成本地代码。你玩过汇编语言或者机器代码...
(学习笔记) Java byte[]转二进制字符串,十六进制字符串的相互转换
热门推荐
Code菜鸟的专栏
09-20 1万+
public class HexConver { public static void main(String[] args) { String content = "这是一个测试"; System.out.println("原字符串："+content); String hex2Str = conver2HexStr(content.getBytes()); System.o
Java实现的进制转换工具类完整示例
08-27
Java实现的进制转换工具类完整示例 Java实现的进制转换工具类是Java语言中的一种常用工具类，用于实现各种进制之间的转换操作，如二进制、十六进制、字符串、数组等。该工具类主要提供了将字节数组转换为十六进制...
java基础，进制转换.pdf
07-25
从提供的文件信息中，我们可以提取以下知识点： 1. Java程序的运行环境...通过这些详细知识点，我们可以充分理解Java基础中的数据类型、进制转换、以及与之相关的概念。这对于深入学习Java编程语言是非常有帮助的。
Java 中二进制转换成十六进制的两种实现方法
08-30
首先，我们需要获取每个字节的高四位和低四位，然后将它们转换为16进制数字，并将这些数字转换为相应的字符。 ```java private static String toHex(byte[] result) { StringBuffer sb = new StringBuffer(result....
java-16进制4字节转Float
04-16
在Java编程语言中，将16进制的4字节数据转换为浮点数是常见的数据处理操作，尤其是在与硬件设备交互或者进行低级通信时。这个过程涉及到字节顺序的理解，以及Java中的数据类型转换。以下是关于这个主题的详细解释。 ...
Java进制转换，十六进制、十进制、二进制
最新发布
10-18
Java进制转换 正整数的十进制转换二进制 将一个十进制数除以二，得到的商再除以二，依此类推直到商等于一或零时为止，倒取除得的余数，即换算为二进制数的结果。只需记住要点：除二取余，倒序排列。 由于计算机...
java中进制转换（二进制，十进制，十六进制）及字节数组与十六进制的转换
05-06
最近由于工作上的需要，遇到进制转换的问题。涉及到的进制主要是 十进制，十六进制，二进制中间的转换。还包括了一个字节数组 与十六进制字符串的互相转换。估计遇到蓝牙通信的朋友，应该用的上。
netty 在java中的字节码转换
03-26
netty通信时经常和底层数据交互，C语言和java的数据类型和范围不同，通信时需要转化或兼容，附件为字节码、进制常用的转换类。
java中如何将byte数组转成二进制大对象
weixin_35755562的博客
01-18 1864
在 Java 中可以使用 ByteArrayInputStream 类将 byte 数组转换成二进制对象。例如： byte[] byteArray= ...; ByteArrayInputStream bais = new ByteArrayInputStream(byteArray); ObjectInputStream ois = new ObjectInputStream(bais); Ob...
转 Java字节码 wiki
学而不思则罔 思而不学则殆
11-28 356
https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings From Wikipedia, the free encyclopedia Jump to navigationJump to search Main article: Java bytecode This is a list of the instructio...
一个字节转换成二进制的方法
sam_jet的专栏
04-10 3244
Byte a=byte.Parse(this.TextBox1.Text); this.TextBox2.Text=Convert.ToString(a,2);//第一个参数是字节类型，第二个参数是转换成二进制
Java –如何将字节转换为二进制字符串
一名可爱的技术搬运工
05-28 5939
在Java中，我们可以使用Integer.toBinaryString(int)将字节转换为代表二进制字符串。 查看Integer.toBinaryString(int)方法签名，它将一个整数作为参数并返回一个String。 整数.java public final class Integer extends Number implements Comparable&lt...
java byte数组转换成0和1的二进制
weixin_42599558的博客
01-10 988
可以使用以下代码将Java中的byte数组转换为0和1的二进制字符串： byte[] bytes = ...; StringBuilder binary = new StringBuilder(); for (byte b : bytes) { int val = b; for (int i = 0; i < 8; i++) { binary.app...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

山鬼谣me

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值