车载canBUS开发：java各基本数据类型的字节位运算

一：首先要知道的java八大基本数据类型所占据的字节大小：
Int: 4 字节
Short: 2字节
Long: 8字节
Byte: 1字节
Character: 2字节
Float: 4字节
Double: 8字节
Boolean：系统没有提供Size方法；
输出代码如下：

private static void calSize() {
        System.out.println("Integer: " + Integer.SIZE / 8); // 4
        System.out.println("Short: " + Short.SIZE / 8); // 2
        System.out.println("Long: " + Long.SIZE / 8); // 8
        System.out.println("Byte: " + Byte.SIZE / 8); // 1
        System.out.println("Character: " + Character.SIZE / 8); // 2
        System.out.println("Float: " + Float.SIZE / 8); // 4
        System.out.println("Double: " + Double.SIZE / 8); // 8
        System.out.println("Boolean: " + Boolean.toString(false));
    }

运行结果显示：console 输出
Integer: 4
Short: 2
Long: 8
Byte: 1
Character: 2
Float: 4
Double: 8
Boolean: false

二：位运算相关代码：

public class Bit {
    public final static int Bit0 = 1<<0;
    public final static int Bit1 = 1<<1;
    public final static int Bit2 = 1<<2;
    public final static int Bit3 = 1<<3;
    public final static int Bit4 = 1<<4;
    public final static int Bit5 = 1<<5;
    public final static int Bit6 = 1<<6;
    public final static int Bit7 = 1<<7;
    public final static int Bit8 = 1<<8;
    public final static int Bit9 = 1<<9;
    public final static int Bit10 = 1<<10;
    public final static int Bit11 = 1<<11;
    public final static int Bit12 = 1<<12;
    public final static int Bit13 = 1<<13;
    public final static int Bit14 = 1<<14;
    public final static int Bit15 = 1<<15;
    public final static int Bit16 = 1<<16;
    public final static int Bit17 = 1<<17;
    public final static int Bit18 = 1<<18;
    public final static int Bit19 = 1<<19;
    public final static int Bit20 = 1<<20;
    public final static int Bit21 = 1<<21;
    public final static int Bit22 = 1<<22;
    public final static int Bit23 = 1<<23;
    public final static int Bit24 = 1<<24;
    public final static int Bit25 = 1<<25;
    public final static int Bit26 = 1<<26;
    public final static int Bit27 = 1<<27;
    public final static int Bit28 = 1<<28;
    public final static int Bit29 = 1<<29;


    public static void setBit(int src, int bit){
        src = src | bit;
    }

    public static void clrBit(int src, int bit){
        src = src & (~ bit);
    }
}

取字节的某几位，示例代码如下：

// 整车控制器LIFE,0~255循环计数,每次+1
            int sn = CanHepler.toInt(buf[0]);
            // 整车故障等级, 00:无故障, 01:一级（严重故障，立即停车）, 10：二级（普通故障，限速运行）,
            // 11:三级（报警故障，报警）
            int  byte1Bit01 = (CanHepler.toInt(buf[1]) & (Bit.Bit0 | Bit.Bit1));
            // 电机控制器故障等级, 00:无故障, 01:一级（严重故障，立即停车）, 10：二级（普通故障，限速运行）,
            // 11:三级（报警故障，报警）
            int byte1Bit23 = (CanHepler.toInt(buf[1]) & (Bit.Bit2 | Bit.Bit3)) >> 2;
            // 电池管理系统故障等级, 00:无故障, 01:一级（严重故障，立即停车）, 10：二级（普通故障，限速运行）,
            // 11:三级（报警故障，报警）
            int byte1Bit45 = (CanHepler.toInt(buf[1]) & (Bit.Bit4 | Bit.Bit5)) >> 4;
            // 整车控制器故障等级, 00:无故障, 01:一级（严重故障，立即停车）, 10：二级（普通故障，限速运行）,
            // 11:三级（报警故障，报警）
            int byte1Bit67 = (CanHepler.toInt(buf[1]) & (Bit.Bit6 | Bit.Bit7)) >> 6;// 00110011

