(जावा) बिट्स (लम्बाई) की संख्या निर्दिष्ट करें जब स्ट्रिंग के लिए द्विआधारी संख्या परिवर्तित?

Question

मैं एक सरणी में एक द्विआधारी स्ट्रिंग के रूप में एक नंबर स्टोर करने के लिए कोशिश कर रहा हूँ, लेकिन मैं कितने बिट्स के रूप में यह स्टोर करने के लिए निर्दिष्ट करने के लिए की जरूरत है।

उदाहरण के लिए, मैं एक स्ट्रिंग "00" की जरूरत है अगर मैं 0 दो के साथ बिट्स स्टोर करने के लिए की जरूरत है। या 6 बिट्स के साथ 1010 "001010"।

क्या कोई मदद कर सकता है?

संपादित करें: धन्यवाद दोस्तों, क्योंकि मैं सामान्य रूप से गणित/प्रोग्रामिंग में बकवास कर रहा हूं, मैं डेविड के सबसे सरल समाधान के साथ गया हूं। कुछ ऐसा:

binaryString.append(Integer.toBinaryString(binaryNumber)); 
for(int n=binaryString.length(); n<numberOfBits; n++) { 
         binaryString.insert(0, "0"); 
} 

ऐसा लगता है कि यह बहुत अक्षम है, इसलिए जब तक यह बहुत अक्षम नहीं है, मैं इसके साथ जाऊंगा।

Answer 1

उपयोग Integer.toBinaryString() तो स्ट्रिंग की लंबाई की जाँच करें और के रूप में कई शून्य से यह पहले जोड़ें रूप में आप अपने इच्छित लंबाई बनाने की जरूरत है: यहाँ एक बुनियादी उदाहरण है।

Answer 2

घर का बना समाधान के बारे में भूल जाओ। इसके बजाय मानक BigInteger का उपयोग करें। आप बिट्स की संख्या निर्दिष्ट कर सकते हैं और उसके बाद ठीक करने के लिए आपको क्या चाहिए toString (पूर्णांक मूलांक) पद्धति का उपयोग (मैं आप की जरूरत मान मूलांक = 2)।

संपादित करें: मैं बिगइंटर को थोड़ा नियंत्रण छोड़ दूंगा। ऑब्जेक्ट नए नंबर आयाम को फिट करने के लिए आंतरिक रूप से अपने बिट बफर का आकार बदल देगा। इसके अलावा अंकगणितीय परिचालन इस वस्तु के माध्यम से किए जा सकते हैं (आपको बाइनरी योजक/गुणक आदि को लागू करने की आवश्यकता नहीं है)।

package test; 

import java.math.BigInteger; 

public class TestBigInteger 
{ 
    public static void main(String[] args) 
    { 
     String value = "1010"; 
     BigInteger bi = new BigInteger(value,2); 
     // Arithmetic operations 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.add(bi); // 10 + 10 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.multiply(bi); // 20 * 20 
     System.out.println("Output: " + bi.toString(2)); 

     /* 
     * Padded to the next event number of bits 
     */ 
     System.out.println("Padded Output: " + pad(bi.toString(2), bi.bitLength() + bi.bitLength() % 2)); 
    } 

    static String pad(String s, int numDigits) 
    { 
     StringBuffer sb = new StringBuffer(s); 
     int numZeros = numDigits - s.length(); 
     while(numZeros-- > 0) { 
      sb.insert(0, "0"); 
     } 
     return sb.toString(); 
    } 
} 

Answer 3

यह एक आम होमवर्क समस्या है। एक शानदार लूप है जिसे आप लिख सकते हैं जो 2> = आपके लक्ष्य संख्या n की छोटी शक्ति की गणना करेगा।

चूंकि यह 2 की शक्ति है, आधार 2 लॉगरिदम बिट्स की संख्या है। लेकिन जावा math लाइब्रेरी केवल प्राकृतिक लघुगणक प्रदान करता है।

