Byte数组相关工具类

左手的ㄟ右手 2024-04-07 13:40 146阅读 0赞

byte 转换基本数据类型

  1. kotlin 中可以直接调用 toByte , toInt 之类的函数直接获取。
  2. java 中需要自己获取，获取方式会放到工具类中。

大端和小端

下面是对连个模式的简单解释。

  • 大端模式：是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于 把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
  • 小端模式：是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中。

更详细的可以参考这篇博客，详解大端模式和小端模式。

1、函数列表

  1. int2BytesBig        :将int转为高字节在前，低字节在后的byte数组（大端）
  2. int2BytesLittle        :将int转为低字节在前，高字节在后的byte数组（小端）
  3. bytes2IntLittle        :byte数组到int的转换(小端)
  4. bytes2IntBig        :byte数组到int的转换(大端)
  6. short2BytesBig        :将short转为高字节在前，低字节在后的byte数组（大端）
  7. short2BytesLittle    :将short转为低字节在前，高字节在后的byte数组(小端)
  8. bytes2ShortLittle    :读取小端byte数组为short
  9. bytes2ShortBig        :读取大端byte数组为short
  11. long2BytesBig        :long类型转byte[] (大端)
  12. long2BytesLittle    :long类型转byte[] (小端)
  13. bytes2LongLittle    :byte[]转long类型(小端)
  14. bytes2LongBig        :byte[]转long类型(大端)
  16. long2BytesBOS        :long类型转byte[] (大端),通过ByteArrayOutputStream实现
  17. bytes2LongBOS        :byte[]转long类型(大端),通过ByteArrayOutputStream实现
  18. long2BytesByteBuffer:long类型转byte[] (大端),通过ByteBuffer实现
  19. bytes2LongByteBuffer:byte[]转long类型(大端), 通过ByteBuffer实现
  21. bytes2Long            :将字节数组转为long,支持大小端
  22. bytes2LongByteBuffer:将字节数组转为long,支持大小端
  24. int2Byte            :int 转 byte
  25. byte2Int            :byte 转 int,解决java中byte输出可能为负数的问题
  26. object2Bytes        :将 object --> byte 数组
  27. bytes2Object        :数组转对象
  29. bytesEquals            :两个byte[]是否相同
  30. subBytes            :截取byte[]
  31. bytesMerger            :拼接byte[] 和 byte[]
  32. bytesMerger            :拼接byte 和 byte[]
  33. bytesMerger            :拼接byte[] 和 byte
  34. bytesMerger            :拼接三个数组
  36. byte2Hex      :byte转Hex 16 进制字符串
  37. bytes2Hex     :byte[]转Hex
  38. bytes2Hex2      :字节数组转为16进制字符串
  39. hex2Byte      :Hex转byte,hex只能含两个字符，如果是一个字符byte高位会是0
  40. hex2Bytes     :Hex转byte[]，两种情况，Hex长度为奇数最后一个字符会被舍去
  41. str2HexStr      :字符串转为16进制字符串，推荐
  42. hexStr2Str      :16进制直接转换成为字符串(无需Unicode解码)，推荐
  43. string2Unicode    :字符串转换unicode
  44. unicode2String    :unicode 转字符串

