二进制字符串到十六进制字符串java

Question

I have this code here, which get a plain text, and turns it to a 512-bit binary string. Then, I would like to turn each 32-bit piece of the string to 8-bit of Hex string, but that part gives me a java.lang.NumberFormatException

// ----- Turning the message to bits
        byte[] binaryS = s.getBytes("UTF-8");
        String mesInBinary = "";
        for (byte b : binaryS) {
            mesInBinary += '0' + Integer.toBinaryString(b);
        }
        // ----- Message padding & Pre-Processing
        // Binary representation of the length of the message in bits
        String mesBitLength = Integer.toBinaryString(mesInBinary.length());
        // We need the size of the message in 64-bits, so we'll
        // append zeros to the binary length of the message so
        // we get 64-bit
        String appendedZeros = "";
        for (int i = 64 - mesBitLength.length() ; i > 0 ; i--)
            appendedZeros += '0';
        // Calculating the k zeros to append to the message after
        // the appended '1'
        int numberOfZeros = (448 - (mesInBinary.length() + 1)) % 512;
        // Append '1' to the message
        mesInBinary += '1';
        // We need a positive k
        while (numberOfZeros < 0)
            numberOfZeros += 512;
        for (int i = 1 ; i <= numberOfZeros ; i++)
            mesInBinary += '0';
        // append the message length in 64-bit format
        mesInBinary += appendedZeros + mesBitLength;
        System.out.println(mesInBinary);
        // ----- Parsing the padded message
        // Breaking the message to 512-bit pieces
        // And each piece, to 16 32-bit word blocks
        String[] chunks = new String[mesInBinary.length() / 512];
        String[] words = new String[64 * chunks.length];
        for (int i = 0 ; i < chunks.length ; i++) {
            chunks[i] = mesInBinary.substring((512 * i), (512 * (i + 1)));
            // Break each chunk to 16 32-bit blocks
            for (int j = 0 ; j < 16 ; j++) {
                words[j] = Long.toHexString(Long.parseLong(chunks[i].substring((32 * j), (32 * (j + 1)))));
            }
        }

The last code line is the problematic one and of which I get the execption. Any suggestions?

Answer 1

The last statement ^* should specify a radix of 2, I think:

words[j] = Long.toHexString(
    Long.parseLong(chunks[i].substring((32 * j), (32 * (j + 1))), 2));

^* Not the last line of code, MДΓΓ :-)

Answer 2

From the Long docs :

public static long parseLong(String s) throws NumberFormatException :

Parses the string argument as a signed decimal long. The characters in the string must all be decimal digits...

public static long parseLong(String s, int radix) throws NumberFormatException :

Parses the string argument as a signed long in the radix specified by the second argument. The characters in the string must all be digits of the specified radix...

You're calling the first version of Long.parseLong() , which expects a decimal number, not a binary one. Use the second version with a radix of 2 to indicate binary.

EDIT: The reason being that a 32-digit decimal number won't fit into a Long , but a binary one will.

Answer 3

for (int i = 0 ; i < chunks.length ; i++) 
{
     chunks[i] = mesInBinary.substring((512 * i), (512 * (i + 1)));
     // Break each chunk to 16 32-bit blocks
     for (int j = 0 ; j < 16 ; j++) 
     {
         words[j] = Long.toHexString(Long.parseLong(chunks[i].substring((32 * j), (32 * (j + 1))),2));
     }
 }