दिलचस्प पोस्ट
एंड्रॉइड 1.6: "android.view.WindowManager $ BadTokenException: खिड़की जोड़ने में असमर्थ – टोकन रिक्त एक आवेदन के लिए नहीं है" मुझे क्यों परवाह करना चाहिए कि जावा में सामान्यीकृत जेनरिक नहीं है? सरणी तत्व को उद्देश्य-सी में ढक दिया नहीं जा सकता अपने आंतरिक उप-घटकों से एक वैध xlsx फ़ाइल कैसे ठीक से इकट्ठा करे? UIWebView की तुलना में फोन कोड के बाद अलग-अलग कोड में अलग-अलग ऐप व्यवहार पर लौटें JSON.stringify () IE 8 द्वारा समर्थित है? एक EventTrigger के साथ एक संपत्ति की स्थापना उद्देश्य सी में एमडी 5 एल्गोरिदम Ggplot2 बार ग्राफ में ऑर्डर बार क्या const_cast सुरक्षित है? क्या कोई "पिछला भाई" सीएसएस चयनकर्ता है? अक्ष के चारों ओर एक चतुष्कोणीय रोटेशन के घटक क्या गणना () में शर्त निर्दिष्ट करना संभव है? codeigniter, परिणाम () बनाम परिणाम_अरे () अतिरिक्त स्थान के साथ मल्टी-लाइन स्ट्रिंग (संरक्षित इंडेंटेशन)

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

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

 0000000000000001 0000000000000010 0000000010000000 0000000100000000 

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

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

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

 ` 1' 

पैडिंग के लिए 0 एस को कैसे रखा जाए मुझे इसे फॉर्मेट में नहीं मिला। क्या ऐसा करने का एक और तरीका है?

अग्रिम में धन्यवाद।

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

Solutions Collecting From Web of "जावा में पूर्णांक के 0-गद्देदार द्विआधारी प्रतिनिधित्व कैसे प्राप्त करें?"

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

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

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

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

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

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

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

मुझे यकीन है कि यह पहले से सोचा गया है, यह सुनिश्चित नहीं है कि यह बाइनरी कोड की लंबी स्ट्रिंग के लिए अच्छा है, लेकिन यह 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; 

आप अपाचे कॉन्सन्स स्ट्रिंग यूटिलस का उपयोग कर सकते हैं। यह पैडिंग स्ट्रिंग के लिए तरीके प्रदान करता है:

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

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

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

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

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

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

 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 ) 

प्रयत्न…

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

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

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

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

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

 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 बिट स्ट्रिंग का उत्पादन करेगा

यह एक पुरानी चाल है, 16 स्ट्रिंग के साथ एक स्ट्रिंग बनाएं, फिर आप String.format ("% s", "Integer.toBinaryString (1))" से प्राप्त की गई छंटनी वाली द्विआधारी स्ट्रिंग को जोड़ सकते हैं और किसी भी अग्रणी 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 ); } } 

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

 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;

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

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

आप दुबारा 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 
 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 की अधिकतम लंबाई की वांछित है। यह ओ (एन) के लिए अनुकूलित किया जा सकता है। जारी रखने का उपयोग करके