2、工具类

  1. public class BytesUtils {
  3.     /**
  4.      * 将int转为高字节在前，低字节在后的byte数组（大端）
  5.      *
  6.      * @param n int
  7.      * @return byte[]
  8.      */
  9.     public static byte[] int2BytesBig(int n) {
  10.         byte[] b = new byte[4];
  11.         b[3] = (byte) (n & 0xff);
  12.         b[2] = (byte) (n >> 8 & 0xff);
  13.         b[1] = (byte) (n >> 16 & 0xff);
  14.         b[0] = (byte) (n >> 24 & 0xff);
  15.         return b;
  16.     }
  18.     /**
  19.      * 将int转为低字节在前，高字节在后的byte数组（小端）
  20.      *
  21.      * @param n int
  22.      * @return byte[]
  23.      */
  24.     public static byte[] int2BytesLittle(int n) {
  25.         byte[] b = new byte[4];
  26.         b[0] = (byte) (n & 0xff);
  27.         b[1] = (byte) (n >> 8 & 0xff);
  28.         b[2] = (byte) (n >> 16 & 0xff);
  29.         b[3] = (byte) (n >> 24 & 0xff);
  30.         return b;
  31.     }
  33.     /**
  34.      * byte数组到int的转换(小端)
  35.      *
  36.      * @param bytes
  37.      * @return
  38.      */
  39.     public static int bytes2IntLittle(byte[] bytes) {
  40.         int int1 = bytes[0] & 0xff;
  41.         int int2 = (bytes[1] & 0xff) << 8;
  42.         int int3 = (bytes[2] & 0xff) << 16;
  43.         int int4 = (bytes[3] & 0xff) << 24;
  45.         return int1 | int2 | int3 | int4;
  46.     }
  48.     /**
  49.      * byte数组到int的转换(大端)
  50.      *
  51.      * @param bytes
  52.      * @return
  53.      */
  54.     public static int bytes2IntBig(byte[] bytes) {
  55.         int int1 = bytes[3] & 0xff;
  56.         int int2 = (bytes[2] & 0xff) << 8;
  57.         int int3 = (bytes[1] & 0xff) << 16;
  58.         int int4 = (bytes[0] & 0xff) << 24;
  60.         return int1 | int2 | int3 | int4;
  61.     }
  63.     /**
  64.      * 将short转为高字节在前，低字节在后的byte数组（大端）
  65.      *
  66.      * @param n short
  67.      * @return byte[]
  68.      */
  69.     public static byte[] short2BytesBig(short n) {
  70.         byte[] b = new byte[2];
  71.         b[1] = (byte) (n & 0xff);
  72.         b[0] = (byte) (n >> 8 & 0xff);
  73.         return b;
  74.     }
  76.     /**
  77.      * 将short转为低字节在前，高字节在后的byte数组(小端)
  78.      *
  79.      * @param n short
  80.      * @return byte[]
  81.      */
  82.     public static byte[] short2BytesLittle(short n) {
  83.         byte[] b = new byte[2];
  84.         b[0] = (byte) (n & 0xff);
  85.         b[1] = (byte) (n >> 8 & 0xff);
  86.         return b;
  87.     }
  89.     /**
  90.      * 读取小端byte数组为short
  91.      *
  92.      * @param b
  93.      * @return
  94.      */
  95.     public static short bytes2ShortLittle(byte[] b) {
  96.         return (short) (((b[1] << 8) | b[0] & 0xff));
  97.     }
  99.     /**
  100.      * 读取大端byte数组为short
  101.      *
  102.      * @param b
  103.      * @return
  104.      */
  105.     public static short bytes2ShortBig(byte[] b) {
  106.         return (short) (((b[0] << 8) | b[1] & 0xff));
  107.     }
  109.     /**
  110.      * long类型转byte[] (大端)
  111.      *
  112.      * @param n
  113.      * @return
  114.      */
  115.     public static byte[] long2BytesBig(long n) {
  116.         byte[] b = new byte[8];
  117.         b[7] = (byte) (n & 0xff);
  118.         b[6] = (byte) (n >> 8 & 0xff);
  119.         b[5] = (byte) (n >> 16 & 0xff);
  120.         b[4] = (byte) (n >> 24 & 0xff);
  121.         b[3] = (byte) (n >> 32 & 0xff);
  122.         b[2] = (byte) (n >> 40 & 0xff);
  123.         b[1] = (byte) (n >> 48 & 0xff);
  124.         b[0] = (byte) (n >> 56 & 0xff);
  125.         return b;
  126.     }
  128.     /**
  129.      * long类型转byte[] (小端)
  130.      *
  131.      * @param n
  132.      * @return
  133.      */
  134.     public static byte[] long2BytesLittle(long n) {
  135.         byte[] b = new byte[8];
  136.         b[0] = (byte) (n & 0xff);
  137.         b[1] = (byte) (n >> 8 & 0xff);
  138.         b[2] = (byte) (n >> 16 & 0xff);
  139.         b[3] = (byte) (n >> 24 & 0xff);
  140.         b[4] = (byte) (n >> 32 & 0xff);
  141.         b[5] = (byte) (n >> 40 & 0xff);
  142.         b[6] = (byte) (n >> 48 & 0xff);
  143.         b[7] = (byte) (n >> 56 & 0xff);
  144.         return b;
  145.     }
  147.     /**
  148.      * byte[]转long类型(小端)
  149.      *
  150.      * @param array
  151.      * @return
  152.      */
  153.     public static long bytes2LongLittle(byte[] array) {
  154.         return ((((long) array[0] & 0xff))
  155.                 | (((long) array[1] & 0xff) << 8)
  156.                 | (((long) array[2] & 0xff) << 16)
  157.                 | (((long) array[3] & 0xff) << 24)
  158.                 | (((long) array[4] & 0xff) << 32)
  159.                 | (((long) array[5] & 0xff) << 40)
  160.                 | (((long) array[6] & 0xff) << 48)
  161.                 | (((long) array[7] & 0xff) << 56));
  162.     }
  164.     /**
  165.      * byte[]转long类型(大端)
  166.      *
  167.      * @param array
  168.      * @return
  169.      */
  170.     public static long bytes2LongBig(byte[] array) {
  171.         return ((((long) array[0] & 0xff) << 56)
  172.                 | (((long) array[1] & 0xff) << 48)
  173.                 | (((long) array[2] & 0xff) << 40)
  174.                 | (((long) array[3] & 0xff) << 32)
  175.                 | (((long) array[4] & 0xff) << 24)
  176.                 | (((long) array[5] & 0xff) << 16)
  177.                 | (((long) array[6] & 0xff) << 8)
  178.                 | (((long) array[7] & 0xff)));
  179.     }
  182.     /**
  183.      * long类型转byte[] (大端),通过ByteArrayOutputStream实现
  184.      *
  185.      * @param l
  186.      * @return
  187.      * @throws IOException
  188.      */
  189.     public static byte[] long2BytesBOS(long l) throws IOException {
  190.         ByteArrayOutputStream bao = new ByteArrayOutputStream();
  191.         DataOutputStream dos = new DataOutputStream(bao);
  192.         dos.writeLong(l);
  193.         byte[] buf = bao.toByteArray();
  194.         return buf;
  195.     }
  197.     /**
  198.      * byte[]转long类型(大端),通过ByteArrayOutputStream实现
  199.      *
  200.      * @param data
  201.      * @return
  202.      * @throws IOException
  203.      */
  204.     public long bytes2LongBOS(byte[] data) throws IOException {
  205.         ByteArrayInputStream bai = new ByteArrayInputStream(data);
  206.         DataInputStream dis = new DataInputStream(bai);
  207.         return dis.readLong();
  208.     }
  210.     /**
  211.      * long类型转byte[] (大端),通过ByteBuffer实现
  212.      *
  213.      * @param value
  214.      * @return
  215.      */
  216.     public static byte[] long2BytesByteBuffer(long value) {
  217.         return ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(value).array();
  218.     }
  220.     /**
  221.      * byte[]转long类型(大端), 通过ByteBuffer实现
  222.      *
  223.      * @param bytes
  224.      * @return
  225.      */
  226.     public static long bytes2LongByteBuffer(byte[] bytes) {
  227.         ByteBuffer buffer = ByteBuffer.allocate(8);
  228.         buffer.put(bytes, 0, bytes.length);
  229.         buffer.flip();
  230.         return buffer.getLong();
  231.     }
  233.     /**
  234.      * 将字节数组转为long<br>
  235.      * 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
  236.      *
  237.      * @param input        byte[]
  238.      * @param offset       起始偏移量 0
  239.      * @param littleEndian 输入数组是否小端模式
  240.      * @return
  241.      */
  242.     public static long bytes2Long(byte[] input, int offset, boolean littleEndian) {
  243.         long value = 0;
  244.         // 循环读取每个字节通过移位运算完成long的8个字节拼装
  245.         for (int count = 0; count < 8; ++count) {
  246.             int shift = (littleEndian ? count : (7 - count)) << 3;
  247.             value |= ((long) 0xff << shift) & ((long) input[offset + count] << shift);
  248.         }
  249.         return value;
  250.     }
  252.     /**
  253.      * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
  254.      *
  255.      * @param input        byte[]
  256.      * @param offset       0
  257.      * @param littleEndian 输入数组是否小端模式
  258.      * @return
  259.      */
  260.     public static long bytes2LongByteBuffer(byte[] input, int offset, boolean littleEndian) {
  261.         // 将byte[] 封装为 ByteBuffer
  262.         ByteBuffer buffer = ByteBuffer.wrap(input, offset, 8);
  263.         if (littleEndian) {
  264.             // ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
  265.             // ByteBuffer 默认为大端(BIG_ENDIAN)模式
  266.             buffer.order(ByteOrder.LITTLE_ENDIAN);
  267.         }
  268.         return buffer.getLong();
  269.     }
  271.     /**
  272.      * int 转 byte
  273.      *
  274.      * @param t
  275.      * @return
  276.      */
  277.     public static byte int2Byte(int t) {
  278.         return (byte) t;
  279.     }
  281.     /**
  282.      * byte 转 int,解决java中byte输出可能为负数的问题
  283.      *
  284.      * @param b
  285.      * @return
  286.      */
  287.     public static int byte2Int(byte b) {
  288.         return b & 0xFF;
  289.     }
  291.     /**
  292.      * 将 object --> byte 数组
  293.      *
  294.      * @param obj
  295.      * @return
  296.      */
  297.     public static byte[] object2Bytes(Object obj) {
  298.         byte[] bytes = null;
  299.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  300.         try {
  301.             ObjectOutputStream oos = new ObjectOutputStream(bos);
  302.             oos.writeObject(obj);
  303.             oos.flush();
  304.             bytes = bos.toByteArray();
  305.             oos.close();
  306.             bos.close();
  307.         } catch (IOException ex) {
  308.             ex.printStackTrace();
  309.         }
  310.         return bytes;
  311.     }
  313.     /**
  314.      * 数组转对象
  315.      *
  316.      * @param bytes
  317.      * @return
  318.      */
  319.     public Object bytes2Object(byte[] bytes) {
  320.         Object obj = null;
  321.         try {
  322.             ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
  323.             ObjectInputStream ois = new ObjectInputStream(bis);
  324.             obj = ois.readObject();
  325.             ois.close();
  326.             bis.close();
  327.         } catch (IOException | ClassNotFoundException ex) {
  328.             ex.printStackTrace();
  329.         }
  330.         return obj;
  331.     }
  333.     /**
  334.      * 两个byte[]是否相同
  335.      * @param data1
  336.      * @param data2
  337.      * @return
  338.      */
  339.     public static boolean bytesEquals(byte[] data1, byte[] data2) {
  340.         return Arrays.equals(data1, data2);
  341.     }
  343.     /**
  344.      * 截取byte[]
  345.      * @param data
  346.      * @param position
  347.      * @param length
  348.      * @return
  349.      */
  350.     public static byte[] subBytes(byte[] data, int position, int length) {
  351.         byte[] temp = new byte[length];
  352.         System.arraycopy(data, position, temp, 0, length);
  353.         return temp;
  354.     }
  355.     /**
  356.      * 拼接byte[] 和 byte[]
  357.      *
  358.      * @param bytes1
  359.      * @param bytes2
  360.      * @return
  361.      */
  362.     public static byte[] bytesMerger(byte[] bytes1, byte[] bytes2) {
  363.         byte[] bytes3 = new byte[bytes1.length + bytes2.length];
  364.         System.arraycopy(bytes1, 0, bytes3, 0, bytes1.length);
  365.         System.arraycopy(bytes2, 0, bytes3, bytes1.length, bytes2.length);
  366.         return bytes3;
  367.     }
  368.     /**
  369.      * 拼接byte 和 byte[]
  370.      *
  371.      * @param byte1
  372.      * @param bytes2
  373.      * @return
  374.      */
  375.     public static byte[] bytesMerger(byte byte1, byte[] bytes2) {
  376.         byte[] bytes3 = new byte[1 + bytes2.length];
  377.         bytes3[0] = byte1;
  378.         System.arraycopy(bytes2, 0, bytes3, 1, bytes2.length);
  379.         return bytes3;
  380.     }
  382.     /**
  383.      * 拼接byte[] 和 byte
  384.      *
  385.      * @param bytes1
  386.      * @param byte2
  387.      * @return
  388.      */
  389.     public static byte[] bytesMerger(byte[] bytes1, byte byte2) {
  390.         byte[] bytes3 = new byte[1 + bytes1.length];
  391.         System.arraycopy(bytes1, 0, bytes3, 0, bytes1.length);
  392.         bytes3[bytes3.length - 1] = byte2;
  393.         return bytes3;
  394.     }
  396.     /**
  397.      * 拼接三个数组
  398.      *
  399.      * @param bt1
  400.      * @param bt2
  401.      * @param bt3
  402.      * @return
  403.      */
  404.     public static byte[] bytesMerger(byte[] bt1, byte[] bt2, byte[] bt3) {
  405.         byte[] data = new byte[bt1.length + bt2.length + bt3.length];
  406.         System.arraycopy(bt1, 0, data, 0, bt1.length);
  407.         System.arraycopy(bt2, 0, data, bt1.length, bt2.length);
  408.         System.arraycopy(bt3, 0, data, bt1.length + bt2.length, bt3.length);
  409.         return data;
  410.     }
  412.   /**
  413.      * byte转Hex 16 进制字符串
  414.      */
  415.     public static String byte2Hex(byte b) {
  416.         String hex = Integer.toHexString(b & 0xFF);
  417.         if (hex.length() < 2) {
  418.             hex = "0" + hex;
  419.         }
  420.         return hex;
  421.     }
  423.     /**
  424.      * byte[]转Hex
  425.      */
  426.     public static String bytes2Hex(byte[] b) {
  427.         StringBuilder sb = new StringBuilder();
  428.         for (int i = 0; i < b.length; i++) {
  429.             String hex = Integer.toHexString(b[i] & 0xFF);
  430.             if (hex.length() < 2) {
  431.                 hex = "0" + hex;
  432.             }
  433.             sb.append(hex.toUpperCase());
  434.         }
  435.         return sb.toString();
  436.     }
  438.     /**
  439.      * 字节数组转为16进制字符串
  440.      */
  441.     public static String bytes2Hex2(byte[] bytes) {
  442.         String strHex = "";
  443.         StringBuilder stringBuilder = new StringBuilder();
  444.         for (int n = 0; n < bytes.length; n++) {
  445.             strHex = Integer.toHexString(bytes[n] & 0xFF);
  446.             stringBuilder.append((strHex.length() == 1) ? "0" + strHex : strHex);
  447.         }
  448.         return stringBuilder.toString().trim();
  449.     }
  451.     /**
  452.      * Hex转byte,hex只能含两个字符，如果是一个字符byte高位会是0
  453.      */
  454.     public static byte hex2Byte(String hex) {
  455.         return (byte) Integer.parseInt(hex, 16);
  456.     }
  458.     /**
  459.      * Hex转byte[]，两种情况，Hex长度为奇数最后一个字符会被舍去
  460.      */
  461.     public static byte[] hex2Bytes(String hex) {
  462.         if (hex.length() < 1) {
  463.             return null;
  464.         } else {
  465.             byte[] result = new byte[hex.length() / 2];
  466.             int j = 0;
  467.             for (int i = 0; i < hex.length(); i += 2) {
  468.                 result[j++] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
  469.             }
  470.             return result;
  471.         }
  472.     }
  474.     /**
  475.      * 字符串转为16进制字符串，推荐
  476.      */
  477.     public static String str2HexStr(String str) {
  478.         char[] chars = "0123456789ABCDEF".toCharArray();
  479.         StringBuilder sb = new StringBuilder("");
  480.         byte[] bs = str.getBytes();
  481.         int bit;
  482.         for (byte b : bs) {
  483.             bit = (b & 0x0f0) >> 4;
  484.             sb.append(chars[bit]);
  485.             bit = b & 0x0f;
  486.             sb.append(chars[bit]);
  487.         }
  488.         return sb.toString().trim();
  489.     }
  491.     /**
  492.      * 16进制直接转换成为字符串(无需Unicode解码)，推荐
  493.      *
  494.      * @param hexStr
  495.      * @return
  496.      */
  497.     public static String hexStr2Str(String hexStr) {
  498.         String str = "0123456789ABCDEF";
  499.         char[] hexs = hexStr.toCharArray();
  500.         byte[] bytes = new byte[hexStr.length() / 2];
  501.         int n;
  502.         for (int i = 0; i < bytes.length; i++) {
  503.             n = str.indexOf(hexs[2 * i]) * 16;
  504.             n += str.indexOf(hexs[2 * i + 1]);
  505.             bytes[i] = (byte) (n & 0xff);
  506.         }
  507.         return new String(bytes);
  508.     }
  510.     /**
  511.      * 字符串转换unicode
  512.      */
  513.     public static String string2Unicode(String string) {
  514.         StringBuilder unicode = new StringBuilder();
  515.         for (int i = 0; i < string.length(); i++) {
  516. // 取出每一个字符
  517.             char c = string.charAt(i);
  518.             // 转换为unicode
  519.             unicode.append("\u").append(Integer.toHexString(c));
  520.         }
  521.         return unicode.toString();
  522.     }
  524.     /**
  525.      * unicode 转字符串
  526.      */
  527.     public static String unicode2String(String unicode) {
  528.         StringBuilder string = new StringBuilder();
  529.         String[] hex = unicode.split("\\u");
  530.         for (int i = 1; i < hex.length; i++) {
  531.             // 转换出每一个代码点
  532.             int data = Integer.parseInt(hex[i], 16);
  533.             // 追加成string
  534.             string.append((char) data);
  535.         }
  536.         return string.toString();
  537.     }
  539. }

