बाइट को उसके बाइनरी स्ट्रिंग प्रतिनिधित्व में कैसे परिवर्तित करें

Question

उदाहरण के लिए, एक बाइट में बिट्स Bहैं 10000010, मैं स्ट्रिंग को strशाब्दिक रूप से कैसे आवंटित कर सकता हूं, अर्थात् str = "10000010"।

संपादित करें

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

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

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

Comments

मैं उलझन में हूं; क्या यह एक चाल है?

— डेव न्यूटन

क्या आप पूछ रहे हैं कि byteआधार 2 में स्ट्रिंग को कैसे कन्वर्ट किया जाए?

— स्लाक्स

मैं सिर्फ यह कर (बाइनरी अंकों के एक स्ट्रिंग के लिए एक मूल्य परिवर्तित) के लिए एक और धागा जिसके लिए काम करता है के लिए एक उत्तर जोड़ा Boolean, Byte, Short, Char, Int, और Long। stackoverflow.com/a/54950845/501113

— chaotic3quilibrium

स्ट्रिंग # प्रारूप () इसे संभालने में सक्षम हो सकता है, यदि आपने इसे 8. की चौड़ाई का उपयोग करने के लिए कहा था। इसी तरह System.out.printf ()।

— खानाबदोश

Answer 1

उपयोग करें 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

डेमो ।

Comments

मैंने यह तरीका आजमाया। मेरे मामले में, मैं बाइट को बाइनरी फ़ाइल से पढ़ता हूं, और बाइट सरणी में संग्रहीत किया जाता है B। मैं उपयोग करता हूं System.out.println(Integer.toBinaryString(B[i]))। जब मैं इस तरीकों का उपयोग करता हूं, तो समस्या (ए) जब बिट्स (सबसे बाईं ओर) 1 से शुरू होती है, तो आउटपुट सही नहीं होता है क्योंकि यह B[i]एक नकारात्मक इंट वैल्यू में बदल जाता है। (b) यदि बिट्स 0 से शुरू होता है, तो आउटपुट इग्नोर होता है 0, उदाहरण के लिए, मान लें B[0]कि 00000001इसकी 1जगह आउटपुट है00000001

— सीन

@ सीन: ए) इसलिए होता है क्योंकि byteजावा में एक 8-बिट हस्ताक्षरित दो के पूरक पूर्णांक है। इसका न्यूनतम मूल्य -128 (2 ^ 8) है, और इसका अधिकतम मूल्य है 127; बी) आप इसे आसानी से ठीक कर सकते हैं कि String.format("%8s", Integer.toBinaryString(b)).replace(' ', '0')इसके परिणामस्वरूप बाएं स्ट्रिंग को शून्य के साथ पैड का उपयोग करके ।

— जोहो सिल्वा

@ जोआओ: आपकी सलाह के लिए धन्यवाद। क्या आपको पता है कि मूल बिट प्रारूप (1 से शुरू होता है) को स्ट्रिंग में कैसे संग्रहीत किया जाए?

— सीन

@ सीन: हां, बस &इसके साथ 0xFF।

— जोहो सिल्वा

@ सीन: & 0xFFमूल रूप से ए signed byteको कनवर्ट करता है unsigned integer। उदाहरण के लिए, -129जैसा आपने कहा, द्वारा दर्शाया गया है 11111111111111111111111110000001। इस मामले में, आप मूल रूप से पहला (कम से कम महत्वपूर्ण) 8 बिट चाहते हैं, इसलिए आप ( &) के साथ 0xFF( 00000000000000000000000011111111), प्रभावी रूप से 1 के बाईं ओर सफाई करते हैं जिसे हम परवाह नहीं करते हैं, बस बाहर निकलते हुए 10000001।

— जोओ सिल्वा

Answer 2

मैंने इसका इस्तेमाल किया। अन्य उत्तरों के समान विचार, लेकिन कहीं भी सटीक दृष्टिकोण नहीं देखा :)

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

0xFF255 है, 11111111(एक अहस्ताक्षरित बाइट के लिए अधिकतम मूल्य)। 0x100256, या है100000000

&एक पूर्णांक के लिए बाइट upcasts। उस बिंदु पर, यह कुछ भी हो सकता है 0- 255( 00000000से 11111111, मैंने अग्रणी 24 बिट्स को बाहर कर दिया)। + 0x100और .substring(1)यह सुनिश्चित करेंगे कि अग्रणी शून्य होंगे।

