Как преобразовать байт в двоичное строковое представление

я использовал это. Аналогичная идея с другими ответами, но нигде не видел точного подхода:)

System.out.println(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));

0xFF равно 255, или 11111111 (максимальное значение для беззнакового байта). 0x100 - это 256 или 100000000

The & преобразует байт в целое число. В этот момент, это может быть что угодно от 0 -255 (00000000 до 11111111, Я исключил ведущие 24 бита). + 0x100 и .substring(1) убедитесь, что там будут нули.

я приурочил его по сравнению к ответ Жоао Сильвы, а это более чем в 10 раз быстрее. http://ideone.com/22DDK1 я не включил ответ Пшемо, поскольку он не заполняется должным образом.

это то, что вы ищете?

//converting from String to byte    
Byte b= (byte)(int)Integer.valueOf("10000010", 2);
System.out.println(b);// output -> -126
//converting from byte to String    
System.out.println(Integer.toBinaryString((b+256)%256));// output -> "10000010"

или как сказал Жоао Силва в своем комментарии

System.out.println(String.format("%8s",
            Integer.toBinaryString((b + 256) % 256)).replace(' ', '0'));

этот код продемонстрирует, как Java int можно разделить на 4 последовательных байта. Затем мы можем проверить каждый байт с помощью методов Java по сравнению с низкоуровневым байт / битовым запросом.

это ожидаемый результат при выполнении кода ниже:

[Input] Integer value: 8549658

Integer.toBinaryString: 100000100111010100011010
Integer.toHexString: 82751a
Integer.bitCount: 10

Byte 4th Hex Str: 0
Byte 3rd Hex Str: 820000
Byte 2nd Hex Str: 7500
Byte 1st Hex Str: 1a

(1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: 82751a
(1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): true

Individual bits for each byte in a 4 byte int:
00000000 10000010 01110101 00011010

вот код:

public class BitsSetCount
{
    public static void main(String[] args) 
    {
        int send = 8549658;

        System.out.println( "[Input] Integer value: " + send + "\n" );
        BitsSetCount.countBits(  send );
    }

    private static void countBits(int i) 
    {
        System.out.println( "Integer.toBinaryString: " + Integer.toBinaryString(i) );
        System.out.println( "Integer.toHexString: " + Integer.toHexString(i) );
        System.out.println( "Integer.bitCount: "+ Integer.bitCount(i) );

        int d = i & 0xff000000;
        int c = i & 0xff0000;
        int b = i & 0xff00;
        int a = i & 0xff;

        System.out.println( "\nByte 4th Hex Str: " + Integer.toHexString(d) );
        System.out.println( "Byte 3rd Hex Str: " + Integer.toHexString(c) );
        System.out.println( "Byte 2nd Hex Str: " + Integer.toHexString(b) );
        System.out.println( "Byte 1st Hex Str: " + Integer.toHexString(a) );

        int all = a+b+c+d;
        System.out.println( "\n(1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: " + Integer.toHexString(all) );

        System.out.println("(1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): " + 
                Integer.toHexString(all).equals(Integer.toHexString(i) ) );

        System.out.println( "\nIndividual bits for each byte in a 4 byte int:");

        /*
         * Because we are sending the MSF bytes to a method
         * which will work on a single byte and print some
         * bits we are generalising the MSF bytes
         * by making them all the same in terms of their position
         * purely for the purpose of printing or analysis
         */
        System.out.print( 
                    getBits( (byte) (d >> 24) ) + " " + 
                    getBits( (byte) (c >> 16) ) + " " + 
                    getBits( (byte) (b >> 8) ) + " " + 
                    getBits( (byte) (a >> 0) ) 
        );


    }

    private static String getBits( byte inByte )
    {
        // Go through each bit with a mask
        StringBuilder builder = new StringBuilder();
        for ( int j = 0; j < 8; j++ )
        {
            // Shift each bit by 1 starting at zero shift
            byte tmp =  (byte) ( inByte >> j );

            // Check byte with mask 00000001 for LSB
            int expect1 = tmp & 0x01; 

            builder.append(expect1);
        }
        return ( builder.reverse().toString() );
    }

}

вы можете проверить каждый бит на байте, а затем добавить либо 0, либо 1 в строку. Вот небольшой вспомогательный метод, который я написал для тестирования:

public static String byteToString(byte b) {
    byte[] masks = { -128, 64, 32, 16, 8, 4, 2, 1 };
    StringBuilder builder = new StringBuilder();
    for (byte m : masks) {
        if ((b & m) == m) {
            builder.append('1');
        } else {
            builder.append('0');
        }
    }
    return builder.toString();
}

сделать каждый бит байта и преобразовать в строку. Скажем, байт имеет 8 бит, и мы можем получить их один за другим с помощью битового перемещения. Например, мы перемещаем второй бит байта 6 бит вправо, второй бит, наконец, бит 8 бит, а затем и(&) с 0x0001 для очистки передних битов.

public static String getByteBinaryString(byte b) {
    StringBuilder sb = new StringBuilder();
    for (int i = 7; i >= 0; --i) {
        sb.append(b >>> i & 1);
    }
    return sb.toString();
}

Извините, я знаю, это немного поздно... Но у меня есть гораздо более простой способ... В двоичную строку :

//Add 128 to get a value from 0 - 255
String bs = Integer.toBinaryString(data[i]+128);
bs = getCorrectBits(bs, 8);

метод getCorrectBits:

private static String getCorrectBits(String bitStr, int max){
    //Create a temp str to add all the zeros
    String tmpStr = "";
    for(int i = 0; i < (max - bitStr.length()); i ++){
        tmpStr += "0";
    }

    return tmpStr + bitStr;
}

Integer.toBinaryString((byteValue & 0xFF) + 256).substring(1)

просто угадать здесь, но если у вас есть байт, то не могли бы вы просто вызвать toString() на объект, чтобы получить значение? Или, взглянув на api, используя byteValue()?

String byteToBinaryString(byte b){
    StringBuilder binaryStringBuilder = new StringBuilder();
    for(int i = 0; i < 8; i++)
        binaryStringBuilder.append(((0x80 >>> i) & b) == 0? '0':'1');
    return binaryStringBuilder.toString();
}