Java 中的汉明码

2025年3月17日 | 阅读 7 分钟

海明码是一种在计算机网络中用于纠错的特殊编码。在计算机图形学中，它主要用于检测和纠正在数据从发送方传输到接收方时发生的错误。在Java中，我们可以使用海明码来实现检测和纠错。

该编码之所以被称为海明码，是因为它是由R.W. Hamming开发用于检测和纠错的。

冗余位和奇偶校验位在检测和纠错中起着重要作用。冗余位是添加到原始数据位中的额外二进制位，这些位准备从发送方传输到接收方，以确保在数据传输过程中没有位丢失。

奇偶校验位是添加到原始数据（二进制位）中的额外位，以便1的总数为偶数或奇数。

要了解更多关于海明码、冗余位和奇偶校验位的信息，请查看部分。

通用海明码算法

我们使用奇偶校验位来识别和纠正错误，使用奇偶校验位识别错误的过程称为海明码。海明码的步骤如下：

第一步，我们将位位置以二进制形式写出。位位置应从1开始（1, 10, 11, 100 等）。
我们将所有是2的幂的位标记为奇偶校验位（1, 2, 4, 8 等）。
我们将所有其他位标记为数据位。
每个数据位都包含在一组唯一的奇偶校验位中，其确定方式取决于其在二进制形式中的位位置。
1. 从最低有效位开始，二进制表示的第4位为1的所有位位置（8-15, 24-31, 40-47 等）由第8个奇偶校验位覆盖。
2. 从最低有效位开始，二进制表示的第3位为1的所有位位置（4-7, 12-15, 20-23 等）由第4个奇偶校验位覆盖。
3. 从最低有效位开始，二进制表示的第2位为1的所有位位置（2, 3, 6, 7, 10, 11 等）由第2个奇偶校验位覆盖。
4. 从最低有效位开始，二进制表示的最低有效位为1的所有位位置（1, 3, 5, 7, 9, 11 等）由第二个奇偶校验位覆盖。
5. 所有位，其中奇偶校验位置与位位置的按位AND非零，都被每个奇偶校验位覆盖。
由于我们检查偶数校验，因此如果它检查的位置中的1的总数为
奇数，则将奇偶校验位置1。
如果它检查的位置中的1的总数为偶数，则将奇偶校验位置0。

让我们通过参考上述步骤在Java中实现海明码逻辑

HammingCodeExample.java

// import required classes and packages
package javaTpoint.JavaExample;
import java.util.*;

// create HammingCodeExample class to implement the Hamming Code functionality in Java
class HammingCodeExample {
	
	// main() method start
	public static void main(String args[]) 
	{
		// declare variables and array
		int size, hammingCodeSize, errorPosition;
		int arr[];
		int hammingCode[];
		// create scanner class object to take input from user
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter the bits size for the data.");
		size = sc.nextInt();
		// initialize array
		arr = new int[size];
		// get data from user which we want to transfer 
		for(int j = 0 ; j < size ; j++) {
			System.out.println("Enter " + (size - j) + "-bit of the data:");
			// fill array with user entered data
			arr[size - j - 1] = sc.nextInt();
		}
		
		// print the user entered data
		System.out.println("The data which you enter is:");
		for(int k = 0 ; k < size ; k++) {
			System.out.print(arr[size - k - 1]);
		}
		System.out.println();	// for next line
		
		// call getHammingCode() method and store its return value to the hammingCode array
		hammingCode = getHammingCode(arr);
		hammingCodeSize = hammingCode.length;
		
		System.out.println("The hamming code generated for your data is:");
		for(int i = 0 ; i < hammingCodeSize; i++) {
			System.out.print(hammingCode[(hammingCodeSize - i - 1)]);
		}
		System.out.println();	// for next line
	
		// The added parity bits are the difference b/w the original data and the returned hammingCode
		System.out.println("For detecting error at the reciever end, enter position of a bit to alter original data "
				+ "(0 for no error):");
		errorPosition = sc.nextInt();
		
		// close Scanner class object
		sc.close();
		
		// check whether the user entered position is 0 or not. 
		if(errorPosition != 0) {
			// alter bit of the user entered position
			hammingCode[errorPosition - 1] = (hammingCode[errorPosition - 1] + 1) % 2;
		}
		
		// print sent data to the receiver
		System.out.println("Sent Data is:");
		for(int k = 0; k < hammingCodeSize; k++) {
			System.out.print(hammingCode[hammingCodeSize - k - 1]);
		}
		System.out.println();	// for next line
		receiveData(hammingCode, hammingCodeSize - arr.length);
	}
	// create getHammingCode() method that returns the hamming code for the data which we want to send
	static int[] getHammingCode(int data[]) {
		// declare an array that will store the hamming code for the data 
		int returnData[];
		int size;
		// code to get the required number of parity bits
		int i = 0, parityBits = 0 ,j = 0, k = 0;
		size = data.length;
		while(i < size) {
			// 2 power of parity bits must equal to the current position(number of bits traversed + number of parity bits + 1).
			if(Math.pow(2, parityBits) == (i + parityBits + 1)) {
				parityBits++;
			}
			else {
				i++;
			}
		}
		
		// the size of the returnData is equal to the size of the original data + the number of parity bits.
		returnData = new int[size + parityBits];
	
		// for indicating an unset value in parity bit location, we initialize returnData array with '2'
	
		for(i = 1; i <= returnData.length; i++) {
			// condition to find parity bit location
			if(Math.pow(2, j) == i) {
			
				returnData[(i - 1)] = 2;
				j++;
			}
			else {
				returnData[(k + j)] = data[k++];
			}
		}
		// use for loop to set even parity bits at parity bit locations
		for(i = 0; i < parityBits; i++) {
		
			returnData[((int) Math.pow(2, i)) - 1] = getParityBit(returnData, i);
		}
		
		return returnData;
	}
	