मैंने इसे जोओ सिल्वा के उत्तर की तुलना में समय दिया , और यह 10 गुना अधिक तेज है। http://ideone.com/22DDK1 मैंने Pshemo के उत्तर को शामिल नहीं किया क्योंकि यह ठीक से पैड नहीं करता है।

Comments

हे! इस बारे में एक सवाल मिला। मेरे पास एक पीडीएफ का बेस 64 प्रतिनिधित्व स्ट्रिंग है, मुझे बाइनरी में बदलने की आवश्यकता है। मूल रूप से, Base64-> बाइट-> बाइनरी। क्या यह कोड काम करेगा?

— सिड

वास्तव में + 0x100 क्या करता है? आप परिणामी पूर्णांक में 256 जोड़ रहे हैं, लेकिन क्यों?

— कोनर डासन

@ConnerDassen यह सुनिश्चित करता है कि बाइनरी स्ट्रिंग 0 गद्देदार है। उदाहरण के लिए, अगर bहै 1, बिना + 0x100तुम सिर्फ मिल जाएगा "1"अपने स्ट्रिंग के रूप में। जोड़कर 1, आप प्राप्त करते हैं 100000001, और यदि आप पहले चरित्र की अनदेखी करते हुए प्रतिस्थापन लेते हैं तो आपको उचित मिलेगा "00000001"। यदि आप नहीं चाहते कि आपका तार गद्देदार हो तो आप आसानी से उपयोग कर सकते हैं Integer.toBinaryString(b & 0xff)। & 0xffफिक्स नकारात्मक / दो के पूरक मुद्दों

— Raekye

Answer 3

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

स्ट्रिंग से बाइट में परिवर्तित करना

byte b = (byte)(int)Integer.valueOf("10000010", 2);
System.out.println(b);// output -> -126

बाइट से स्ट्रिंग में परिवर्तित करना

System.out.println(Integer.toBinaryString((b+256)%256));// output -> "10000010"

या जैसा कि जोआओ सिल्वा ने अपनी टिप्पणी में कहा कि 0हम अग्रणी स्ट्रिंग को 8 की लंबाई में प्रारूपित कर सकते हैं और परिणामी अग्रणी स्थानों को शून्य के साथ बदल सकते हैं, इसलिए स्ट्रिंग के मामले में जैसे " 1010"हम प्राप्त करेंगे"00001010"

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

Answer 4

आप बाइट पर प्रत्येक बिट की जाँच कर सकते हैं फिर एक स्ट्रिंग के लिए 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();
}

Answer 5

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

Comments

क्या आप इस प्रश्न का उत्तर क्यों देते हैं, इसका स्पष्टीकरण देने के लिए कृपया अपना उत्तर संपादित कर सकते हैं ? कोड-केवल उत्तर हतोत्साहित किए जाते हैं , क्योंकि वे समाधान नहीं सिखाते हैं।

— डेविडपोस्टिल

Answer 6

यह कोड प्रदर्शित करेगा कि कैसे एक जावा इंट को लगातार 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() );
    }

}

Answer 7

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

Answer 8

क्षमा करें, मुझे पता है कि यह थोड़ा देर हो चुकी है ... लेकिन मेरे पास बहुत आसान तरीका है ... बाइनरी स्ट्रिंग के लिए:

//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 string to add all the zeros
    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < (max - bitStr.length()); i ++){
        sb.append("0");
    }

    return sb.toString()+ bitStr;
}

Answer 9

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

Answer 10

हम सभी जानते हैं कि जावा अहस्ताक्षरित खोजशब्द की तरह कुछ भी प्रदान नहीं करता है। इसके अलावा, byteजावा की कल्पना के अनुसार एक आदिम −128और के बीच एक मूल्य का प्रतिनिधित्व करता है 127। उदाहरण के लिए, अगर एक byteहै castएक करने के लिए intजावा पहले की व्याख्या करेगा bitके रूप में signऔर उपयोग पर हस्ताक्षर विस्तार।

फिर, बाइट 127को उसके बाइनरी स्ट्रिंग प्रतिनिधित्व से अधिक कैसे परिवर्तित किया जाए ??

