एक char

Question

मानते हुए बिट्स Iterating बिट्स मेरे पास चार "सी" है जिसका ascii कोड 0110 0111 है। मैं अपने बिट्स पर कैसे पुन: प्रयास कर सकता हूं? मैं इन 1 और 0 के से वेक्टर बनाना चाहता हूं ....

Answer 1

आप उन्हें आसानी से बिटवाइज़ ऑपरेटर्स का उपयोग करने पर पुनरावृति कर सकते हैं:

char c = 'C'; 
for (int i = 0; i < 8; ++i) 
{ 
    // extract the i-th bit 
    int b = ((c & 1<<i) >> i); 
    // b will be 1 if i-th bit is set, 0 otherwise 

    // do whatever you want with b 
} 

आप इसे अनुकूलित कर सकते हैं (जैसा कि टिप्पणी में सुझाव दिया):

int b = ((c >> i) & 1); 

Answer 2

एक वर्ण में एक पूर्णांक मान है। कुछ इस तरह काम करेगा:

int myChar = 42; 
String binstr = Integer.toBinaryString(myChar); 

बाकी मैं एक व्यायाम के रूप में आप के लिए छोड़ देंगे - लेकिन तुम सब अब क्या करना है अपने बाइनरी मान की स्ट्रिंग प्रतिनिधित्व पर पुनरावृति है और जो कुछ भी यह है कि आप की योजना बनाई थी करना करने पर

Answer 3

बस प्रत्येक स्थिति में आप के बारे में परवाह पर बिटवाइज़ चेकों का उपयोग करें। निम्नलिखित की तरह कुछ एरे bits बनाएगा जो व्यक्तिगत मान रखता है।

char c = 'C'; 
int[] bits = new int[8]; 

int j = 0; 
for(int i = 1; i <= 256; i *= 2){ 
    bits[j++] = (c & i) > 0 ? 1 : 0; 
} 

Answer 4

आप बिटवाइज़ संचालन के साथ ऐसा करना होगा:

अर्थात्:

while (my_char > 0) { 
    if my_char & 1 
    char_vector.push 1 // if the right most bit is 1 
    else 
    char_vector.push 0 // right most bit must be 0 if we fell through to the else 
    my_char = my_char >> 1 // right shift one position 
} 

यदि आप के बाद आप सही पारी, आप पैड शेष 0s साथ char_vector कर सकते हैं, जरूरत है शून्य करने के लिए।

Answer 5

char c = 'C'; 
Vector<Boolean> vector = new Vector<Boolean>(16); 
for (int i = Character.SIZE-1; i >=0; --i) { 
    int num = c >> i; 
    boolean set = (num & 1) == 1; 
    vector.add(Boolean.valueOf(set)); 
} 

Answer 6

unrolled पाश:

int[] bits = new int[8] 
bits[0] = (c & 1) > 0 ? 1 : 0; 
bits[1] = (c & 2) > 0 ? 1 : 0; 
bits[2] = (c & 4) > 0 ? 1 : 0; 
bits[3] = (c & 8) > 0 ? 1 : 0; 
bits[4] = (c & 16) > 0 ? 1 : 0; 
bits[5] = (c & 32) > 0 ? 1 : 0; 
bits[6] = (c & 64) > 0 ? 1 : 0; 
bits[7] = (c & 128) > 0 ? 1 : 0;