取字节的某一位，示例代码如下：

// 动力电池单体电压过低, 0：正常, 1：故障
            int byte4Bit0 = (CanHepler.toInt(buf[4]) & (Bit.Bit0));
            // 电机控制器过温, 0：正常, 1：故障
            int byte4Bit1 = (CanHepler.toInt(buf[4]) & (Bit.Bit1)) >> 1;
            // 真空泵故障, 0：正常, 1：故障
            int byte4Bit2 = (CanHepler.toInt(buf[4]) & (Bit.Bit2)) >> 2;
            // 蓄电池电压过低（10.9V~11.9V）, 0：正常, 1：故障
            int byte4Bit3 = (CanHepler.toInt(buf[4]) & (Bit.Bit3)) >> 3;
            // 电机控制器掉线, 0：正常, 1：故障
            int byte4Bit4 = (CanHepler.toInt(buf[4]) & (Bit.Bit4)) >> 4;
            // 电池管理系统掉线, 0：正常, 1：故障
            int byte4Bit5 = (CanHepler.toInt(buf[4]) & (Bit.Bit5)) >> 5;
            // SOC较低故障（10%-20%）, 0：正常, 1：故障
            int byte4Bit6 = (CanHepler.toInt(buf[4]) & (Bit.Bit6)) >> 6;
            // SOC过低故障（小于10%）, 0：正常, 1：故障
            int byte4Bit7 = (CanHepler.toInt(buf[4]) & (Bit.Bit7)) >> 7;

CanHepler.java文件：

    public static int toInt(byte b) {
        int result = ((int) b) & 0xff;
        return result;
    }

数据转换工具类，示例代码如下：

/** *数据转换工具 */
public class Utility {
    //-------------------------------------------------------
    // 判断奇数或偶数，位运算，最后一位是1则为奇数，为0是偶数
    static public int isOdd(int num)
    {
        return num & 0x1;
    }
    //-------------------------------------------------------
    static public int HexToInt(String inHex)//Hex字符串转int
    {
        return Integer.parseInt(inHex, 16);
    }
    //-------------------------------------------------------
    static public byte HexToByte(String inHex)//Hex字符串转byte
    {
        return (byte)Integer.parseInt(inHex,16);
    }
    //-------------------------------------------------------
    static public String Byte2Hex(Byte inByte)//1字节转2个Hex字符
    {
        return String.format("%02x", inByte).toUpperCase();
    }
    //-------------------------------------------------------
    static public String ByteArrToHex(byte[] inBytArr)//字节数组转转hex字符串
    {
        StringBuilder strBuilder=new StringBuilder();
        int j=inBytArr.length;
        for (int i = 0; i < j; i++)
        {
            strBuilder.append(Byte2Hex(inBytArr[i]));
            strBuilder.append(" ");
        }
        return strBuilder.toString(); 
    }
  //-------------------------------------------------------
    static public String ByteArrToHex(byte[] inBytArr,int offset,int byteCount)//字节数组转转hex字符串，可选长度
    {
        StringBuilder strBuilder=new StringBuilder();
        int j=byteCount;
        for (int i = offset; i < j; i++)
        {
            strBuilder.append(Byte2Hex(inBytArr[i]));
            strBuilder.append(" ");
        }
        return strBuilder.toString();
    }
    //-------------------------------------------------------
    //转hex字符串转字节数组
    static public byte[] HexToByteArr(String inHex)//hex字符串转字节数组
    {
        int hexlen = inHex.length();
        byte[] result;
        if (isOdd(hexlen)==1)
        {//奇数
            hexlen++;
            result = new byte[(hexlen/2)];
            inHex="0"+inHex;
        }else {//偶数
            result = new byte[(hexlen/2)];
        }
        int j=0;
        for (int i = 0; i < hexlen; i+=2)
        {
            result[j]=HexToByte(inHex.substring(i,i+2));
            j++;
        }
        return result; 
    }