	// create getParityBit() method that return parity bit based on the power
	static int getParityBit(int returnData[], int pow) {
		int parityBit = 0;
		int size = returnData.length;
		
		for(int i = 0; i < size; i++) {
			
			// check whether returnData[i] contains an unset value or not
			if(returnData[i] != 2) {
				
				// if not, we save the index in k by increasing 1 in its value
				
				int k = (i + 1);
				
				// convert the value of k into binary
				String str = Integer.toBinaryString(k);
			
				//Now, if the bit at the 2^(power) location of the binary value of index is 1, 
				// we check the value stored at that location. If the value is 1 or 0, 
				// we will calculate the parity value.
			
				int temp = ((Integer.parseInt(str)) / ((int) Math.pow(10, pow))) % 10;
				if(temp == 1) {
					if(returnData[i] == 1) {
						parityBit = (parityBit + 1) % 2;
					}
				}
			}
		}
		return parityBit;
	}

	// create receiveData() method to detect error in the received data
	static void receiveData(int data[], int parityBits) {
		
		// declare variable pow, which we use to get the correct bits to check for parity.
		int pow;
		int size = data.length;		
		// declare parityArray to store the value of parity check
		int parityArray[] = new int[parityBits];
		// we use errorLoc string for storing the integer value of the error location.
		String errorLoc = new String();
		// use for loop to check the parities
		for(pow = 0; pow < parityBits; pow++) {
			// use for loop to extract the bit from 2^(power)
			for(int i = 0; i < size; i++) {
				int j = i + 1;
				// convert the value of j into binary
				String str = Integer.toBinaryString(j);
				// find bit by using str
				int bit = ((Integer.parseInt(str)) / ((int) Math.pow(10, pow))) % 10;
				if(bit == 1) {
					if(data[i] == 1) {
						parityArray[pow] = (parityArray[pow] + 1) % 2;
					}
				}
			}
			errorLoc = parityArray[pow] + errorLoc;
		}
		// This gives us the parity check equation values.
		// Using these values, we will now check if there is a single bit error and then correct it.
		// errorLoc provides parity check eq. values which we use to check whether a single bit error is there or not
		// if present, we correct it
		int finalLoc = Integer.parseInt(errorLoc, 2);
		// check whether the finalLoc value is 0 or not
		if(finalLoc != 0) {
			System.out.println("Error is found at location " + finalLoc + ".");
			data[finalLoc - 1] = (data[finalLoc - 1] + 1) % 2;
			System.out.println("After correcting the error, the code is:");
			for(int i = 0; i < size; i++) {
				System.out.print(data[size - i - 1]);
			}
			System.out.println();
		}
		else {
			System.out.println("There is no error in the received data.");
		}
		// print the original data
		System.out.println("The data sent from the sender:");
		pow = parityBits - 1;
		for(int k = size; k > 0; k--) {
			if(Math.pow(2, pow) != k) {
				System.out.print(data[k - 1]);
			}
			else {
				// decrement value of pow
				pow--;
			}
		}
		System.out.println();	// for next line
	}
}

输出

下一主题Java中的Map of Map

Java 中的汉明码

通用海明码算法

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的汉明码

通用海明码算法

相关帖子

如何在 Java 中分解日期和时间

Stack Using Two Queues in Java

Java 工具和命令列表

How to Remove Last Character from String in Java

Java 中一个类中的两个构造函数

PipedInputStream and PipedOutputStream classes

Java 中二叉树的底视图

Java 中将 JSON 转换为 XML

Resolving Conflicts During Multiple Inheritance in Java

2022 年 Java 开发者的职业选择

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器