java byte数组拷贝_异或校验原理

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

其实在以前没接触这些内容的时候，脸上是懵逼的表情，完全不明白异或是为了干什么。

其实用简单的语言来说，接收数据的异或校验相当于解密，发送时候的校验位相当于加密；

官方解释是：其他数据信息传递中为保证数据传递正确可靠，在数据帧中常加载异或校验位（个人理解怕传输过程中出现数据丢失损坏的情况，所以加校验保证了数据的准确性）

言归正传java中怎么异或校验

1、发送数据

        byte[] rece = new byte[6];
        rece[0] = 0x55;
        rece[1] = 0x01;
        rece[2] = (byte) 0xA1;
        rece[3] = 0x5F;
        rece[4] = 0x00;
        rece[5] = (byte) (rece[0] ^ rece[1] ^ rece[2] ^ rece[3] ^ rece[4]);

比如说有一个byte数组，第五位是校验位，那么校验位的就是前面所有位数数据的异或，即：

rece[5] = (byte) (rece[0] ^ rece[1] ^ rece[2] ^ rece[3] ^ rece[4]);

计算得出的校验位为AA，得到校验位之后就可以进行指令发送操作了；

2、解析数据

比如我们收到一个byte数组，其数据如下：

        rece[0] = 0x55;
        rece[1] = 0x01;
        rece[2] = (byte) 0xA2;
        rece[3] = 0x00;
        rece[4] = 0x00;
        rece[5] = 0xF6

 此时我们如何判断数据是准确的呢？还是通过异或校验

		int error=rece[5];
		for(int i=0; i<5;i++){
			error=error^ rece[i];
		}
		return error==0;

还是以rece[5]为校验位举例：当校验位与前面所有数据进行异或，最后得到的异或值=0时，表示数据是有效的。如果出现了其他情况，那么就需要排除一下了。

附几个byte数据操作常用的方法

/** 十六进制字符串转换byte数组*/
	public static byte[] hexStringToByteArray(String digits) {
		String s = digits.length() % 2 > 0 ? "0" + digits : digits;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		for (int i = 0; i < s.length(); i += 2) {
			char c1 = s.charAt(i);
			if ((i + 1) >= s.length()) {
				throw new IllegalArgumentException("hexUtil.odd");
			}
			char c2 = s.charAt(i + 1);
			byte b = 0;
			if ((c1 >= '0') && (c1 <= '9'))
				b += ((c1 - '0') * 16);
			else if ((c1 >= 'a') && (c1 <= 'f'))
				b += ((c1 - 'a' + 10) * 16);
			else if ((c1 >= 'A') && (c1 <= 'F'))
				b += ((c1 - 'A' + 10) * 16);
			else
				throw new IllegalArgumentException("hexUtil.bad");

			if ((c2 >= '0') && (c2 <= '9'))
				b += (c2 - '0');
			else if ((c2 >= 'a') && (c2 <= 'f'))
				b += (c2 - 'a' + 10);
			else if ((c2 >= 'A') && (c2 <= 'F'))
				b += (c2 - 'A' + 10);
			else
				throw new IllegalArgumentException("hexUtil.bad");
			baos.write(b);
		}
		return (baos.toByteArray());

	}


/** byte数组 转换为 十六进制 字符串 */

    public static String byteArrayToHexStr(byte bytes[]) {

        StringBuffer sb = new StringBuffer(bytes.length * 2);
        for (int i = 0; i < bytes.length; i++) {
            sb.append(digitToHexChar((bytes[i] >> 4)));
            sb.append(digitToHexChar((bytes[i] & 0x0f)));
        }
        return (sb.toString());

    }
    private static char digitToHexChar(int value) {
        value = value & 0x0f;
        if (value >= 10){
            return ((char) (value - 10 + 'A'));
        }else{
            return ((char) (value + '0'));
        }
    }

 一些进制转换方法

	/**
	 * 16进制字符串转换为10进制数字
	 * @param hexs
	 * @return
	 */
	public static int decodeHEX(String hexs){
		BigInteger bigint=new BigInteger(hexs, 16);
		int numb=bigint.intValue();
		return numb;
	}

	/**
	 * 10进制数字转换为16进制字符串 1位时 补0
	 * @param n
	 * @return
	 */
	private String getNum(Integer n){
		String number=Integer.toHexString(n);
		if(number.length()==1){
			number="0"+number;
		}
		return number;
	}

	/**
	 * 10进制数字转换为16进制字符串
	 * @param numb
	 * @return
	 */
	public static String encodeHEX(Integer numb){
		String hex= Integer.toHexString(numb);
		return hex;
	}