java - बाइट को अपने बाइनरी स्ट्रिंग प्रस्तुति में कैसे परिवर्तित करें




binary byte (7)

उदाहरण के लिए, बाइट B में बिट्स 10000010 , मैं स्ट्रिंग str सचमुच बिट्स कैसे असाइन कर सकता हूं, यानी, str = "10000010"

संपादित करें

मैंने एक बाइनरी फ़ाइल से बाइट पढ़ा, और बाइट सरणी B में संग्रहीत किया। मैं System.out.println(Integer.toBinaryString(B[i])) उपयोग करता हूं System.out.println(Integer.toBinaryString(B[i])) । यह समस्या है

(ए) जब बिट्स (बाएं) 1 से शुरू होते हैं, तो आउटपुट सही नहीं होता है क्योंकि यह B[i] को ऋणात्मक int मान में परिवर्तित करता है।

(बी) यदि बिट्स 0 शुरू होते हैं, तो उत्पादन 0 अनदेखा करता है, उदाहरण के लिए, मान लें कि B[0] में 00000001 है, 00000001 बजाय आउटपुट 1


आप बाइट पर प्रत्येक बिट को चेक कर सकते हैं और स्ट्रिंग में 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();
}

क्या यह वही है आप जिसकी तलाश में हैं?

//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'));

बस अनुमान लगाओ, लेकिन अगर आपके पास बाइट है तो क्या आप ऑब्जेक्ट पर मूल्य प्राप्त करने के लिए बस स्ट्रिंग () को नहीं बुला सकते? या, byteValue () का उपयोग कर, api पर glancing?


बाइट के प्रत्येक बिट प्राप्त करें और स्ट्रिंग में कनवर्ट करें। कहें बाइट में 8 बिट हैं, और हम उन्हें थोड़ा सा स्थानांतरित करके एक-एक करके प्राप्त कर सकते हैं। उदाहरण के लिए, हम बाइट 6 बिट्स के दूसरे बिट को दाएं, दूसरी बिट 8 बिट्स के आखिरी बिट पर ले जाते हैं, और (&) 0 बिट 0001 के साथ फ्रंट बिट्स को साफ करते हैं।

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();
}

यह कोड दिखाएगा कि कैसे जावा int को लगातार 4 बाइट्स में विभाजित किया जा सकता है। इसके बाद हम निम्न स्तर बाइट / बिट पूछताछ की तुलना में जावा विधियों का उपयोग करके प्रत्येक बाइट का निरीक्षण कर सकते हैं।

जब आप नीचे दिए गए कोड को चलाते हैं तो यह अपेक्षित आउटपुट होता है:

[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() );
    }

}

Integer#toBinaryString() उपयोग करें:

byte b1 = (byte) 129;
String s1 = String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(' ', '0');
System.out.println(s1); // 10000001

byte b2 = (byte) 2;
String s2 = String.format("%8s", Integer.toBinaryString(b2 & 0xFF)).replace(' ', '0');
System.out.println(s2); // 00000010

DEMO


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();
}




byte