java - जावा में मूल्य और 0xff क्या करता है?




integer byte (3)

मेरे पास निम्न जावा कोड है:

byte value = 0xfe; // corresponds to -2 (signed) and 254 (unsigned)
int result = value & 0xff;

परिणाम मुद्रित होने पर 254 है, लेकिन मुझे नहीं पता कि यह कोड कैसे काम करता है। यदि ऑपरेटर बस थोड़ा सा है, तो इसका परिणाम बाइट और इसके बजाय एक पूर्णांक क्यों नहीं होता है?


32 बिट प्रारूप प्रणाली में हेक्साडेसिमल मान 0xff 00000000000000000000000011111111 प्रतिनिधित्व करता है जो दशमलव में 255(15*16^1+15*16^0) है। और bitwise और ऑपरेटर पहले ऑपरेंड के रूप में वही 8 सही अधिकांश बिट्स मास्क करता है।


यह result (हस्ताक्षरित) मान के परिणामस्वरूप परिणाम के 8 बिट्स में value के 8 बिट्स डालने से उत्पन्न होता है।

इस तरह कुछ कारण जरूरी है कि byte जावा में एक हस्ताक्षरित प्रकार है। अगर आपने अभी लिखा है:

int result = value;

तो result 00 00 00 fe बजाय मूल्य ff ff ff fe साथ खत्म हो जाएगा। एक और सूक्ष्मता यह है कि इसे केवल int मान 1 पर संचालित करने के लिए परिभाषित किया गया है, तो क्या होता है:

  1. value एक int ( ff ff ff fe ) को बढ़ावा दिया जाता है।
  2. 0xff एक int शाब्दिक ( 00 00 00 ff ) है।
  3. result लिए वांछित मूल्य उपज करने के लिए लागू किया जाता है।

(बिंदु यह है कि int ऑपरेटर लागू होने से पहले int रूपांतरण होता है।)

1 ठीक है, बिल्कुल नहीं। ऑपरेटर long मूल्यों पर भी काम करता है, अगर ऑपरेंड एक long लेकिन byte पर नहीं। जावा भाषा विशिष्टता, खंड 15.22.1 और 5.6.2


http://www.coderanch.com/t/236675/java-programmer-SCJP/certification/xff

हेक्स शाब्दिक 0xFF एक बराबर int (255) है। जावा 32 बिट्स के रूप में int का प्रतिनिधित्व करता है। यह बाइनरी में ऐसा दिखता है:

00000000 00000000 00000000 11111111

जब आप किसी भी संख्या पर थोड़ा सा बुद्धिमान और इस मूल्य (255) के साथ करते हैं, तो यह मास्क (जेरोस बना सकता है) लेकिन संख्या के निम्नतम 8 बिट्स (जैसा होगा) होगा।

... 01100100 00000101 & ...00000000 11111111 = 00000000 00000101

और% की तरह कुछ है लेकिन really नहीं।

और 0xff क्यों? इसमें ((2 की शक्ति) - 1)। सभी ((2 की शक्ति) - 1) (उदाहरण के लिए 7, 255 ...)% ऑपरेटर की तरह कुछ व्यवहार करेंगे।

फिर
बाइनरी में, 0 है, सभी शून्य, और 255 इस तरह दिखते हैं:

00000000 00000000 00000000 11111111

और -1 इस तरह दिखता है

11111111 11111111 11111111 11111111

जब आप थोड़ा सा और 0xFF और 0 से 255 तक कोई मान करते हैं, तो परिणाम मान के समान सटीक होता है। और यदि 255 से अधिक कोई भी मूल्य अभी भी परिणाम 0-255 के भीतर होगा।

हालांकि, अगर आप करते हैं:

-1 & 0xFF

आपको मिला

00000000 00000000 00000000 11111111 , जो -1 के मूल मान के बराबर नहीं है ( 11111111 दशमलव में 255 है)।


कुछ और मैनिप्ल्यूशन: (प्रश्न से संबंधित नहीं)

X >> 1 = X/2
X << 1 = 2X

किसी विशेष बिट को सेट करें (1) या नहीं (0) तब जांचें

 int thirdBitTobeChecked =   1 << 2   (...0000100)
 int onWhichThisHasTobeTested = 5     (.......101)

 int isBitSet = onWhichThisHasTobeTested  & thirdBitTobeChecked;
 if(isBitSet > 0) {
  //Third Bit is set to 1 
 } 

एक विशेष बिट सेट करें (1)

 int thirdBitTobeSet =   1 << 2    (...0000100)
 int onWhichThisHasTobeSet = 2     (.......010)
 onWhichThisHasTobeSet |= thirdBitTobeSet;

रीसेट (0) एक विशेष बिट

int thirdBitTobeReSet =   ~(1 << 2)  ; //(...1111011)
int onWhichThisHasTobeReSet = 6      ;//(.....000110)
onWhichThisHasTobeReSet &= thirdBitTobeReSet;

XOR

बस ध्यान दें कि यदि आप दो बार एक्सओआर ऑपरेशन करते हैं, तो वही मान परिणाम देगा।

byte toBeEncrypted = 0010 0110
byte salt          = 0100 1011

byte encryptedVal  =  toBeEncrypted ^ salt == 0110 1101
byte decryptedVal  =  encryptedVal  ^ salt == 0010 0110 == toBeEncrypted :)

एक्सओआर के साथ एक और तर्क है

if     A (XOR) B == C (salt)
then   C (XOR) B == A
       C (XOR) A == B

उपर्युक्त अस्थायी के बिना दो चर को स्वैप करने के लिए उपरोक्त उपयोगी है

a = a ^ b; b = a ^ b; a = a ^ b;

या

a ^= b ^= a ^= b;




bitwise-and