Cálculo de suma en android / java

Escribí una función de cálculo de comprobación en android / java. La función como sigue

void CalculateCheckSum( byte[] bytes ){ short CheckSum = 0, i = 0; for( i = 0; i < bytes.length; i++ ){ CheckSum = (short) ((short)CheckSum + (short)bytes[i]); } Log.i("Checksum", Integer.toHexString(CheckSum)); }

Los valores de entrada para el cálculo de la suma de comprobación son 0xEF, 0x01, 0xEF, 0x01, 0x33, 0x0C, 0xB8, 0xE5, 0xFC, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF. He calculado manualmente el valor de la suma de comprobación y el resultado es 0xCE4. Cuando se utiliza la función anterior obtener respuesta como 0xFFFFFFE4. ¿Hay algún error en mi cálculo, si es así, por favor corrijame.

Gracias

byte acuerdo con Java Docs :

El valor de un byte está comprendido entre 2^(-7) y (2^7)-1 (-128 a 127).

Pero su valor 0xEF (en decimal 239) ya ha alcanzado el límite de un byte. Eso es lo que causa la suma dar los números equivocados.

Utilice un depurador y depurar su código. Generalmente, sin embargo, si sigue agregando cosas, incluso si utiliza un int o un long , está destinado a desbordarse en algún momento, por lo que obtendrá resultados inesperados. Lo mejor es utilizar un algoritmo de suma de comprobación estándar o una de las clases ya disponibles como CRC32 o Adler31 . En cuanto a su código, usted parece estar tratando el resultado como un entero, así que ¿por qué elenco a short en el primer lugar?

Java hace todos los cálculos aritméticos utilizando int 's, por lo que su byte s convertido en int y los que no caben en un byte se verá así como int ' s: ffffffef (-17). Naturalmente sólo se necesita el valor de byte real, por lo que necesita cero todo lo demás utilizando (0xff & b) . Así que tu bucle se convierte en algo como esto:

  int checkSum = 0; for(byte b : bytes){ checkSum += (0xff & b); }

El problema aquí es el (short) elenco de bytes[i] . Extiende el signo. Debe cambiar (short)bytes[i] a (bytes[i] & 0xff) . Esto le dará la respuesta correcta.

No tiene nada que ver con el desbordamiento de bytes, contrariamente a la mayoría de las otras respuestas. No tiene que cambiar el tipo de matriz tampoco.

Como se mencionó anteriormente por aprian, mientras que el byte tiene los 8 bits necesarios para sus valores hexadecimales, sólo puede almacenar valores entre -128 y 127. Así que una solución rápida y fácil sería utilizar la siguiente primitiva más grande, en este caso short .

 short shorts[] = {0xEF, 0x01, 0xEF, 0x01, 0x33, 0x0C, 0xB8, 0xE5, 0xFC, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; int checkSum = 0; for( short s : shorts){ checkSum = checkSum + s; } System.out.println("Checksum: " + Integer.toHexString(checkSum));

Eso me da la salida:

 Checksum: ce4

Por supuesto, esto significa que puede que tenga que convertir su byte array antemano.

Finalmente conseguí

Código corregido

 void CalculateCheckSum( byte[] bytes ){ short CheckSum = 0, i = 0; for( i = 0; i < bytes.length; i++){ CheckSum += (short)(bytes[i] & 0xFF); } Log.i("Checksum", Integer.toHexString(CheckSum)); }

Gracias a aprian y otros

Debe utilizar números enteros como entrada si los convierte con:

  String CalculateCheckSum( Integer[] bytes ){ Integer CheckSum = 0, i = 0; for( i = 0; i < bytes.length; i++ ){ CheckSum += bytes[i]; } return Integer.toHexString(CheckSum); }

Esto devolverá el esperado 0xCE4 espero que este arreglo su problema