जावा हेक्साडेसिमल

Question

मैं एक संदेश है

static int[] message = { 
     0x01, 0x10, 0x00, 
     0x01, // port addres 01 - 08 
     0x00, 0x01, 0x02, 
     0x06, 0x00, 
     0xA4, 0x21 
}; 

मैं जानता हूँ कि डेटा ठीक कह रहे हैं, के रूप में मैं उन्हें RXTX साथ COM पोर्ट के लिए लिख रहा हूँ, और मैं सही HW प्रतिक्रिया मिल गया

मुझे लगता है कि 0x01 पता 1 मान है, और वास्तव में 01 (जो दो बिट्स, चौथाई बाइट लंबा है)

जब मुझे संदेश समायोजित करने की आवश्यकता है, तो इस तरह के मान उत्पन्न कर रहे हैं?

message[index] = 1 & 0xff 

मैं इस टुकड़ा के उत्पादन में देखते हैं, और यह ठीक लग रहा है

for (int i = 0; i < 255; i++) { 
    System.out.println(i & 0xff); 
} 

कोई चादर तुम मुझे सलाह देते हैं पढ़ने के लिए है?
int सही में इन नंबरों को संगृहीत करना, जैसा कि हम मूल्यों के लिए उपयोग कर सकते हैं byte (-128, +127) नहीं <0x00, 0xFF> रेंज

Answer 1

अप करने के लिए आप शायद तुम क्या जरूरत के लिए एक ByteBuffer उपयोग करना चाहते हैं, और एक वर्ग के अंतर्गत लपेट।

मैं अपने सटीक संदेश स्वरूप पता नहीं है, लेकिन मान लीजिए कि एक पल के लिए इस डेटा के 3 बाइट्स और एक बंदरगाह की 1 बाइट है करते हैं:)

public final class Message 
{ 
    private static final MESSAGE_SIZE = 4; 
    private static final PORT_OFFSET=3; 

    private final ByteBuffer buf; 

    public Message() 
    { 
     buf = ByteBuffer.allocate(MESSAGE_SIZE); 
    } 

    public void setPort(final byte b) 
    { 
     buf.put(PORT_OFFSET, b); 
    } 

    // etc 

    public byte[] getRaw() 
    { 
     return buf.array(); 
    } 
} 

तुम भी ByteBuffer के hashCode (उपयोग कर सकते हैं और बराबर() संदेशों की तुलना करने के लिए, यदि आप कभी भी पूर्ण get/put विधियों का उपयोग करते हैं (अन्यथा व्यायामशाला का थोड़ा सा क्रम में है)।

मैंने एनआरपीई पैकेट पढ़ने/लिखने के लिए इस तकनीक का उपयोग किया।

Answer 2

मुझे पता है कि 0x01 1 बना रहता है और (जो दो बिट्स है)

यह केवल सच है कि आप कुछ है कि ऐसा करने के लिए कर रहे हैं 01 की तरह वास्तव में भेज दिया है। जावा int एक 32-बिट मान (reference) है। सिर्फ इसलिए कि मूल्य को उन सभी बिट्स की आवश्यकता नहीं है, इसका मतलब यह नहीं है कि वे नहीं भेजे गए हैं, क्योंकि को एक अलग मूल्य के लिए सभी बिट्स की आवश्यकता हो सकती है। आप जो भेज रहे हैं उसका आकार इस बात से सीमित हो सकता है कि आप इसे कैसे भेज रहे हैं, लेकिन आपके द्वारा उद्धृत अन्य मूल्यों को देखते हुए, आप सुनिश्चित कर सकते हैं कि आप कम से कम आठ बिट्स भेज रहे हैं।

यदि आप OutputStream#write का उपयोग कर रहे हैं, तो जो भेजा जाता है वह पूरी तरह से ठोस कार्यान्वयन पर निर्भर करेगा। OutputStream धाराओं को लिखने के लिए एक सार वर्ग परिभाषित अर्थशास्त्र है; यह धारा को स्वयं परिभाषित नहीं करता है। वास्तव में परिभाषित करने के लिए एक ठोस उपclass आवश्यक है जो लिखा जाता है। FileOutputStream और ByteArrayOutputStream और PipedOutputStream सभी डेटा अलग-अलग आउटपुट करते हैं।