[分享]Java中byte[]与基础类型之间的转换

ゞ浴缸里的玫瑰 2022-08-07 16:44 174阅读 0赞

========================================================  
作者：qiujuer  
博客：[blog.csdn.net/qiujuer][blog.csdn.net_qiujuer]  
网站：[www.qiujuer.net][]  
开源库：[github.com/qiujuer/Genius-Android][github.com_qiujuer_Genius-Android]  
开源库：[github.com/qiujuer/Blink][github.com_qiujuer_Blink]  
转载请注明出处：[http://blog.csdn.net/qiujuer/article/details/45152189][http_blog.csdn.net_qiujuer_article_details_45152189]  
\------学之开源，用于开源；初学者的心态，与君共勉！

========================================================

很久没有写博客了，有些生疏了；一直忙着做 Blink 框架去了。  
在这里打个广告，Blink是一款Socket协议跨平台框架，现在提供有Java、Android、C\#的版本；通过Blink能实现对Socket传输的异步封装，能直接发送或接受数据，现能直接发送 byte ，String，File 等类型，可在不改动框架情况下直接扩展所需类型。

[Blink开源框架链接][github.com_qiujuer_Blink]

因为在Socket的传输中都是 Bytes 的传输，所以涉及到 Java 基本类型（char、short、int、long）与byte\[\] 的转化，自己总结了一下，简单的写了一个类。

/**
     * Bit Converter
     */
    public class BitConverter {
    
        /**
         * Convert char to byte[]
         *
         * @param x char
         * @return bytes
         */
        public static byte[] toBytes(char x) {
            return toBytes(x, new byte[2], 0);
        }
    
        /**
         * Convert char to byte[]
         *
         * @param x       char
         * @param bytes   Dest bytes
         * @param bytePos Dest pos
         * @return bytes
         */
        public static byte[] toBytes(char x, byte[] bytes, int bytePos) {
            bytes[bytePos++] = (byte) (x);
            bytes[bytePos] = (byte) (x >> 8);
            return bytes;
        }
    
    
        /**
         * Convert short to byte[]
         *
         * @param x Short
         * @return bytes
         */
        public static byte[] toBytes(short x) {
            return toBytes(x, new byte[2], 0);
        }
    
        /**
         * Convert short to byte[]
         *
         * @param x       Short
         * @param bytes   Dest bytes
         * @param bytePos Dest pos
         * @return bytes
         */
        public static byte[] toBytes(short x, byte[] bytes, int bytePos) {
            bytes[bytePos++] = (byte) (x);
            bytes[bytePos] = (byte) (x >> 8);
            return bytes;
        }
    
        /**
         * Convert int to byte[]
         *
         * @param x int
         * @return bytes
         */
        public static byte[] toBytes(int x) {
            return toBytes(x, new byte[4], 0);
        }
    
        /**
         * Convert int to byte[]
         *
         * @param x       int
         * @param bytes   Dest bytes
         * @param bytePos Dest pos
         * @return bytes
         */
        public static byte[] toBytes(int x, byte[] bytes, int bytePos) {
            bytes[bytePos++] = (byte) (x);
            bytes[bytePos++] = (byte) (x >> 8);
            bytes[bytePos++] = (byte) (x >> 16);
            bytes[bytePos] = (byte) (x >> 24);
            return bytes;
        }
    
        /**
         * Convert long to byte[]
         *
         * @param x long
         * @return bytes
         */
        public static byte[] toBytes(long x) {
            return toBytes(x, new byte[8], 0);
        }
    
        /**
         * Convert long to byte[]
         *
         * @param x       long
         * @param bytes   Dest bytes
         * @param bytePos Dest pos
         * @return bytes
         */
        public static byte[] toBytes(long x, byte[] bytes, int bytePos) {
            bytes[bytePos++] = (byte) (x);
            bytes[bytePos++] = (byte) (x >> 8);
            bytes[bytePos++] = (byte) (x >> 16);
            bytes[bytePos++] = (byte) (x >> 24);
            bytes[bytePos++] = (byte) (x >> 32);
            bytes[bytePos++] = (byte) (x >> 40);
            bytes[bytePos++] = (byte) (x >> 48);
            bytes[bytePos] = (byte) (x >> 56);
            return bytes;
        }
    
        /**
         * Convert byte[] to char
         *
         * @param bytes bytes
         * @return char
         */
        public static char toChar(byte[] bytes) {
            return toChar(bytes, 0);
        }
    
        /**
         * Convert byte[] to char
         *
         * @param bytes bytes
         * @param index byte start index
         * @return char
         */
        public static char toChar(byte[] bytes, int index) {
            return (char) ((bytes[index + 1] << 8) | (bytes[index] & 0xff));
        }
    
        /**
         * Convert byte[] to short
         *
         * @param bytes bytes
         * @return short
         */
        public static short toShort(byte[] bytes) {
            return toShort(bytes, 0);
        }
    
        /**
         * Convert byte[] to short
         *
         * @param bytes bytes
         * @param index byte start index
         * @return short
         */
        public static short toShort(byte[] bytes, int index) {
            return (short) ((bytes[index + 1] << 8) | (bytes[index] & 0xff));
        }
    
        /**
         * Convert byte[] to int
         *
         * @param bytes bytes
         * @return int
         */
        public static int toInt(byte[] bytes) {
            return toInt(bytes, 0);
        }
    
        /**
         * Convert byte[] to int
         *
         * @param bytes bytes
         * @param index bytes start index
         * @return int
         */
        public static int toInt(byte[] bytes, int index) {
            return (((bytes[index + 3]) << 24) |
                    ((bytes[index + 2] & 0xff) << 16) |
                    ((bytes[index + 1] & 0xff) << 8) |
                    ((bytes[index] & 0xff)));
        }
    
        /**
         * Convert byte[] to long
         *
         * @param bytes bytes
         * @return long
         */
        public static long toLong(byte[] bytes) {
            return toLong(bytes, 0);
        }
    
        /**
         * Convert byte[] to long
         *
         * @param bytes bytes
         * @param index bytes start index
         * @return long
         */
        public static long toLong(byte[] bytes, int index) {
            return ((((long) bytes[index + 7]) << 56) |
                    (((long) bytes[index + 6] & 0xff) << 48) |
                    (((long) bytes[index + 5] & 0xff) << 40) |
                    (((long) bytes[index + 4] & 0xff) << 32) |
                    (((long) bytes[index + 3] & 0xff) << 24) |
                    (((long) bytes[index + 2] & 0xff) << 16) |
                    (((long) bytes[index + 1] & 0xff) << 8) |
                    (((long) bytes[index] & 0xff)));
        }
    }

> 需要注意的是：无论是从基本类型转换为 byte\[\] 还是 byte\[\] 转换为基本类型， 都是采用的低位在前高位在后的形式；这个与C\#的默认模式是一致的，如果你的需求是高位在前的情况则需要自己更改一下顺序了。

========================================================

[blog.csdn.net_qiujuer]: http://blog.csdn.net/qiujuer
[www.qiujuer.net]: http://www.qiujuer.net/
[github.com_qiujuer_Genius-Android]: https://github.com/qiujuer/Genius-Android
[github.com_qiujuer_Blink]: https://github.com/qiujuer/Blink
[http_blog.csdn.net_qiujuer_article_details_45152189]: http://blog.csdn.net/qiujuer/article/details/45152189