जावा में पूर्णांक के 0-गद्देदार बाइनरी प्रतिनिधित्व कैसे प्राप्त करें?

Question

उदाहरण के लिए, 1, 2, 128, 256आउटपुट के लिए (16 अंक) हो सकता है:

0000000000000001
0000000000000010
0000000010000000
0000000100000000

मैंने कोशिश की

String.format("%16s", Integer.toBinaryString(1));

यह बाएं-गद्दी के लिए स्थान रखता है:

`               1'

0पैडिंग के लिए एस कैसे लगाएं। मैं इसे फ़ॉर्मेट में नहीं ढूंढ सका । क्या इसे करने का एक और तरीका है?

PS यह पोस्ट बताता है कि पूर्णांक को 0-पैडिंग के साथ कैसे स्वरूपित किया जाए, लेकिन यह बाइनरी प्रतिनिधित्व के लिए नहीं है।

Comments

क्या आपने प्रयोग करने की कोशिश की है %016s?

— डेनिज डोगन

@ डिनीज़ हां, यह विफल रहता हैException in thread "main" java.util.FormatFlagsConversionMismatchException: Conversion = s, Flags = 0

— khachik

इस पर एक नज़र डालें: stackoverflow.com/a/15124135/1316649

— fstang

Answer 1

मुझे लगता है कि यह एक उप-अपनाने वाला समाधान है, लेकिन आप ऐसा कर सकते हैं

String.format("%16s", Integer.toBinaryString(1)).replace(' ', '0')

Comments

हां, मैं इसे अभी करता हूं, लेकिन मेरा मानना ​​है कि एक और तरीका होना चाहिए :) धन्यवाद।

— खटिक

वास्तव में कुछ शोध करने के बाद, ऐसा लगता है कि आप इसे प्रिंटफ सिंटैक्स का उपयोग करके नहीं कर सकते हैं .. इसलिए शायद यह इतना बुरा नहीं है।

— शमूएल पार्सोनेज

@ डैनियल नेगेटिव नंबर में कोई जगह नहीं होगी, इसलिए यह भी काम करता है।

— एरिक वांग

@ डैनियल इंटेगर :: toBinaryString डॉक्टर:Returns a string representation of the integer argument as an unsigned integer in base 2.

— एलन

Answer 2

Java.util.Formatter में कोई बाइनरी रूपांतरण नहीं बनाया गया है, मैं आपको सलाह दूंगा कि ज़ीरोस के साथ स्पेस कैरेक्टर को बदलने के लिए String.replace का उपयोग करें, जैसे कि:

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0")

या में दी गई पंक्तियों के साथ जोड़ा बाईं गद्दी कहीं साथ द्विआधारी प्रतिनिधित्व करने के लिए परिवर्तित पूर्णांकों के लिए अपने स्वयं के तर्क को लागू इस तो। या यदि आपको वास्तव में संख्याओं को प्रारूपित करने की आवश्यकता है, तो आप अपने द्विआधारी प्रतिनिधित्व को BigInteger में बदल सकते हैं और फिर अग्रणी शून्य के साथ प्रारूपित कर सकते हैं, लेकिन रनटाइम में यह बहुत महंगा है, जैसे कि:

String.format("%016d", new BigInteger(Integer.toBinaryString(1)))

Comments

धन्यवाद, यह एक बेहतर है, क्योंकि यह बड़ी संख्या (जैसे 2 ^ 30) पर अतिप्रवाह से बचा जाता है।

— १२:१० बजे १२:१०

हां, लेकिन मैं वास्तव में ऐसा नहीं करूंगा, मैं या तो प्रतिस्थापित विधि या अपनी स्वयं की गद्दी विधि का उपयोग करूंगा: एक तरीका यह होगा कि स्ट्रिंग का उपयोग किया जाए। तर्क शून्य के साथ आवश्यक पैडिंग लंबाई को प्रारूपित करने के लिए फिर से, या कोड में: String.format ( "% 0" + (32 - बाइनरी.लिफ्टिंग ()) + "डी"% s ", 0, बाइनरी) बेशक आपको 32 के नकारात्मक परिणामों के लिए देखने की आवश्यकता होगी - बाइनरी.लिफ्टिंग () ...

— ज़ोरान Regvart

Answer 3

आप Apache Commons StringUtils का उपयोग कर सकते हैं । यह पैडिंग स्ट्रिंग्स के लिए तरीके प्रदान करता है:

StringUtils.leftPad(Integer.toBinaryString(1), 16, '0');

Answer 4

मैं हर तरह की मेथड कॉल्स की कोशिश कर रहा था जो कि इस काम को करने के लिए मैंने पहले कभी इस्तेमाल नहीं की थीं, उन्होंने मध्यम सफलता के साथ काम किया, जब तक कि मैंने कुछ ऐसा नहीं सोचा जो इतना सरल है कि यह बस काम कर सकता है, और यह किया!

मुझे यकीन है कि यह पहले सोचा गया है, निश्चित नहीं है कि यह बाइनरी कोड के लंबे स्ट्रिंग के लिए अच्छा है, लेकिन यह 16 बिट स्ट्रिंग्स के लिए ठीक काम करता है। आशा करता हूँ की ये काम करेगा!! (नोट का दूसरा टुकड़ा कोड बेहतर हुआ है)

String binString = Integer.toBinaryString(256);
  while (binString.length() < 16) {    //pad with 16 0's
        binString = "0" + binString;
  }

लूप आउट के साथ काम करने के लिए इस उत्तर को बेहतर बनाने में मदद करने के लिए विल का धन्यवाद। यह शायद थोड़ा अनाड़ी है लेकिन यह काम करता है, कृपया सुधारें और यदि आप कर सकते हैं तो वापस टिप्पणी करें ...।

binString = Integer.toBinaryString(256);
int length = 16 - binString.length();
char[] padArray = new char[length];
Arrays.fill(padArray, '0');
String padString = new String(padArray);
binString = padString + binString;

Comments

यह एक अच्छा और सरल उपाय है। binString.length()एक स्ट्रिंग बनाने के लिए और 16 के बीच के अंतर का उपयोग करके इसे बेहतर बनाया जा सकता है और फिर उस स्ट्रिंग को लूपिंग के बजाय बिनस्ट्रिंग के साथ जोड़ा जा सकता है, हालांकि इस उत्तर के साथ कुछ इस तरह है: stackoverflow.com/a/2804866/1353098

— विल

होगा - आप शानदार हैं, बीमार है कि अभी मेरे कोड में! मैं लूप की तरह नहीं था, धन्यवाद!

— टॉम स्पेंसर

Answer 5

यहां एक पुरानी पोस्ट के लिए एक नया जवाब।

एक विशिष्ट लंबाई के लिए अग्रणी शून्य के साथ एक द्विआधारी मूल्य पैड करने के लिए, यह प्रयास करें:

Integer.toBinaryString( (1 << len) | val ).substring( 1 )

तो len = 4और val = 1,

Integer.toBinaryString( (1 << len) | val )

स्ट्रिंग देता है "10001", फिर

"10001".substring( 1 )

बहुत पहले चरित्र का वर्णन करता है। इसलिए हम जो चाहते हैं वह प्राप्त करते हैं:

"0001"

यदि valनकारात्मक होने की संभावना है, बल्कि प्रयास करें:

Integer.toBinaryString( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 )

Answer 6

User3608934 के विचार का एक सरल संस्करण "यह एक पुरानी चाल है, 16 0 के साथ एक स्ट्रिंग बनाएं और फिर आपके द्वारा छंटनी की गई बाइनरी स्ट्रिंग को जोड़ दें":

private String toBinaryString32(int i) {
    String binaryWithOutLeading0 = Integer.toBinaryString(i);
    return "00000000000000000000000000000000"
            .substring(binaryWithOutLeading0.length())
            + binaryWithOutLeading0;
}

Answer 7

मुझे "सही" समाधान नहीं पता है लेकिन मैं आपको एक तेज़ पैच सुझा सकता हूं।

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0");

मैंने सिर्फ कोशिश की है और देखा कि यह ठीक काम करता है।

Comments

क्यों फॉर्मैटर केवल 16 वर्णों वाला है? क्यों नहीं %32s?

— रिंग बियरर

Answer 8

प्रयत्न...

String.format("%016d\n", Integer.parseInt(Integer.toBinaryString(256)));

मुझे नहीं लगता कि यह ऐसा करने का "सही" तरीका है ... लेकिन यह काम करता है :)

Comments

यह निश्चित रूप से ऐसा करने का एक खराब तरीका है क्योंकि यह केवल इनपुट मानों के एक छोटे से अंश तक काम करता है .... सबसे बड़ा आउटपुट जो इसे सफलतापूर्वक उत्पन्न कर सकता है 0000001111111111वह इनपुट मूल्य के लिए है। इससे 1023बड़ा कोई भी मूल्य आउटपुट का उत्पादन करेगा toBinaryString(1024), 10000000000जिसमें से parseInt(...)इस प्रकार बहुत बड़ा है , इनपुट केवल 64K संभावित इनपुट मूल्यों के 1K के लिए काम करता है

— रॉल्फ

Answer 9

एक भोला समाधान जो काम करेगा

String temp = Integer.toBinaryString(5);
while (temp.length() < Integer.SIZE) temp = "0"+temp; //pad leading zeros
temp = temp.substring(Integer.SIZE - Short.SIZE); //remove excess

एक अन्य तरीका होगा

String temp = Integer.toBinaryString((m | 0x80000000));
temp = temp.substring(Integer.SIZE - Short.SIZE);

यह पूर्णांक 5 के 16 बिट स्ट्रिंग का उत्पादन करेगा

Answer 10

जावा 11 से शुरू होकर आप रिपीट (...) विधि का उपयोग कर सकते हैं :

"0".repeat(Integer.numberOfLeadingZeros(i) - 16) + Integer.toBinaryString(i)

या, यदि आपको किसी पूर्णांक के 32-बिट प्रतिनिधित्व की आवश्यकता है:

"0".repeat(Integer.numberOfLeadingZeros(i != 0 ? i : 1)) + Integer.toBinaryString(i)

Answer 11

यह एक पुरानी चाल है, 16 0 के साथ एक स्ट्रिंग बनाएं। तब छंटनी की गई बाइनरी स्ट्रिंग को जोड़ दें जो आपको String.format ("% s", Integer.toBinaryString (1)) से मिला है और किसी भी अग्रणी को बंद करते हुए सही-सबसे 16 वर्णों का उपयोग करें। 0 की। बेहतर अभी तक, एक फ़ंक्शन बनाएं जो आपको निर्दिष्ट करता है कि आप कितने समय तक एक बाइनरी स्ट्रिंग चाहते हैं। बेशक, पुस्तकालयों सहित इसे पूरा करने के लिए शायद एक बिलियन अन्य तरीके हैं, लेकिन मैं एक दोस्त की मदद करने के लिए इस पोस्ट को जोड़ रहा हूं :)

public class BinaryPrinter {

    public static void main(String[] args) {
        System.out.format("%d in binary is %s\n", 1, binaryString(1, 4));
        System.out.format("%d in binary is %s\n", 128, binaryString(128, 8));
        System.out.format("%d in binary is %s\n", 256, binaryString(256, 16));
    }

    public static String binaryString( final int number, final int binaryDigits ) {
        final String pattern = String.format( "%%0%dd", binaryDigits );
        final String padding = String.format( pattern, 0 );
        final String response = String.format( "%s%s", padding, Integer.toBinaryString(number) );

        System.out.format( "\npattern = '%s'\npadding = '%s'\nresponse = '%s'\n\n", pattern, padding, response );

        return response.substring( response.length() - binaryDigits );
    }
}

Answer 12

मैं नीचे की तरह विधि के साथ अपना स्वयं का उपयोग वर्ग लिखूंगा

public class NumberFormatUtils {

public static String longToBinString(long val) {
    char[] buffer = new char[64];
    Arrays.fill(buffer, '0');
    for (int i = 0; i < 64; ++i) {
        long mask = 1L << i;
        if ((val & mask) == mask) {
            buffer[63 - i] = '1';
        }
    }
    return new String(buffer);
}

public static void main(String... args) {
    long value = 0b0000000000000000000000000000000000000000000000000000000000000101L;
    System.out.println(value);
    System.out.println(Long.toBinaryString(value));
    System.out.println(NumberFormatUtils.longToBinString(value));
}

}

आउटपुट:

5
101
0000000000000000000000000000000000000000000000000000000000000101

समान दृष्टिकोण को किसी भी अभिन्न प्रकार पर लागू किया जा सकता है। मुखौटा के प्रकार पर ध्यान दें

long mask = 1L << i;

Answer 13

यह विधि एक स्ट्रिंग को एक स्ट्रिंग, लंबाई = बिट में कनवर्ट करती है। या तो 0s के साथ या सबसे महत्वपूर्ण बिट्स के साथ गद्देदार।

static String toBitString( int x, int bits ){
    String bitString = Integer.toBinaryString(x);
    int size = bitString.length();
    StringBuilder sb = new StringBuilder( bits );
    if( bits > size ){
        for( int i=0; i<bits-size; i++ )
            sb.append('0');
        sb.append( bitString );
    }else
        sb = sb.append( bitString.substring(size-bits, size) );

    return sb.toString();
}

Answer 14

आप lib https://github.com/kssource/BitSequence का उपयोग कर सकते हैं । यह एक संख्या स्वीकार करता है और अलंकृत स्ट्रिंग, गद्देदार और / या समूहीकृत करता है।

String s = new BitSequence(2, 16).toBynaryString(ALIGN.RIGHT, GROUP.CONTINOUSLY));  
return  
0000000000000010  

another examples:

[10, -20, 30]->00001010 11101100 00011110
i=-10->00000000000000000000000000001010
bi=10->1010
sh=10->00 0000 0000 1010
l=10->00000001 010
by=-10->1010
i=-10->bc->11111111 11111111 11111111 11110110

Answer 15

for(int i=0;i<n;i++)
{
  for(int j=str[i].length();j<4;j++)
  str[i]="0".concat(str[i]);
}

str[i].length()बाइनरी की संख्या 2 है बाइनरी में 01 है जो कि लंबाई 2 है 4 की वांछित अधिकतम संख्या की लंबाई 4 है। यह O (n) के लिए अनुकूलित किया जा सकता है। जारी रखकर उपयोग करें।

Answer 16

// नीचे उचित आकार संभाल लेंगे

public static String binaryString(int i) {
    return String.format("%" + Integer.SIZE + "s", Integer.toBinaryString(i)).replace(' ', '0');
}

public static String binaryString(long i) {
    return String.format("%" + Long.SIZE + "s", Long.toBinaryString(i)).replace(' ', '0');
}

Answer 17

import java.util.Scanner;
public class Q3{
  public static void main(String[] args) {
    Scanner scn=new Scanner(System.in);
    System.out.println("Enter a number:");
    int num=scn.nextInt();
    int numB=Integer.parseInt(Integer.toBinaryString(num));
    String strB=String.format("%08d",numB);//makes a 8 character code
    if(num>=1 && num<=255){
     System.out.println(strB);
    }else{
        System.out.println("Number should be in range between 1 and 255");
    }
  }
}

Comments

numBऔर numसमान हैं और किसी भी तरह से अलग नहीं हैं

— igorepst