বাইটকে কীভাবে তার বাইনারি স্ট্রিং উপস্থাপনায় রূপান্তর করা যায়


95

উদাহরণস্বরূপ, একটি বাইট বিট Bহয় 10000010, কিভাবে আমি স্ট্রিং বিট ধার্য করতে পারেন str, আক্ষরিক, যে str = "10000010"

সম্পাদনা করুন

আমি বাইনারি ফাইল থেকে বাইটটি পড়ি এবং বাইট অ্যারেতে সঞ্চয় করি B। আমি ব্যবহার System.out.println(Integer.toBinaryString(B[i]))। সমস্যা হল

(ক) বিটগুলি যখন (বামতম) 1 দিয়ে শুরু হয়, আউটপুট সঠিক হয় না কারণ এটি B[i]একটি নেতিবাচক ইনট মানগুলিতে রূপান্তর করে।

(খ) যদি বিটগুলি শুরু হয় 0, আউটপুট উপেক্ষা করা হবে 0, উদাহরণস্বরূপ, B[0]ধরুন 00000001 আছে, আউটপুট 1পরিবর্তে হয়00000001


4
আমি বিভ্রান্ত; এটা কি কৌশল?
ডেভ নিউটন

4
আপনি কি byteবেস 2 তে স্ট্রিংয়ে রূপান্তর করবেন তা জিজ্ঞাসা করছেন ?
এসএলএক্স

আমি শুধু এই করছেন (বাইনারি ডিজিট একটি স্ট্রিং একটি মান রূপান্তর) জন্য অন্য থ্রেড, যার জন্য কাজ করে একটি উত্তর যোগ Boolean, Byte, Short, Char, Int, এবং Longstackoverflow.com/a/54950845/501113
chaotic3quilibrium

স্ট্রিং # ফর্ম্যাট () এটি হ্যান্ডেল করতে সক্ষম হতে পারে, যদি আপনি এটি 8 এর প্রস্থ ব্যবহার করতে বলেন তবে একইভাবে System.out.printf ()।
NomadMaker

উত্তর:


172

ব্যবহার 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

ডেমো


আমি এই পদ্ধতিটি চেষ্টা করেছিলাম। আমার ক্ষেত্রে, আমি বাইনারি ফাইল থেকে বাইটটি পড়েছি এবং বাইট অ্যারেতে সঞ্চয় করি B। আমি ব্যবহার System.out.println(Integer.toBinaryString(B[i]))। আমি যখন এই পদ্ধতিগুলি ব্যবহার করি তখন সমস্যাটি হয় (ক) বিটগুলি যখন (বামতম) 1 দিয়ে শুরু হয়, আউটপুট সঠিক হয় না কারণ এটি B[i]একটি নেতিবাচক ইনট মানগুলিতে রূপান্তর করে। (খ) যদি বিটগুলি 0 দিয়ে শুরু হয় তবে আউটপুটটি উপেক্ষা করা হবে 0, উদাহরণস্বরূপ, ধরে নেওয়া B[0]হয়েছে 00000001, আউটপুট 1পরিবর্তে হয়00000001
শ্যান

4
@ শিয়ান: ক) ঘটবে কারণ byteজাভাতে একটি 8-বিট স্বাক্ষরিত দুজনের পরিপূরক পূর্ণসংখ্যা হয়। এর সর্বনিম্ন মান -128 (2 ^ 8), এবং এর সর্বাধিক মান 127; খ) আপনি String.format("%8s", Integer.toBinaryString(b)).replace(' ', '0')বাম প্যাডে জিরোসের সাথে ফলাফলের স্ট্রিংটি ব্যবহার করে সহজেই তা ঠিক করতে পারেন ।
জোও সিলভা

4
@ জোয়াও: আপনার পরামর্শের জন্য ধন্যবাদ কীভাবে সম্বোধন করবেন (ক), কীভাবে মূল বিট ফর্ম্যাটটি (1 দিয়ে শুরু হবে) স্ট্রিংয়ে সংরক্ষণ করবেন সে সম্পর্কে আপনার কোনও ধারণা আছে?
শান