还有一种写法：

  1. /**
  2.  * <pre>
  3.  *     author : wushaohong
  4.  *     date   : 2020-05-01
  5.  *     desc   : 字节数组与基本数据类型的转换
  6.  *              byte、short、int、float、long、double、16进制字符串
  7.  *     version: 1.0
  8.  * </pre>
  9.  */
  11. public class ByteArrayUtil {
  13.     /**
  14.      * 字节数组转 short，小端
  15.      */
  16.     public static short byteArray2Short_Little_Endian(byte[] array) {
  18.         // 数组长度有误
  19.         if (array.length > 2) {
  20.             return 0;
  21.         }
  23.         short value = 0;
  24.         for (int i = 0; i < array.length; i++) {
  25.             // & 0xff，除去符号位干扰
  26.             value |= ((array[i] & 0xff) << (i * 8));
  27.         }
  28.         return value;
  29.     }
  31.     /**
  32.      * 字节数组转 short，大端
  33.      */
  34.     public static short byteArray2Short_Big_Endian(byte[] array) {
  36.         // 数组长度有误
  37.         if (array.length > 2) {
  38.             return 0;
  39.         }
  41.         short value = 0;
  42.         for (int i = 0; i < array.length ; i++) {
  43.             value |= ((array[i] & 0xff) << ((array.length - i - 1) * 8));
  44.         }
  45.         return value;
  46.     }
  48.     /**
  49.      * 字节数组转 int，小端
  50.      */
  51.     public static int byteArray2Int_Little_Endian(byte[] array) {
  53.         // 数组长度有误
  54.         if (array.length > 4) {
  55.             return 0;
  56.         }
  58.         int value = 0;
  59.         for (int i = 0; i < array.length; i++) {
  60.             value |= ((array[i] & 0xff) << (i * 8));
  62.         }
  63.         return value;
  64.     }
  66.     /**
  67.      * 字节数组转 int，大端
  68.      */
  69.     public static int byteArray2Int_Big_Endian(byte[] array) {
  71.         // 数组长度有误
  72.         if (array.length > 4) {
  73.             return 0;
  74.         }
  76.         int value = 0;
  77.         for (int i = 0; i < array.length ; i++) {
  78.             value |= ((array[i] & 0xff) << ((array.length - i - 1) * 8));
  79.         }
  80.         return value;
  81.     }
  83.     /**
  84.      * 字节数组转 float，小端
  85.      */
  86.     public static float byteArray2Float_Little_Endian(byte[] array) {
  88.         // 数组长度有误
  89.         if (array.length != 4) {
  90.             return 0;
  91.         }
  93.         return Float.intBitsToFloat(byteArray2Int_Little_Endian(array));
  94.     }
  96.     /**
  97.      * 字节数组转 float，大端
  98.      */
  99.     public static float byteArray2Float_Big_Endian(byte[] array) {
  101.         // 数组长度有误
  102.         if (array.length > 4) {
  103.             return 0;
  104.         }
  106.         return Float.intBitsToFloat(byteArray2Int_Big_Endian(array));
  107.     }
  109.     /**
  110.      * 字节数组转 long，小端
  111.      */
  112.     public static long byteArray2Long_Little_Endian(byte[] array) {
  114.         // 数组长度有误
  115.         if (array.length != 8) {
  116.             return 0;
  117.         }
  119.         long value = 0;
  120.         for (int i = 0; i < array.length ; i++) {
  121.             // 需要转long再位移，否则int丢失精度
  122.             value |= ((long)(array[i]& 0xff) << (i * 8));
  123.         }
  124.         return value;
  125.     }
  127.     /**
  128.      * 字节数组转 long，大端
  129.      */
  130.     public static long byteArray2Long_Big_Endian(byte[] array) {
  132.         // 数组长度有误
  133.         if (array.length != 8) {
  134.             return 0;
  135.         }
  137.         long value = 0;
  138.         for (int i = 0; i < array.length ; i++) {
  139.             value |= ((long)(array[i] & 0xff) << ((array.length - i - 1) * 8));
  140.         }
  141.         return value;
  142.     }
  144.     /**
  145.      * 字节数组转 double，小端
  146.      */
  147.     public static double byteArray2Double_Little_Endian(byte[] array) {
  149.         // 数组长度有误
  150.         if (array.length != 8) {
  151.             return 0;
  152.         }
  154.         return Double.longBitsToDouble(byteArray2Long_Little_Endian(array));
  155.     }
  157.     /**
  158.      * 字节数组转 double，大端
  159.      */
  160.     public static double byteArray2Double_Big_Endian(byte[] array) {
  162.         // 数组长度有误
  163.         if (array.length != 8) {
  164.             return 0;
  165.         }
  167.         return Double.longBitsToDouble(byteArray2Long_Big_Endian(array));
  168.     }
  170.     /**
  171.      * 字节数组转 HexString
  172.      */
  173.     public static String byteArray2HexString(byte[] array) {
  175.         StringBuilder builder = new StringBuilder();
  176.         for (byte b : array) {
  178.             String s = Integer.toHexString(b & 0xff);
  179.             if (s.length() < 2) {
  180.                 builder.append("0");
  181.             }
  182.             builder.append(s);
  183.         }
  185.         return builder.toString().toUpperCase();
  186.     }
  188.     //---------------------------------华丽的分割线-------------------------------------
  190.     /**
  191.      * short 转字节数组，小端
  192.      */
  193.     public static byte[] short2ByteArray_Little_Endian(short s) {
  195.         byte[] array = new byte[2];
  197.         for (int i = 0; i < array.length; i++) {
  198.             array[i] = (byte) (s >> (i * 8));
  199.         }
  200.         return array;
  201.     }
  203.     /**
  204.      * short 转字节数组，大端
  205.      */
  206.     public static byte[] short2ByteArray_Big_Endian(short s) {
  208.         byte[] array = new byte[2];
  210.         for (int i = 0; i < array.length; i++) {
  211.             array[array.length - 1 - i] = (byte) (s >> (i * 8));
  212.         }
  213.         return array;
  214.     }
  216.     /**
  217.      * int 转字节数组，小端
  218.      */
  219.     public static byte[] int2ByteArray_Little_Endian(int s) {
  221.         byte[] array = new byte[4];
  223.         for (int i = 0; i < array.length; i++) {
  224.             array[i] = (byte) (s >> (i * 8));
  225.         }
  226.         return array;
  227.     }
  229.     /**
  230.      * int 转字节数组，大端
  231.      */
  232.     public static byte[] int2ByteArray_Big_Endian(int s) {
  234.         byte[] array = new byte[4];
  236.         for (int i = 0; i < array.length; i++) {
  237.             array[array.length - 1 - i] = (byte) (s >> (i * 8));
  238.         }
  239.         return array;
  240.     }
  242.     /**
  243.      * float 转字节数组，小端
  244.      */
  245.     public static byte[] float2ByteArray_Little_Endian(float f) {
  247.         return int2ByteArray_Little_Endian(Float.floatToIntBits(f));
  248.     }
  250.     /**
  251.      * float 转字节数组，大端
  252.      */
  253.     public static byte[] float2ByteArray_Big_Endian(float f) {
  255.         return int2ByteArray_Big_Endian(Float.floatToIntBits(f));
  256.     }
  258.     /**
  259.      * long 转字节数组，小端
  260.      */
  261.     public static byte[] long2ByteArray_Little_Endian(long l) {
  263.         byte[] array = new byte[8];
  265.         for (int i = 0; i < array.length; i++) {
  266.             array[i] = (byte) (l >> (i * 8));
  267.         }
  268.         return array;
  269.     }
  271.     /**
  272.      * long 转字节数组，大端
  273.      */
  274.     public static byte[] long2ByteArray_Big_Endian(long l) {
  276.         byte[] array = new byte[8];
  278.         for (int i = 0; i < array.length; i++) {
  279.             array[array.length - 1 - i] = (byte) (l >> (i * 8));
  280.         }
  281.         return array;
  282.     }
  284.     /**
  285.      * double 转字节数组，小端
  286.      */
  287.     public static byte[] double2ByteArray_Little_Endian(double d) {
  289.         return long2ByteArray_Little_Endian(Double.doubleToLongBits(d));
  290.     }
  292.     /**
  293.      * double 转字节数组，大端
  294.      */
  295.     public static byte[] double2ByteArray_Big_Endian(double d) {
  297.         return long2ByteArray_Big_Endian(Double.doubleToLongBits(d));
  298.     }
  300.     /**
  301.      * HexString 转字节数组
  302.      */
  303.     public static byte[] hexString2ByteArray(String hexString) {
  305.         // 两个十六进制字符一个 byte，单数则有误
  306.         if (hexString.length() % 2 != 0) {
  307.             return null;
  308.         }
  310.         byte[] array = new byte[hexString.length() / 2];
  312.         int value = 0;
  313.         for (int i = 0; i < hexString.length(); i++) {
  315.             char s = hexString.charAt(i);
  317.             // 前半个字节
  318.             if (i % 2 == 0) {
  319.                 value = Integer.parseInt(String.valueOf(s), 16) * 16;
  320.             } else {
  321.                 // 后半个字节
  322.                 value += Integer.parseInt(String.valueOf(s), 16);
  323.                 array[i / 2] = (byte) value;
  324.                 value = 0;
  325.             }
  326.         }
  328.         return array;
  329.     }
  330. }

参考

Java 中 byte、byte 数组和 int、long 之间的转换

大端小端模式

发表评论

表情：
评论列表 （有 0 条评论，146人围观）

还没有评论，来说两句吧...

相关阅读