बिट्स को बिट्स में कैसे परिवर्तित करें?

Question

मेरे पास बाइट्स की एक सरणी है। मैं प्रत्येक बाइट्स तक पहुंच बनाना चाहता हूं और इसके बराबर बाइनरी वैल्यू (8 बिट्स) चाहता हूं ताकि अगले ऑपरेशन करने के लिए। मैंने बिटसेट के बारे में सुना है लेकिन क्या इससे निपटने का कोई और तरीका है?

धन्यवाद।

Answer 1

byte ar[] ; 
byte b = ar[0];//you have 8 bits value here,if I understood your Question correctly :) 

Answer 2

तुम सिर्फ बाइनरी में इसके बारे में स्ट्रिंग प्रतिनिधित्व की जरूरत है तो आप बस द्विआधारी के लिए 2 करने के लिए सेट वैकल्पिक दूसरे पैरामीटर के साथ Integer.toString() उपयोग कर सकते हैं।

किसी भी अभिन्न प्रकार पर सामान्य बिट ट्विडलिंग करने के लिए, आपको लॉजिकल और बिट्सफ़्ट ऑपरेटरों का उपयोग करना होगा।

// tests if bit is set in value 
boolean isSet(byte value, int bit){ 
    return (value&(1<<bit))!=0; 
} 

// returns a byte with the required bit set 
byte set(byte value, int bit){ 
    return value|(1<<bit); 
} 

Answer 3

जावा में bitwise operators है। a tutorial example देखें।

जावा प्रोग्रामिंग भाषा ऑपरेटरों को भी प्रदान करती है जो अभिन्न प्रकारों पर बिटवाई और बिट शिफ्ट ऑपरेशन करती हैं। इस खंड में चर्चा की गई ऑपरेटरों का कम आम तौर पर उपयोग किया जाता है। इसलिए, उनके कवरेज संक्षिप्त है; इरादा आपको केवल यह बताने के लिए है कि ये ऑपरेटर मौजूद हैं।

यूनरी बिटवाई पूरक ऑपरेटर "~" थोड़ा पैटर्न बदलता है; इसे किसी भी अभिन्न प्रकार पर लागू किया जा सकता है, जिससे प्रत्येक "0" एक "1" और प्रत्येक "1" "0" बना दिया जा सकता है। उदाहरण के लिए, एक बाइट में 8 बिट होते हैं; इस ऑपरेटर को उस मान पर लागू करना जिसका बिट पैटर्न "00000000" है, इसका पैटर्न "11111111" में बदल जाएगा।

ए byte मूल्य अभिन्न है, आप मास्किंग परिचालनों का उपयोग करके बिट स्थिति की जांच कर सकते हैं। कम से कम महत्वपूर्ण बिट मुखौटा 1 या 0x1, अगले बिट 0x2 के अनुरूप, आदि

byte b = 3; 
if((b & 0x1) == 0x1) { 
    // LSB is on 
} else { 
    // LSB is off 
} 

Answer 4

आप क्या आप Guava Primitives पैकेज में देख रहे हैं, की तर्ज पर कुछ मिल सकती है से मेल खाती है।

वैकल्पिक रूप से, आप

public boolean[] convert(byte...bs) { 
boolean[] result = new boolean[Byte.SIZE*bs.length]; 
int offset = 0; 
for (byte b : bs) { 
    for (int i=0; i<Byte.SIZE; i++) result[i+offset] = (b >> i & 0x1) != 0x0; 
    offset+=Byte.SIZE; 
} 
return result; 
} 

कि परीक्षण नहीं किया है की तरह कुछ लिखने के लिए चाहते हो सकता है, लेकिन यह विचार नहीं है। कुछ और की सरणी वापस करने के लिए लूप/असाइनमेंट में आसान संशोधन भी हैं (कहें, int या long)।

Answer 5

BitSet.valueOf(byte[] bytes)

आप स्रोत कोड पर एक नज़र लेने के लिए कि यह कैसे अगर आप जावा 7

Answer 6

उपयोग नहीं कर रहे लागू हो जाता है अच्छी तरह से मुझे लगता है मैं तुम क्या मतलब प्राप्त हो सकता है। अब इसके साथ एक बड़ी त्रुटि यह है कि यह नकारात्मक संख्याओं पर काम नहीं करता है। हालांकि यह मानते हुए कि आप फ़ाइल इनपुट पढ़ने के लिए इसका उपयोग नहीं कर रहे हैं, फिर भी आप इसका उपयोग कर पाएंगे।

public static ArrayList<Boolean> toBitArr(byte[] bytearr){ 
    ArrayList<Boolean> bitarr = new ArrayList<Boolean>(); 
    ArrayList<Boolean> temp = new ArrayList<Boolean>(); 
    int i = 0; 
    for(byte b: bytearr){ 
     while(Math.abs(b) > 0){ 
      temp.add((b % 2) == 1); 
      b = (byte) (b >> 1); 
     } 
     Collections.reverse(temp); 
     bitarr.addAll(temp); 
     temp.clear(); 
    } 
    return bitarr; 
}