4
@ শীন: হ্যাঁ, ঠিক &এটি দিয়েই 0xFF
জোও সিলভা

14
@Sean: & 0xFFমূলত একটি পরিবর্তিত signed byteএকটি থেকে unsigned integer। উদাহরণস্বরূপ, -129যেমন আপনি বলেছেন, এটি দ্বারা প্রতিনিধিত্ব করা হয় 11111111111111111111111110000001। এই ক্ষেত্রে, আপনি মূলত প্রথম (অন্তত উল্লেখযোগ্য) 8 বিট চান যাতে আপনি এবং ( &) এটা দিয়ে 0xFF( 00000000000000000000000011111111), কার্যকরভাবে, বামে 1 এর পরিষ্কারের যে আমরা যত্ন সম্পর্কে না শুধু ছাড়ার 10000001
জোও সিলভা

37

আমি এই ব্যবহার। অন্যান্য উত্তরের অনুরূপ ধারণা, তবে কোথাও নির্ভুল পন্থা দেখতে পেল না :)

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

0xFF255 বা 11111111(স্বাক্ষরবিহীন বাইটের সর্বাধিক মান)। 0x100256, বা100000000

&একটি পূর্ণসংখ্যা বাইট upcasts। এই মুহুর্তে, এটি যে কোনও হতে পারে 0- 255( 00000000থেকে 11111111, আমি শীর্ষস্থানীয় 24 বিট বাদ দিয়েছি)। + 0x100এবং .substring(1)নিশ্চিত করুন যে সেখানে জিরো থাকবে।

জোও সিলভার উত্তরের সাথে তুলনা করে আমি এটির সময়সীমা বেঁধেছিলাম এবং এটি 10 গুণ বেশি দ্রুত over http://ideone.com/22DDK1 সঠিকভাবে প্যাড না হওয়ায় আমি Pshemo এর উত্তর অন্তর্ভুক্ত করিনি।


আরে! এই সম্পর্কে একটি প্রশ্ন পেয়েছি। আমার কাছে পিডিএফের বেস 64 প্রতিনিধিত্বমূলক স্ট্রিং রয়েছে, আমাকে বাইনারি রূপান্তর করা দরকার। মূলত, বেস 64-> বাইট-> বাইনারি.এই কোডটি কি কাজ করবে?
সিড

+ 0x100 ঠিক কী করে? আপনি ফলাফল পূর্ণসংখ্যার সাথে 256 যোগ করছেন, তবে কেন?
কনার দাসসেন

4
@ কননারডাসেন এটি বাইনারি স্ট্রিং 0 প্যাডড নিশ্চিত করে। উদাহরণস্বরূপ, যদি bহয় তবে আপনি 1ছাড়া + 0x100কেবল "1"আপনার স্ট্রিং হিসাবে পাবেন । যোগ করে 1, আপনি পেয়েছেন 100000001, এবং আপনি প্রথম চরিত্রটিকে উপেক্ষা করে স্ট্রিংগুলি গ্রহণ করলে আপনি সঠিক পাবেন "00000001"। আপনি যদি না চান যে আপনার স্ট্রিং প্যাডড হয়ে যায় তবে আপনি কেবল ব্যবহার করতে পারেন Integer.toBinaryString(b & 0xff)। The & 0xff
ণাত্মক

8

আপনি যেটা খুঁজছিলেন এটাই কি সেটা?

স্ট্রিং থেকে বাইটে রূপান্তর করা হচ্ছে

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

6

আপনি বাইটে প্রতিটি বিট পরীক্ষা করতে পারেন তারপরে 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();
}

3

প্রতিটি বিট পেতে এবং স্ট্রিংতে রূপান্তর করুন। বলুন বাইটে 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();
}

এই কোডটি কেন প্রশ্নের উত্তর দেয় তার ব্যাখ্যা দিতে আপনি দয়া করে আপনার উত্তরটি সম্পাদনা করতে পারেন? কোড-কেবল উত্তরগুলি নিরুৎসাহিত করা হয় , কারণ তারা সমাধানটি শেখায় না।
ডেভিডপস্টিল