math.log(n)/math.log(2.0) 

बिट्स की संख्या है।

Answer 4

import java.util.BitSet; 

public class StringifyByte { 

    public static void main(String[] args) { 
     byte myByte = (byte) 0x00; 
     int length = 2; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 

     myByte = (byte) 0x0a; 
     length = 6; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 
    } 

    public static String stringifyByte(byte b, int len) { 
     StringBuffer bitStr = new StringBuffer(len); 
     BitSet bits = new BitSet(len); 
     for (int i = 0; i < len; i++) 
     { 
      bits.set (i, (b & 1) == 1); 
      if (bits.get(i)) bitStr.append("1"); else bitStr.append("0"); 
      b >>= 1; 
     } 
     return reverseIt(bitStr.toString()); 
    } 

    public static String reverseIt(String source) { 
     int i, len = source.length(); 
     StringBuffer dest = new StringBuffer(len); 

     for (i = (len - 1); i >= 0; i--) 
      dest.append(source.charAt(i)); 
     return dest.toString(); 
    } 
} 

आउटपुट:

myByte: 0x0 
bitString: 00 
myByte: 0x10 
bitString: 001010 

Answer 5

यहाँ int मूल्यों के लिए एक सरल उपाय; यह स्पष्ट होना चाहिए कि इसे कैसे विस्तारित किया जाए बाइट, आदि

public static String bitString(int i, int len) { 
    len = Math.min(32, Math.max(len, 1)); 
    char[] cs = new char[len]; 
    for (int j = len - 1, b = 1; 0 <= j; --j, b <<= 1) { 
     cs[j] = ((i & b) == 0) ? '0' : '1'; 
    } 
    return new String(cs); 
} 

यहाँ नमूना परीक्षण मामलों का एक सेट से उत्पादन होता है:

0 1        0        0 
    0 -1        0        0 
    0 40 00000000000000000000000000000000 00000000000000000000000000000000 
13 1        1        1 
13 2        01        01 
13 3        101        101 
13 4        1101        1101 
13 5       01101       01101 
-13 1        1        1 
-13 2        11        11 
-13 3        011        011 
-13 4        0011        0011 
-13 5       10011       10011 
-13 -1        1        1 
-13 40 11111111111111111111111111110011 11111111111111111111111111110011 

बेशक

, आप अपने दम पर कर रहे हैं लंबाई पैरामीटर पूरे मूल्य का प्रतिनिधित्व करने के लिए पर्याप्त बनाने के लिए ।

Answer 6

भी सरल:

String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16)); 
String.format("%032", new BigInteger(binAddr)); 

विचार यहाँ एक दशमलव संख्या अस्थायी रूप से के रूप में वापस स्ट्रिंग पार्स करने में है (एक है कि सिर्फ इसलिए से मिलकर करने के लिए होता सब 1 है और 0 है) और फिर String.Format का उपयोग करें ()।

नोट आप मूल रूप से, BigInteger का उपयोग करना होगा क्योंकि द्विआधारी तार जल्दी से पूर्णांक और लांग NumberFormatExceptions में जिसके परिणामस्वरूप अतिप्रवाह अगर आप Integer.fromString() या Long.fromString() उपयोग करने के लिए प्रयास करें।

Answer 7

इस प्रयास करें:

String binaryString = String.format("%"+Integer.toString(size)+"s",Integer.toBinaryString(19)).replace(" ","0"); 

जहां आकार किसी भी संख्या उपयोगकर्ता तो यहाँ

Answer 8

चाहता है के बजाय 8 आप अपने वांछित लंबाई लिख सकते हैं हो सकता है और तदनुसार शून्य जोड़ देंगे। अपने उल्लेख किया पूर्णांक की लंबाई से अधिक है कि की संख्या तो उल्लेख किया कि यह किसी भी शून्य

String.format("%08d",1111);

आउटपुट संलग्न नहीं होंगे: 00001111

String.format("%02d",1111); 

उत्पादन: 1111