Java与JavaScript中相同CRC16位运算逻辑为何结果不同？

The mismatch between your Java and JavaScript CRC16 calculations boils down to two critical differences in how the languages handle numeric types and bitwise operations:

1. Signed vs. Unsigned Byte Handling #

In JavaScript, when you convert a hex pair to a character with String.fromCharCode() and fetch its value via charCodeAt(), you get an unsigned 8-bit value (ranging from 0 to 255). This aligns perfectly with the raw byte values you need for CRC calculation.

But in Java, the byte type is signed (range: -128 to 127). Any hex value greater than 0x7F (like 0xEA in your input) gets converted to a negative byte. When you run crc ^= b, the negative byte is promoted to an int with leading 1s (e.g., 0xEA becomes 0xFFFFFFEA), which corrupts the higher bits of your CRC and throws off the entire calculation.

2. Sign-Extended Bit Shifting #

Java uses arithmetic right shift (>>) for signed types, which fills the leftmost bit with the sign bit when shifting. Since negative bytes introduce unwanted sign bits into the CRC value, this shift operation doesn't behave the same way as JavaScript's bitwise operations (which, while using 32-bit signed integers, stay within the 16-bit bounds needed for CRC16).

Fixed Java Implementation #

Here's the corrected code that matches the JavaScript logic exactly:

import org.apache.commons.codec.binary.Hex;

public class CRC16Calculator {
    public static void main(String[] args) throws Exception {
        String hex = "08010000016B40D8EA30010000000000000000000000000000000105021503010101425E0F01F10000601A014E000000000000000001";
        byte[] arr = Hex.decodeHex(hex);
        int polynomial = 0xA001;
        int crc = 0x0000; // Use int instead of long for 16-bit CRC context

        for (byte b : arr) {
            crc ^= (b & 0xFF); // Convert signed byte to unsigned 8-bit value
            for (int i = 8; i != 0; i--) {
                if ((crc & 0x0001) != 0) {
                    crc >>= 1;
                    crc ^= polynomial;
                } else {
                    crc >>= 1;
                }
                crc &= 0xFFFF; // Keep CRC constrained to 16 bits
            }
        }

        System.out.println(crc); // Output: 51151
        System.out.println(String.format("%04X", crc)); // Output: C7CF
    }
}

Key Fixes Explained: #

• b & 0xFF: Converts the signed byte to an unsigned 8-bit integer, ensuring we only modify the lower 8 bits of the CRC value (matching JavaScript's behavior).
• Using int instead of long: CRC16 is a 16-bit value, so int is sufficient and avoids unnecessary 64-bit sign handling that could introduce errors.
• crc &= 0xFFFF: Ensures we always keep the CRC value within 16 bits, preventing any unintended high-bit contamination from sign extension during shifts.

内容的提问来源于stack exchange，提问作者Lapskaus