कुछ भी नहीं आपको byteकेवल 8-बिट्स को देखने से रोकता है और उन बिट्स के बीच 0और मान के रूप में व्याख्या करता है 255। इसके अलावा, आपको यह ध्यान रखने की आवश्यकता है कि ऐसा कुछ भी नहीं है जो आप किसी अन्य की विधि पर अपनी व्याख्या को लागू करने के लिए कर सकते हैं। यदि कोई विधि एक को स्वीकार करती है byte, तो वह विधि बीच में एक मूल्य को स्वीकार करती है −128और 127जब तक कि स्पष्ट रूप से अन्यथा न कहा गया हो।

तो इसे हल करने का सबसे अच्छा तरीका byteमूल्य को विधि में परिवर्तित intकरके Byte.toUnsignedInt()या इसे एक intआदिम के रूप में कास्टिंग करना है (int) signedByte & 0xFF। यहाँ आपके पास एक उदाहरण है:

public class BinaryOperations
{
    public static void main(String[] args)
    {
        byte forbiddenZeroBit = (byte) 0x80;

        buffer[0] = (byte) (forbiddenZeroBit & 0xFF);
        buffer[1] = (byte) ((forbiddenZeroBit | (49 << 1)) & 0xFF);
        buffer[2] = (byte) 96;
        buffer[3] = (byte) 234;

        System.out.println("8-bit header:");
        printBynary(buffer);
    }

    public static void printBuffer(byte[] buffer)
    {
        for (byte num : buffer) {
            printBynary(num);
        }
    }

    public static void printBynary(byte num)
    {
        int aux = Byte.toUnsignedInt(num);
        // int aux = (int) num & 0xFF; 
        String binary = String.format("%8s', Integer.toBinaryString(aux)).replace(' ', '0');
        System.out.println(binary);
    }
}

उत्पादन

8-bit header:
10000000
11100010
01100000
11101010

Answer 11

आप उदाहरण के लिए बिगइन्टेगर के साथ काम कर सकते हैं , खासकर यदि आपके पास 256 बिट या अधिक समय है:

String string = "10000010";
BigInteger biStr = new BigInteger(string, 2);

System.out.println("binary: " + biStr.toString(2));
System.out.println("hex: " + biStr.toString(16));
System.out.println("dec: " + biStr.toString(10));

एक और उदाहरण जो बाइट्स स्वीकार करता है:

String string = "The girl on the red dress.";

byte[] byteString = string.getBytes(Charset.forName("UTF-8"));
System.out.println("[Input String]: " + string);
System.out.println("[Encoded String UTF-8]: " + byteString);

BigInteger biStr = new BigInteger(byteString);
System.out.println("binary: " + biStr.toString(2)); // binary
System.out.println("hex: " + biStr.toString(16));   // hex or base 16
System.out.println("dec: " + biStr.toString(10));  // this is base 10

परिणाम:

[Input String]: The girl on the red dress.
[Encoded String UTF-8]: [B@70dea4e

binary: 101010001101000011001010010000001100111011010010111001001101100001000000110111101101110001000000111010001101000011001010010000001110010011001010110010000100000011001000111001001100101011100110111001100101110
hex: 546865206769726c206f6e20746865207265642064726573732e

---

आप बाइनरी को बाइट प्रारूप में बदलने के लिए भी काम कर सकते हैं

try {
   System.out.println("binary to byte: " + biStr.toString(2).getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {e.printStackTrace();}

---

नोट: अपने द्विआधारी प्रारूप के लिए स्ट्रिंग प्रारूपण के लिए आप नीचे नमूने का उपयोग कर सकते हैं

String.format("%256s", biStr.toString(2).replace(' ', '0'));  // this is for the 256 bit formatting

Answer 12

एक सरल उत्तर हो सकता है:

System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 0
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1})); // 1
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0})); // 256
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0})); // 65536
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0})); // 16777216
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0})); // 4294967296
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0})); // 1099511627776
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0})); // 281474976710656
System.out.println(new BigInteger(new byte[]{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0})); // 72057594037927936
System.out.println(new BigInteger(new byte[]{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0})); // 18446744073709551616
System.out.println(new BigInteger(new byte[]{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 4722366482869645213696
System.out.println(new BigInteger(new byte[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 1208925819614629174706176
System.out.println(Long.MAX_VALUE);                                              // 9223372036854775807

Answer 13

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