java - suma - Conversión de una lista entera que contiene binario a hexadecimal

suma y resta de binarios

Question

Tengo una lista de enteros que contiene algunos valores binarios

List<Integer> binary = new ArrayList();
for (int i=0; i<8; i++)
{
    bin[i] = pText[i] ^ ivKey[i]; //some binary value is calculated
    binary.add(bin[i]); //the binary list gets updated here
}

for (int i=0; i<myCipher2.size(); i++)
{
    System.out.print(binary.get(i)); //this prints the appended binary as shown in the output
}

La lista cuando se imprime da lo siguiente:

000001010100001110011101

Cada 8 bits se refiere a un hex, por lo que la salida que deseo cuando se convierta debería darme el siguiente

05 43 9d

¿Cómo puedo dividir la lista en 8 bits y convertir esos 8 bits en hex?

Answer 1

Entonces, aquí está mi opinión ...

Básicamente, esto utiliza List#subList para crear una sub-lista de la matriz binaria principal. Cada sublista contiene hasta 8 valores ...

int length = Math.min(8, bits.size());
List<Integer> byteList = bits.subList(0, length);

Luego invierte esta lista, inviertes fácilmente el orden for-loop , esto me parece más simple ...

Collections.reverse(byteList);

Luego utilizo un for-loop simple for-loop recorrer la sub-lista. Para cada bit que es 1 , simplemente agrego su equivalente binario ( Math.pow(2, index) ) al valor resultante

for (int index = 0; index < byteList.size(); index++) {
    int bit = byteList.get(index);
    if (bit == 1) {
        int pos = (int)Math.pow(2, index);
        value += pos;
    }
}

Luego remuevo los primeros n valores de la lista maestra y continúo hasta que no quede nada ...

Esto se imprimirá ...

Word = 00000101 = 5; 0x05
Word = 01000011 = 67; 0x43
Word = 10011101 = 157; 0x9d

Ejemplo ejecutable ...

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test100 {

    public static void main(String[] args) {
        List<Integer> bits = new ArrayList<Integer>(25);
        bits.add(0);
        bits.add(0);
        bits.add(0);
        bits.add(0);
        bits.add(0);
        bits.add(1);
        bits.add(0);
        bits.add(1);

        bits.add(0);
        bits.add(1);
        bits.add(0);
        bits.add(0);
        bits.add(0);
        bits.add(0);
        bits.add(1);
        bits.add(1);

        bits.add(1);
        bits.add(0);
        bits.add(0);
        bits.add(1);
        bits.add(1);
        bits.add(1);
        bits.add(0);
        bits.add(1);

        System.out.println();

        while (bits.size() > 0) {

            int length = Math.min(8, bits.size());
            List<Integer> byteList = bits.subList(0, length);
            Collections.reverse(byteList);
            int value = 0;
            StringBuilder binary = new StringBuilder(8);
            for (int index = 0; index < byteList.size(); index++) {
                int bit = byteList.get(index);
                if (bit == 1) {
                    int pos = (int)Math.pow(2, index);
                    value += pos;
                }
                binary.insert(0, bit);
            }

            System.out.println("Word = " + binary + " = " + value + "; 0x" + pad(2, Integer.toHexString(value)));

            int size = Math.max(0, bits.size());
            bits = bits.subList(length, size);

        }
    }

    public static String pad(int length, String value) {
        StringBuilder zeros = new StringBuilder(value);
        while (zeros.length() < length) {
            zeros.insert(0, "0");
        }
        return zeros.toString();
    }

}

Answer 2

Lo primero es lo primero, no debe declarar objetos genéricos con tipos crudos, agregue un tipo a su ArrayList :

List<Integer> binary = new ArrayList<Integer>();

Dado que no está directamente relacionado con su pregunta, puede leer por qué debe hacer esto aquí

Ahora, ya que su lista contiene dígitos binarios individuales, lo que puede hacer es usar un StringBuilder para construir cadenas binarias de 8 bits a partir de él. También puede usar un StringBuilder para construir el valor hexadecimal convertido. Cada vez que construyes esta cadena de 8 bits, la conviertes en hexadecimal (en realidad primero a decimal y luego a hexadecimal) y la anexas a StringBuilder luego crea la cadena hexagonal.

Aquí está el código:

// ... your program

StringBuilder hexString = new StringBuilder();
StringBuilder eightBits = new StringBuilder();
for(int i = 0; i < binary.size(); i += 8) {                 
    for(int j = i; j < (i + 8) && j < binary.size(); j++) { // read next 8 bits or whatever bits are remaining
        eightBits.append(binary.get(j)); // build 8 bit value
    }
    int decimal = Integer.parseInt(eightBits.toString(), 2); // get decimal value
    hexString.append(Integer.toHexString(decimal) + " "); // add hex value to the hex string and a space for readability 
    eightBits.setLength(0); // reset so we can append the new 8 bits
}
System.out.println(hexString.toString()); // prints "5 43 9d" for the value you gave

Nota: este programa es una continuación de su programa

Answer 3

Puede crear una cadena binaria y convertirla a decimal y luego a hexadecimal:

    int[] arr = {0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,1,0,0,1,1,1,0,1};
    int i = 0;
    while (i < arr.length) {
        String res = "";
        for(int j = 0; j < 8; j++) {
            res += arr[i];
            i++;
        }
        System.out.println(Integer.toHexString(Integer.parseInt(res, 2)));
    }

SALIDA

5
43
9d