「javacrc算法」java算法和c语言算法
本篇文章给大家谈谈javacrc算法，以及java算法和c语言算法对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java的crc8校验，按指定多项式，求助
- 2、如何用java实现CRC8验证算法
- 3、java中CRC算法是个什么东东
- 4、求java的 crc8算法方法
- 5、CRC算法，从原理到实现
- 6、JAVA怎么做CRC校验的程序
java的crc8校验，按指定多项式，求助
以下是我的分析，不知是否正确，你参考下1、首先来看你打java代码：crc=(byte)((crc1)^0x8c);和 crc=(byte)(crc1); 导致这个问题是因为byte的最高位符号位，转换的时候就出错了2、示例代码：package com.test;public class test {public static void main(String[] args) {byte[] ptr = { 1, 1, 1, 1, 1, 1 };byte res = getCrc(ptr);System.out.println();System.out.println((byte)( (1 1) ^ 0x8c ) + ":" +( (1 1) ^ 0x8c ) );}public static byte getCrc(byte[] ptr) {int crc = 0;for (int i = 0; i 1) ^ 0x8c;} else {crc = crc 1;}}}return (byte) crc;}}
如何用java实现CRC8验证算法
/*
*---------------------------------------------------------------------------
* Copyright (C) 1999,2000 Dallas Semiconductor Corporation, All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of Dallas Semiconductor
* shall not be used except as stated in the Dallas Semiconductor
* Branding Policy.
*---------------------------------------------------------------------------
*/
package com.dalsemi.onewire.utils;
/**
* CRC8 is a class to contain an implementation of the
* Cyclic-Redundency-Check CRC8 for the iButton. The CRC8 is used
* in the 1-Wire Network address of all iButtons and 1-Wire
* devices.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @version 0.00, 28 Aug 2000
* @author DS
*
*/
public class CRC8
{
//--------
//-------- Variables
//--------
/**
* CRC 8 lookup table
*/
private static byte dscrc_table [];
/*
* Create the lookup table
*/
static
{
//Translated from the assembly code in iButton Standards, page 129.
dscrc_table = new byte [256];
int acc;
int crc;
for (int i = 0; i 256; i++)
{
acc = i;
crc = 0;
for (int j = 0; j 8; j++)
{
if (((acc ^ crc) 0x01) == 0x01)
{
crc = ((crc ^ 0x18) 1) | 0x80;
}
else
crc = crc 1;
acc = acc 1;
}
dscrc_table [i] = ( byte ) crc;
}
}
//--------
//-------- Constructor
//--------
/**
* Private constructor to prevent instantiation.
*/
private CRC8 ()
{
}
//--------
//-------- Methods
//--------
/**
* Perform the CRC8 on the data element based on the provided seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc data element on which to perform the CRC8
* @param seed seed the CRC8 with this value
* @return CRC8 value
*/
public static int compute (int dataToCRC, int seed)
{
return (dscrc_table [(seed ^ dataToCRC) 0x0FF] 0x0FF);
}
/**
* Perform the CRC8 on the data element based on a zero seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc data element on which to perform the CRC8
* @return CRC8 value
*/
public static int compute (int dataToCRC)
{
return (dscrc_table [dataToCRC 0x0FF] 0x0FF);
}
/**
* Perform the CRC8 on an array of data elements based on a
* zero seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc array of data elements on which to perform the CRC8
* @return CRC8 value
*/
public static int compute (byte dataToCrc [])
{
return compute(dataToCrc, 0, dataToCrc.length);
}
/**
* Perform the CRC8 on an array of data elements based on a
* zero seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc array of data elements on which to perform the CRC8
* @param off offset into array
* @param len length of data to crc
* @return CRC8 value
*/
public static int compute (byte dataToCrc [], int off, int len)
{
return compute(dataToCrc, off, len, 0);
}
/**
* Perform the CRC8 on an array of data elements based on the
* provided seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc array of data elements on which to perform the CRC8
* @param off offset into array
* @param len length of data to crc
* @param seed seed to use for CRC8
* @return CRC8 value
*/
public static int compute (byte dataToCrc [], int off, int len, int seed)
{
// loop to do the crc on each data element
int CRC8 = seed;
for (int i = 0; i len; i++)
CRC8 = dscrc_table [(CRC8 ^ dataToCrc [i + off]) 0x0FF];
return (CRC8 0x0FF);
}
/**
* Perform the CRC8 on an array of data elements based on the
* provided seed.
* p
* CRC8 is based on the polynomial = X^8 + X^5 + X^4 + 1.
*
* @param dataToCrc array of data elements on which to perform the CRC8
* @param seed seed to use for CRC8
* @return CRC8 value
*/
public static int compute (byte dataToCrc [], int seed)
{
return compute(dataToCrc, 0, dataToCrc.length, seed);
}
}
java中CRC算法是个什么东东
CRC算法实现有2种方法，一、查表法，二、直接计算，查表法的计算速度相对来说比较快，本人介绍的方法是直接计算法，用了2种方法实现，都是面向对象进行算法的封装。
package com.wms.serial;
/**
* @author linduo
* @version 2006/08/25
*/
public class CRC16{
public int value;
public CRC16()
{
value = 0;
}
/** update CRC with byte b */
public void update(byte aByte)
{
int a, b;
a = (int) aByte;
for (int count = 7; count =0; count--) {
a = a 1;
b = (a 8) 1;
if ((value 0x8000) != 0) {
value = ((value 1) + b) ^ 0x1021;
} else {
value = (value 1) + b;
}
}
value = value 0xffff;
return;
}
/** reset CRC value to 0 */
public void reset()
{
value = 0;
}
public int getValue()
{
return value;
}
public static void main(String[] args) {
CRC16 crc16 = new CRC16();
byte[] b = new byte[]{
//(byte) 0xF0,(byte)0xF0,(byte)0xF0,(byte)0x72
(byte) 0x2C,(byte)0x00,(byte)0xFF,(byte)0xFE
,(byte) 0xFE,(byte)0x04,(byte)0x00,(byte)0x00
,(byte) 0x00,(byte)0x00
};
for (int k = 0; k b.length; k++)
{
crc16.update(b[k]);
}
System.out.println(Integer.toHexString(crc16.getValue()));
System.out.println(Integer.toHexString(b.length));
}
}
package com.wms.serial;
public class CRC162 {
public static final void main(String[] args){
CRC162 crc16 = new CRC162();
byte[] b = new byte[]{
//(byte) 0xF0,(byte)0xF0,(byte)0xF0,(byte)0x72
(byte) 0x2C,(byte)0x00,(byte)0xFF,(byte)0xFE
,(byte) 0xFE,(byte)0x04,(byte)0x00,(byte)0x00
,(byte) 0x00,(byte)0x00
};
System.out.println(Integer.toHexString(crc16.encode(b)));
//再把这个2f49替换成b数组的最后两个字节的数组,生成一个新的数组b2
byte[] b2 = new byte[]{
//(byte) 0xF0,(byte)0xF0,(byte)0xF0,(byte)0x72
(byte) 0x2C,(byte)0x00,(byte)0xFF,(byte)0xFE
,(byte) 0xFE,(byte)0x04,(byte)0x00,(byte)0x00
,(byte) 0x2f,(byte)0x49
};
System.out.println(Integer.toHexString(crc16.encode(b2))); //算出来是 0
//你可以自已构造一些byte进行加解密试试
}
public short encode(byte[] b){
short CRC_x = 0;
int pp = 65536; // 116;
int pp2 = 69665; // (116) + (112) + (15) + 1
for(int i=0;ib.length;i++){
for(int j=0;j8;j++){
CRC_x = (short)((CRC_x1) + (((b[i]j)0x80)7));
if((CRC_x/pp) == 1){
CRC_x=(short)(CRC_x^pp2);
}
}
}
return CRC_x;
}
}
求java的 crc8算法方法
你的意思就翻译一下，是吗：
static char crc8fun ( char in, char prest)
{
int loop;
char out;
char crc_pol=0xb8; /*多项式*/
out = in^prest;
for(loop=0;loop8;loop++){
if(out0x01){
out=(out1)^crc_pol;
}else{
out=(out1);
}
return out;
}
}
CRC算法，从原理到实现
CRC，一种基于有限域GF(2)的多项式环的Hash算法。在GF(2)中，多项式系数只有0、1，加减运算等同于异或(XOR)运算，乘除运算与一般多项式运算一致（合并同类项时需要注意为XOR运算）
在GF(2)中，多项式系数只有0、1，加减运算等同于异或(XOR)运算，乘除运算与一般多项式运算一致（合并同类项时需要注意为XOR运算）。在CRC-n算法中，有M(x)·x n =Q(x)·G(x)+R(x)，M(x)为m位的数据，G(x)为一个GF(2)的n+1项的生成多项式(Poly)，M(x)·x n 则是通过在数据M(x)后添加n个0形成的对应的m+n位多项式，而R(x)即为M(x)·x n 除以G(x)的n位余数——即CRC校验码，Q(x)为商，直接丢弃。通过比较两次计算产生的Signature是否一致判断故障的发生
假定M(x)=11100110，G(x)=x 3 + x + 1，其中n=3，则M(x)·x n =11100110000，将G(x)多项式中的各项系数取出，按降幂排列所对应的数据Poly=1011，然后对其进行除法运算：
所得n位余数即为CRC——100
根据定义可以建立一个简单的CRC实现算法，模型如下图所示：
1)建立一个长度为r的CRC Register，并初始化为0
2)在M(x)后添加r个0形成M(x)·x n
3)将CRC Register左移一位，将M(x)·x n 的MSB移入CRC Register的Bit 0
4)第3步中的从CRC Register移出的数，如果是1，则计算，CRC Register=Poly XOR CRC Register
5)重复第3步，直到M(x)·x n 全部移入CRC Register
6)CRC Register即为CRC校验值
根据定义所建立的算法模型存在明显缺陷，按位移动处理效率低下，为此我们探索如何实现更大处理单元的算法。这次我们以CRC-32为例，按照前面的算法思路构建的模型如下图所示：
设CRC Register中的Byte 3依次为：t7 t6 t5 t4 t3 t2 t1 t0，Poly中的Bit31-Bit24依次为：g7 g6 g5 g4 g3 g2 g1 g0，根据1.3.2可知，在第1次迭代中，CRC Register的MSB:t7将会决定Poly与CRC Register的异或，如果t7=1，这就会发生，反之就不会发生;在第2次迭代中，CRC Register的MSB:t6 XOR (t7*g7) 将会决定本次Poly与CRC Register的异或是否发生，即t7、t6控制第2XOR操作；同理，在第3次迭代中，CRC Register的MSB也是通过t7、t6、t5决定，即t7、t6、t5控制第3次XOR操作。故我们可以得出下述结论：k次以后的迭代的最高位的值，可以由寄存器的前k位计算得到。根据这个结论，我们可以一次性取出CRC Register的Byte 3，提前计算出8次迭代后的寄存器余式，因为高位终将会在迭代中被移出，我们只需要关心余式即可。同时XOR运算满足结合律：A XOR B XOR C = A XOR (B XOR C)
上图即为Byte 3全部迭代移出的示意图，根据结合律可以看出，我们可以依据Byte 3直接确定8次异或的与否及Poly的偏移量，从而提前计算出不同偏移量的Poly间XOR的值，令其为A，易知A的高8位和Byte 3一定相等，Reg向左移出btye3，从M(x)·x n 读取一个byte放在byte 0，最后将A的低32位与Reg完成XOR操作。为避免与字节边界发生冲突，我们采用字节的整数倍——字节（1 byte）、字（2 byte）、双字（4 byte），故一般不采用4bit作为处理单元。由于一个字节的取值是有限的——256种，我们只要提前计算一个字节全部的A值保存到表中。运行时以byte值为索引，直接从表里取出即可
至此我们完成基于1 byte为处理单元的Table Driven，算法模型如下图所示：
1)建立一个长度为r的CRC Register，并初始化为0
2)在M(x)后添加r个0形成M(x)·x n
3)将CRC Register左移一个byte，从M(x)·x n 读入一个byte至CRC Register的byte 0中
4)以第3步中的从CRC Register移出的byte为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
5)重复第3步，直到M(x)·x n 全部移入CRC Register6) CRC Register即为CRC校验值
在上述的两种算法中，我们每次都需要在M(x)后添加n个0，其并不参与运算，目的只是为了将M(x)的全部推入CRC Register而已，并且在有些情境下在M(x)后添0操作并不总是能够实现的，故通过改进计算步骤有了直接表法，避免了对原始数据的添0操作
算法流程，算法模型如下图所示：
1)建立一个长度为r的CRC Register，按照Init值对其初始化
2)将CRC Register左移一个byte，从M(x)左移一个byte，两者进行XOR
3)第2步中XOR后的值作为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
4)重复第2步，直到M(x)全部取出
5)CRC Register即为CRC校验值
在Direct Table算法中，当RefIn、RefOut为True，每次都需要对数据做颠倒操作，很麻烦。为此产生了Reflected Direct Table算法，该算法改变了CRC Register的移动方向，而不需要对M(x)做任何处理，按字节顺序读取即可，算法模型如下图所示
算法流程如下：
1)建立一个长度为r的CRC Register，按照Init值对其初始化
2)将CRC Register右移一个byte，从M(x)左移一个byte，两者进行XOR
3)第2步中XOR后的值作为index，从表中取出对应的n位宽的值，将该值与CRC Register进行XOR
4)重复第2步，直到M(x)全部取出
5)CRC Register即为CRC校验值
Name: CRC标准
Width: 生成的CRC的位宽
Poly: 生成多项式，一般采用十六进制简记，长度为width+1，由于其最高位恒为1，故记法中不体现出来（例如：x 16 +x 12 +x 5 +1记为0x1021）
Init: 初始值，如果数据前添加了若干个前导零，在前述算法中，一般是检测不到的，故通过改变CRC Register中的预设值，以实现对该类型错误的检测。在Direct Table算法中用Init初始化CRC Register即可，在Table Driven算法中，不可以直接用Init初始化CRC Register，因为其等同于在原始数据前插入了Init，必须要先把CRC Register设为0，等M(x)·x n 移动n/8次后，即CRC Register的预设值0全部移出时，再将Init值异或进CRC Register。完成Init操作
Xorout: 结果异或值，所有计算完成后将CRC Register与Xorout进行异或作，作为最后的校验值
RefIn: 输入反转，这是一个布尔值，如果为False，则每个字节内的位顺序保持不变，即Bit 7为MSB，Bit0为LSB。如果为True，则将需要每个字节内的位顺序颠倒，即Bit 7为LSB，Bit0为MSB。这个约定在硬件CRC中是合理的，因为在串口通讯中硬件一般默认先发送字节的Bit 0，最后发送Bit 7
RefOut: 输出反转，这是一个布尔值，如果为False，则在计算结束后，直接进入Xorout环节，如果为True，则在计算结束后，将CRC Register进行颠倒后，再进入Xorout环节。注意，和RefIn颠倒字节内的位顺序不同的是，这个是将CRC Register的值作为一个整体颠倒，即Bit n到Bit0进行颠倒
针对常见常用的下述CRC给出了实现方法，以供参考
JAVA怎么做CRC校验的程序
实现方法：最简单的校验就是把原始数据和待比较数据直接进行比较，看是否完全一样这种方法是最安全最准确的。同时也是效率最低的。
应用例子：龙珠cpu在线调试工具bbug.exe。它和龙珠cpu间通讯时，bbug发送一个字节cpu返回收到的字节，bbug确认是刚才发送字节后才继续发送下一个字节的。 实现方法：在数据存储和传输中，字节中额外增加一个比特位，用来检验错误。校验位可以通过数据位异或计算出来。
应用例子：单片机串口通讯有一模式就是8位数据通讯，另加第9位用于放校验值。
bcc异或校验法(block check character)
实现方法：很多基于串口的通讯都用这种既简单又相当准确的方法。它就是把所有数据都和一个指定的初始值（通常是0）异或一次，最后的结果就是校验值，通常把它附在通讯数据的最后一起发送出去。接收方收到数据后自己也计算一次异或和校验值，如果和收到的校验值一致就说明收到的数据是完整的。
校验值计算的代码类似于：
unsigned uCRC=0;//校验初始值
for(int i=0;iDataLenth;i++) uCRC^=Data[i];
适用范围：适用于大多数要求不高的数据通讯。
应用例子：ic卡接口通讯、很多单片机系统的串口通讯都使用。 (Cyclic Redundancy Check)
实现方法：这是利用除法及余数的原理来进行错误检测的
javacrc算法的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java算法和c语言算法、javacrc算法的信息别忘了在本站进行查找喔。
发布于：2022-12-06，除非注明，否则均为原创文章，转载请注明出处。