में मैं एक परियोजना के भीतर कोड की कुछ लाइनें है, कि मैं का मूल्य नहीं देख सकता ...बिटवाइस और, बिटवाइस समावेशी OR प्रश्न, जावा
buffer[i] = (currentByte & 0x7F) | (currentByte & 0x80);
यह एक से filebuffer पढ़ता फ़ाइल, बाइट्स के रूप में संग्रहीत, और तब बफर करने के लिए स्थानांतरण [i] दिखाया गया है, लेकिन मैं समझ नहीं पा रहा हूं कि समग्र उद्देश्य क्या है, कोई विचार?
धन्यवाद
अन्य उत्तर पहले से ही कहा गया है, (currentByte & 0x7F) | (currentByte & 0x80)(currentByte & 0xFF) के बराबर है।JLS3 15.22.1 कहना है कि यह करने के लिए प्रोत्साहित किया जाता है एक int:
जब एक ऑपरेटर &, दोनों ऑपरेंड ^, या | परिवर्तनीय (§5.1.8) को एक आदिम अभिन्न प्रकार, बाइनरी संख्यात्मक पदोन्नति ऑपरेटरों (§5.6.2) पर पहली बार किया गया है। बिटवाई ऑपरेटर अभिव्यक्ति का प्रकार प्रचारित प्रकार के प्रचार प्रकार है।
क्योंकि JLS3 5.6.2 का कहना है कि टाइप करते currentByte है byte और 0x7F एक int है (और यह मामला है), तो दोनों ऑपरेंड int करने के लिए प्रोत्साहित कर रहे हैं।
इसलिए, buffer तत्व प्रकार int या व्यापक का एक सरणी होगा।
अब, एक int पर & 0xFF प्रदर्शन करके, हम प्रभावी रूप से मूल byte रेंज -128..127 अहस्ताक्षरित रेंज 0..255, अक्सर उदाहरण के लिए java.io धाराओं द्वारा इस्तेमाल किया एक आपरेशन में मैप करें।
आप इसे निम्न कोड स्निपेट में कार्रवाई में देख सकते हैं। ध्यान दें कि यह समझने के लिए कि यहां क्या हो रहा है, आपको यह जानना होगा कि जावा char को 2's complement मानों के अलावा, अभिन्न प्रकारों को संग्रहीत करता है।
byte b = -123;
int r = b;
System.out.println(r + "= " + Integer.toBinaryString(r));
int r2 = b & 0xFF;
System.out.println(r2 + "= " + Integer.toBinaryString(r2));
अंत में, एक वास्तविक दुनिया उदाहरण के लिए, जावाडोक और java.io.ByteArrayInputStream की read विधि के क्रियान्वयन की जाँच:
/**
* Reads the next byte of data from this input stream. The value
* byte is returned as an <code>int</code> in the range
* <code>0</code> to <code>255</code>. If no byte is available
* because the end of the stream has been reached, the value
* <code>-1</code> is returned.
*/
public synchronized int read() {
return (pos < count) ? (buf[pos++] & 0xff) : -1;
}
मुझे लगता है कि किसी को बहुत ज्यादा यहाँ सोच था। यह ठीक नहीं है।
मेरे पास है, लेकिन एक टिप्पणी
यह कोड पीछे छोड़ दिया गया है। जब तक आप नहीं जानते कि आप एक फिश रन-टाइम पर हैं? वैसे भी 'बफर' का प्रकार क्या है?
जटिल बिटवाइज तर्क पूरी तरह से अनिवार्य है।
for (int i = 0; i < buffer.length; i++) {
buffer[i] = filebuffer[currentPosition + i] & 0xff;
}
वही काम करता है। यदि बफर को बाइट्स की सरणी के रूप में घोषित किया जाता है तो आप & 0xff भी छोड़ सकते हैं, लेकिन दुर्भाग्य से घोषणा नहीं दिखाई दे रही है।
कारण यह हो सकता है कि मूल डेवलपर जावा में हस्ताक्षरित बाइट्स द्वारा उलझन में था।
(currentByte & 0x7F) | (currentByte & 0x80)
currentByte & (0x7F | 0x80)
जो
currentByte & 0xFF
जो बिल्कुल के रूप में
currentByte
संपादित एक ही है के बराबर होती है के बराबर है: मैं केवल के दाईं ओर को देखा असाइनमेंट, और मुझे अभी भी ई लगता है योग्यता सच है।
हालांकि, ऐसा लगता है कि कोड हस्ताक्षरित बाइट को बड़े आकार में डालना चाहता है जबकि बाइट को बिना हस्ताक्षर किए गए व्याख्या करना है।
क्या जावा में हस्ताक्षर किए गए हस्ताक्षर-बाइट को कास्ट करने का कोई आसान तरीका है?
एक बिटवाइज़ और ऑपरेशन का परिणाम है कि पर एक 1 बिट्स है जहां दोनों बिट्स 1, जबकि बिट्स कि पर एक बिटवाइज़ या आपरेशन hase एक का परिणाम है या तो बॉट बिट्स में से एक है जहां 1.
तो एक मूल्य 0x65 के लिए उदाहरण के मूल्यांकन:
01100101 0x65
& 01111111 0x7F
===============
01100101 0x65
01100101 0x65
& 10000000 0x80
===============
00000000 0x00
01100101 0x65
| 00000000 0x00
===============
01100101 0x65
तार्किक आपरेशन के इन प्रकार के बारे में अच्छी बात: आप हर कोशिश कर सकते हैं संभावित संयोजन (उनमें से सभी 256) और सत्यापित करें कि आपको अपेक्षित उत्तर मिल गया है।
बाहर निकलता है, जिस फ़ाइल को बाइट पढ़ा जा रहा था, उस पर हस्ताक्षर किए गए बिट नोटेशन और एक अलग लंबाई में था, इसलिए इसे इस कार्य को करने के लिए पुन: प्रयास किया गया ताकि इसे जावा int टाइप तक बढ़ाया जा सके, जबकि अपने सही संकेत को बनाए रखना :)
एलओएल, यही मुझे काम करना है! :) – Dave
दोनों एरे बाइट्स मैंने टिम्बो से सुझाव की कोशिश की, और इसके बदले में फ्यूबर किया गया: -/ – Dave
बफर तत्व प्रकार int या व्यापक है, अन्यथा इसे संकलित नहीं करना चाहिए। – eljenso