/*
 * crc校驗,輸入一個數組,返回一個數組,返回的陣列比原陣列
 * 多了兩個位元組,也就是兩個校驗碼,低位元組在前,高位元組在後.
 */
public class CRC16 {
 public static int[] crc(int[] data){
  int[] temdata=new int[data.length+2];
  //unsigned char alen = *aStr – 2;   //CRC16只計算前兩部分      
   int xda , xdapoly ;          
   int i,j, xdabit ;           
   xda = 0xFFFF ; 
  xdapoly = 0xA001 ; // (X**16 + X**15 + X**2 + 1)  
  for(i=0;i<data.length;i++)        
  {        
  xda ^= data[i] ;
  for(j=0;j<8;j++) {        
   xdabit =( int )(xda & 0x01) ;        
   xda >>= 1 ;
  if( xdabit==1 )
   xda ^= xdapoly ;
   }       
  }   
  System.arraycopy(data, 0, temdata, 0, data.length);
  temdata[temdata.length-2] = (int)(xda & 0xFF) ;          
  temdata[temdata.length-1] = (int)(xda>>8) ;    
  return temdata;
  }

//這個主函式用來測試用的
 public static void main(String args[]){
  int[] data={12,25,1,4,10,5,47,2,45,2,3,4,7,5,6,2,45};
  int[] d1=crc(data);
  for(int i=0;i<d1.length;i++)
   System.out.print(d1[i]+" ");
  System.out.println();
  int[] d2=crc(d1);
  for(int i=0;i<d2.length;i++)
   System.out.print(d2[i]+" ");
 }

}

==================================================================================

下面是C++的演算法和參考原始碼;

4 校驗碼      
CRC碼由傳送端計算，放置於傳送資訊報文的尾部。接收資訊的裝置再重新計算接收到資訊報文的CRC，比較計算得到
的CRC是否與接收到的相符，如果兩者不相符，則表明出錯。       
校驗碼的計算多項式為(X16 + X15 + X2 + 1)。       
具體CRC16碼的
計算方法是：        
1．預置1個16位的暫存器為十六進位制FFFF（即全為1）；稱此暫存器為CRC暫存器；      
2．把第一個8位二進位制資料 （既通訊資訊幀的第一個位元組）與16位的CRC暫存器的低8位相異或，把結果放於CRC暫存器；      
3．把CRC暫存器的內容右移一 位（朝低位）用0填補最高位，並檢查右移後的移出位；      
4．如果移出位為0：重複第3步（再次右移一位）；         
   如果移出位為1：CRC暫存器與多項式A001（1010 0000 0000 0001）進行異或；      
5．重複步驟3和4，直到右移8次，這樣整個8位資料全部進行了處理；  
6．重複步驟2到步驟5，進行通訊資訊幀下一個位元組的處理；      
7．將該通訊資訊幀所有位元組按上述步驟計算完成後，得到的16位CRC暫存器的高、低位元組進行交換；      
8．最後得到的CRC暫存器內容即為：CRC碼。     

參考演算法的C語言實現如下。以下程式
計算一個報文的CRC16並填入報文最後兩位元組。      
void CRC16( unsigned char *aStr ){             
unsigned char alen = *aStr – 2;   //CRC16只計算前兩部分      
unsigned int xda , xdapoly ;          
unsigned char i,j, xdabit ;           
 xda = 0xFFFF ;       
xdapoly = 0xA001 ; // (X**16 + X**15 + X**2 + 1)           
for(i=0;i<alen;i++)        
{        
xda ^= aStr[i] ;        
for(j=0;j<8;j++) {        
 xdabit =(unsigned char )(xda & 0x01) ;        
 xda >>= 1 ;         
if( xdabit )
 xda ^= xdapoly ;  
 }       
}              
aStr[alen-2] = (unsigned char)(xda & 0xFF) ;          
aStr[alen-1] = (unsigned char)(xda>>8) ;      
}

===============================================================================

以程式碼僅供參考,如有不明白或建議請聯絡我,共同交流,email:[email protected]

另外提供一個網上找的java crc校驗的源程式,我沒怎麼研究,

import java.io.IOException;
 
public class CRC16Checker {
 
            private static int[] index = new int[] { 16, 15, 2, 0 };
 
