Java 中的 CRC 程序

2025年5月12日 | 阅读 5 分钟

CRC 是 **循环冗余校验 (Cyclic Redundancy Check)** 的缩写。它由 W. Wesley Peterson 于 1961 年发明。它是一种错误检测技术，可用于检测数字网络（或通信通道或数字数据）和存储设备中的错误。它用于追踪数字数据中的意外更改。在本节中，我们将学习如何通过 Java 程序计算和执行 CRC。让我们详细了解 CRC。

CRC 机制

它是一种错误检测机制，其中将一个特殊数字添加到数据块中。添加数字的主要目的是识别传输或存储过程中发生的更改。它会被计算两次，一次在数据传输期间的发送方，一次在接收方重新计算。它将数据逐位与最初传输的值进行比较。如果在数据传输过程中发生任何错误（损坏的位），CRC 将与最初传输的值不匹配。我们可以通过下图轻松理解 CRC 机制。

例如，数据中的单个损坏位会导致计算出的 CRC 发生一位变化，但多个损坏位可能会相互抵消。如果损坏或改变的多个位被称为突发错误。

还有一些其他的错误检测机制，如垂直冗余校验（VRC）和纵向冗余校验（LRC），但 CRC 比其他机制更强大。CRC 的算法更复杂，因为它使用二进制除法来计算 CRC。除数是使用多项式生成的。因此，CRC 也被称为多项式码校验和。

以下是在 CRC 中用于错误检测的步骤

第一步，我们在数据单元后面附加N个零。N 的值始终小于数据单元中的位数（称为除法，为N+1）。
下一步，我们使用二进制除法过程将新扩展的数据除以除数，从该除法中获得的余数称为 CRC 余数。
下一步，我们将之前在数据单元中附加的所有零替换为余数位。之后，我们将新生成的数据单元发送给接收方。
接收方接收带有 CRC 余数的数据单元。之后，接收方用除数除以数据单元。
如果用除数除以数据单元后余数为零，则数据单元未损坏，可以接受。
如果用除数除以数据单元后余数不等于零，则数据单元已损坏，将被丢弃。

让我们举个例子来理解 CRC 是如何工作的

假设原始数据是 11100，除数是 1001。

首先，我们将在数据单元部分添加零。除数的长度是 4，我们知道字符串 0 的长度总是比其除数少一位。所以，我们在数据单元中附加三个零，即11100。
附加零后，结果字符串将是 11100000，我们用除数1001对其进行除法。我们使用二进制除法过程来除以除数。
用除数除以数据单元后得到的余数称为 CRC 余数。
CRC 余数替换数据单元末尾附加的零字符串，最终字符串为 11100111，将通过网络发送。

CyclicRedundancyCheck.java

// import required classes and packages
package javaTpoint.MicrosoftJava;
import java.util.*;
// create CRCExample class to demonstrate the working of Cyclic Redundancy Check
class CRCExample {
	// main() method start
	public static void main(String args[]) {
		// create scanner class object to take input from user
		Scanner scan = new Scanner(System.in);
		// declare n for the size of the data
		int size;
		// take the size of the data from the user
		System.out.println("Enter the size of the data array: ");
		size = scan.nextInt();
		// declaration of the data array
		int data[] = new int[size];
		// take bits of the data from the user
		System.out.println("Enter data bits in the array one by one: ");
		for(int i = 0 ; i < size ; i++) {
			System.out.println("Enter bit " + (size-i) + ":");
			data[i] = scan.nextInt();
		}
		// take the size of the divisor from the user
		System.out.println("Enter the size of the divisor array:");
		size = scan.nextInt();
		// declaration of the divisor array
		int divisor[] = new int[size];
		System.out.println("Enter divisor bits in the array one by one: ");
		for(int i = 0 ; i < size ; i++) {
			System.out.println("Enter bit " + (size-i) + ":");
			divisor[i] = scan.nextInt();
		}
	// Divide the input data by the input divisor and store the result in the rem array
		int rem[] = divideDataWithDivisor(data, divisor);
		// iterate rem using for loop to print each bit
		for(int i = 0; i < rem.length-1; i++) {
			System.out.print(rem[i]);
		}
		System.out.println("\nGenerated CRC code is: ");
		
		for(int i = 0; i < data.length; i++) {
			System.out.print(data[i]);
		}
		for(int i = 0; i < rem.length-1; i++) {
			System.out.print(rem[i]);
		}
		System.out.println();
		// we create a new array that contains the original data with its CRC code
		// the size of the sentData array with be equal to the sum of the data and the rem arrays length
		int sentData[] = new int[data.length + rem.length - 1];
		System.out.println("Enter bits in the array which you want to send: ");
		for(int i = 0; i < sentData.length; i++) {
			System.out.println("Enter bit " +(sentData.length - 1)+ ":");
			sentData[i] = scan.nextInt();
		}
		receiveData(sentData, divisor);
	}
	// create divideDataWithDivisor() method to get CRC
	static int[] divideDataWithDivisor(int oldData[], int divisor[]) {
		// declare rem[] array
		int rem[] = new int[divisor.length];
		int i;
		int data[] = new int[oldData.length + divisor.length];
	// use system's arraycopy() method for copying data into rem and data arrays
		System.arraycopy(oldData, 0, data, 0, oldData.length);
		System.arraycopy(data, 0, rem, 0, divisor.length);
		// iterate the oldData and exor the bits of the remainder and the divisor
		for(i = 0; i < oldData.length; i++) {
			System.out.println((i+1) + ".) First data bit is : "+ rem[0]);
			System.out.print("Remainder : ");
			if(rem[0] == 1) {
				// We have to exor the remainder bits with divisor bits
				for(int j = 1; j < divisor.length; j++) {
					rem[j-1] = exorOperation(rem[j], divisor[j]);
					System.out.print(rem[j-1]);
				}
			}
			else {
				// We have to exor the remainder bits with 0
				for(int j = 1; j < divisor.length; j++) {
					rem[j-1] = exorOperation(rem[j], 0);
					System.out.print(rem[j-1]);
				}
			}
			// The last bit of the remainder will be taken from the data
			// This is the 'carry' taken from the dividend after every step
			// of division
			rem[divisor.length-1] = data[i+divisor.length];
			System.out.println(rem[divisor.length-1]);
		}
		return rem;
	}
	// create exorOperation() method to perform exor data
	static int exorOperation(int x, int y) {
		// This simple function returns the exor of two bits
		if(x == y) {
			return 0;
		}
		return 1;
	}
	// method to print received data 
	static void receiveData(int data[], int divisor[]) {
	 
		int rem[] = divideDataWithDivisor(data, divisor);
		// Division is done
		for(int i = 0; i < rem.length; i++) {
			if(rem[i] != 0) {
				// if the remainder is not equal to zero, data is currupted
				System.out.println("Currupted data received...");
				return;
			}
		}
		System.out.println("Data received without any error.");
	}
}

输出