2

এই কোডটি প্রদর্শিত হবে যে কোনও জাভা ইন্টি কীভাবে তার টানা 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() );
    }

}


2

দুঃখিত, আমি জানি এটি কিছুটা দেরি হয়ে গেছে ... তবে আমার কাছে আরও সহজ উপায় আছে ... বাইনারি স্ট্রিংয়ের জন্য:

//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;
}

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

1

আপনি বিগইন্টিজারের সাথে নীচের উদাহরণের মতো কাজ করতে পারেন , বিশেষত আপনার যদি 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

1

একটি সহজ উত্তর হতে পারে:

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

0

আমরা সবাই জানি যে জাভা স্বাক্ষরবিহীন কীওয়ার্ডের মতো কিছু সরবরাহ করে না। তদুপরি, byteজাভা অনুসারে একটি আদিম −128এবং এর মধ্যে একটি মান উপস্থাপন করে 127। উদাহরণস্বরূপ, যদি একটি byteহয় castএকটি থেকে intজাভা প্রথম কী ব্যাখ্যা দেবেন bitযেমনsign এবং ব্যবহার নিদর্শন এক্সটেনশান।

তারপরে, কীভাবে বাইটকে 127এর বাইনারি স্ট্রিং উপস্থাপনের চেয়ে বৃহত্তর রূপান্তর করা যায় ??

কিছুই আপনাকে byte8-বিট হিসাবে কেবল দেখতে বাধা দেয় না এবং সেই বিটগুলি 0এবং এর মধ্যে একটি মান হিসাবে ব্যাখ্যা করে 255। এছাড়াও, আপনার মনে রাখতে হবে যে অন্য কারও পদ্ধতির উপর আপনার ব্যাখ্যা জোর করে বলার জন্য আপনার কিছুই করার দরকার নেই। যদি কোনও পদ্ধতি কোনও গ্রহণ করে byte, তবে সেই পদ্ধতিটির মধ্যে একটি মান গ্রহণ করা হয় −128এবং 127অন্যথায় স্পষ্টভাবে বিবরণ না দেওয়া পর্যন্ত।

সুতরাং এটি সমাধানের সর্বোত্তম উপায় হল পদ্ধতিটি কল করে বা এটি আদিম হিসাবে ing ালাই করে byteমানকে একটি মানতে রূপান্তর করা । এখানে আপনার একটি উদাহরণ রয়েছে: intByte.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

0

যাঁদের বাইটারি স্ট্রিংয়ে বাইটসকে ব্যাপকভাবে রূপান্তর করতে হবে তাদের জন্য আরও একটি ইঙ্গিত: এই স্ট্রিং অপারেশনটিকে সারাক্ষণ ব্যবহারের পরিবর্তে একটি সারণী ব্যবহার করুন। বারবার রূপান্তর ফাংশন কল করার চেয়ে এটি অনেক দ্রুত

public class ByteConverterUtil {

  private static final String[] LOOKUP_TABLE = IntStream.range(0, Byte.MAX_VALUE - Byte.MIN_VALUE + 1)
                                                        .mapToObj(intValue -> Integer.toBinaryString(intValue + 0x100).substring(1))
                                                        .toArray(String[]::new);

  public static String convertByte(final byte byteValue) {
    return LOOKUP_TABLE[Byte.toUnsignedInt(byteValue)];
  }

  public static void main(String[] args){
    System.out.println(convertByte((byte)0)); //00000000
    System.out.println(convertByte((byte)2)); //00000010
    System.out.println(convertByte((byte)129)); //10000001
    System.out.println(convertByte((byte)255)); //11111111
  }


}

-1

এখানে কেবল অনুমান করা, তবে আপনার যদি বাইট থাকে তবে আপনি কী পেতে পারেন মান পেতে অবজেক্টে টস স্ট্রিং ()? অথবা, এ নেত্রপাত API , byteValue ব্যবহার ()?

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.