            private static int[] getBinary(String text) {
                        StringBuffer num = new StringBuffer();
                        String s; char ch;
                        for (int i = 0; i < text.length(); i++) { // Change each char to binary code.
                                    s = Integer.toBinaryString(text.charAt(i));
                                    // If the code is less than 8 bit, make it as 8 bit.
                                    for (int j = 8 - s.length(); j > 0; j--) num.append(0);
                                    num.append(s);
                        }
                        int len = num.length();
                        int[] code = new int[len];
                        for (int i = 0; i < len; i++) // Change each 0/1 char to int.
                            code[i] = Character.getNumericValue(num.charAt(i));
                        return code;
            }
 
            private static String toHex(int[] num) {
                        StringBuffer hex = new StringBuffer(num.length / 4);
                        char[] ch = new char[4];
                        for (int i = 0; i < num.length;) {
                            // Change each 0/1 int to char.
                                    ch[0] = Character.forDigit(num[i++], 2);
                                    ch[1] = Character.forDigit(num[i++], 2);
                                    ch[2] = Character.forDigit(num[i++], 2);
                                    ch[3] = Character.forDigit(num[i++], 2);
                                    // Change each 4-bit-code to hex number.
                                    hex.append(Integer.toHexString(Integer.parseInt(String.valueOf(ch), 2)));
                        }
                        return hex.toString();
            }
 
// CRC codes main process
            public static int[] makeCRCCodes(int[] sourceCodes, int[] multinomial) {
                        // The lenght of CRC code is N bits longer than source code. The codes
                        // from 0 to sourceLength are same as the source. N bits after source
                        // are the CRC codes. N is decided by the multinomial.
                        // CRC碼陣列總長為原碼長加上校驗碼碼長。陣列前部存放原碼。校驗碼存放在陣列
                        // 最後的N位。校驗碼長度決定於生成多項式陣列0位置上的元素。
                        int sourceLength = sourceCodes.length;
                        int codesLength = sourceLength + multinomial[0];
                        int[] crcCodes = new int[codesLength];
                        // Copy source code from 0 to sourceLength. 拷貝原碼。
                        System.arraycopy(sourceCodes, 0, crcCodes, 0, sourceLength);
                        int temp, pos;
                        // Division system. 除法器。
                        for (int i = 0; i < sourceLength; i++) {
                                    // Count value of the input adding the first register.
                                    // 用第i位原碼和第一個暫存器值模二加。
                                    temp = (crcCodes[sourceLength] + sourceCodes[i]) % 2;
                                    // Move registers forwards from (1, length) to (0, length - 1).
                                    // 第二個暫存器及以後的所有暫存器值前移1位。
                                    System.arraycopy(
                                                crcCodes, sourceLength + 1, crcCodes, sourceLength, multinomial[0] - 1);
                                    // Set the last register with counted value.
                                    // 最後一個暫存器值存放計算好的輸入值。
                                    crcCodes[codesLength - 1] = temp;
                                    // Count other registers. 按生成多項式的值算出位置，模二加出該暫存器的值。
                                    for (int j = index.length - 2; j > 0; j--) {
                                                pos = codesLength - multinomial[j] - 1;
                                                crcCodes[pos] = (crcCodes[pos] + temp) % 2;
                                    }
                        }
                        return crcCodes;
            }
 
            public static void main(String[] args) throws IOException {
                        System.out.print("Input hex data :");
                        StringBuffer buf = new StringBuffer();
                        char ch = (char) System.in.read();
                        while (ch != '/r' && ch != '/n') {
                                    buf.append(ch);
                                    ch = (char) System.in.read();
                        }
                        // Get binary codes.
                        int[] b = CRC16Checker.getBinary(buf.toString());
                        // Make CRC codes.
                        b = CRC16Checker.makeCRCCodes(b, CRC16Checker.index);
                        // Output code as binary number.
                        for (int i = 0; i < b.length;) {
                                    for (int j = 0; j < 4; j++, i++) System.out.print(b[i]);
                                    System.out.print(' ');
                        }
                        System.out.println();
                        // Output code as hex number.
                        System.out.println("The CRC16 code is :" + CRC16Checker.toHex(b));
            }
}