    //-------------------------------------------------------
    static public String ByteArrToString(byte[] inBytArr)//字节数组转转ascii字符串
    {
        StringBuilder strBuilder=new StringBuilder();
        int j=inBytArr.length;
        for (int i = 0; i < j; i++)
        {
            strBuilder.append((char)(inBytArr[i]));
        }
        return strBuilder.toString(); 
    }

    //根据高低位字节码生成字符
    static public char MakeWord(byte loByte, byte hiByte) {
        int loB = (loByte & 0xFF);
        int hiB = (hiByte & 0xFF);
        int a = (0xFFFF & (loB | hiB << 8));
        return (char)(0xFFFF & (loB | hiB << 8));
    }

    //取字符的低位字节码
    static public byte LoByte(char word){
        return (byte)word;
    }

    //取字符的高位字节码
    static public byte HiByte(char word){
        return (byte)((word >> 8) & 0xFF);
    }

    public static int byteToInt(byte b){
        return (0xFF & b);
    }

/** * unicode转换成中文 * * @param unicode * @return */
    public static String unicodeToCn(byte[] unicode) {
        String returnStr = "";
        if (unicode != null && unicode.length % 2 == 0) {
            for (int i = 0; i < unicode.length / 2; i++) {
                String str = Integer.toHexString(unicode[i * 2]);
                if (str.length() > 2) {
                    str = str.substring(str.length() - 2);
                } else if (str.length() < 2) {
                    str = "0" + str;
                }

                String str2 = Integer.toHexString(unicode[i * 2 + 1]);
                if (str2.length() > 2) {
                    str2 = str2.substring(str2.length() - 2);
                } else if (str2.length() < 2) {
                    str2 = "0" + str2;
                }
                returnStr += "\\u" + str + str2;
            }

            String[] strs = returnStr.split("\\\\u");
            returnStr = "";
            for (int i = 1; i < strs.length; i++) {
                returnStr += (char) Integer.valueOf(strs[i], 16).intValue();
            }
        }
        return returnStr;
    }

    /** * 中文转换成unicode * * @param cn * @return */
    public static byte[] cnToUnicode(String cn) {
        if (cn != null) {
            char[] chars = cn.toCharArray();
            byte[] datas = new byte[chars.length * 2];
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < chars.length; i++) {
                String hexString = Integer.toHexString(chars[i]);
                sb.append(hexString + " ");
                if (hexString.length() == 0) {
                    hexString = "0000" + hexString;
                } else if (hexString.length() == 1) {
                    hexString = "000" + hexString;
                } else if (hexString.length() == 2) {
                    hexString = "00" + hexString;
                } else if (hexString.length() == 3) {
                    hexString = "0" + hexString;
                }
                String info = hexString.substring(0, 2);
                datas[i * 2] = (byte) Integer.parseInt(info, 16);
                info = hexString.substring(2, 4);
                datas[i * 2 + 1] = (byte) Integer.parseInt(info, 16);
            }
            return datas;
        } else {
            return null;
        }
    }

/** * 取出一个byte的begin到end位的数值 * * @param b * @param begin 从0开始 * @param end * @return */
    public static byte getData(byte b, int begin, int end) {
        int byteNum = 1;
        byte dataTemp = 1;

        for (int i = 1; i < (byteNum + (end - begin)); i++) {
            dataTemp = (byte) (dataTemp | (1 << i));
        }

        byte temp = (byte) (b >> begin);
        return (byte) (temp & dataTemp);
    }
/** * 截取byte数组，根据开始位置和结束位置 * * @param value * @param start * @param end * @return */
    public static byte[] splitByteArray(byte[] value, int start, int end) {
        byte[] bytes = new byte[end - start + 1];
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = value[start + i];
        }
        return bytes;
    }

}