इस तथ्य के आसपास काम करने का सबसे अच्छा तरीका क्या है कि सभी जावा बाइट्स पर हस्ताक्षर किए गए हैं?

जावा में, एक हस्ताक्षरित बाइट जैसी कोई चीज नहीं है।

कुछ निम्न स्तर के कोड के साथ काम करते हुए, कभी-कभी आपको उन बाइट्स के साथ काम करने की आवश्यकता होती है जिनके पास 128 से अधिक हस्ताक्षरित मान नहीं हैं, जिससे जावा को संकेत के लिए उपयोग किए जाने वाले एमएसबी के कारण नकारात्मक संख्या के रूप में व्याख्या करने का कारण बनता है।

इस के आसपास काम करने का एक अच्छा तरीका क्या है? (कहें जावा का उपयोग न करें एक विकल्प नहीं है)

0
ro fr bn

7 उत्तर

मुझे लगता है कि आप उन्हें स्टोर करने के लिए बस एक छोटा सा उपयोग कर सकते हैं। बहुत कुशल नहीं है, लेकिन वास्तव में एकमात्र विकल्प है जो मैंने देखा है।

0
जोड़ा

सरणी से किसी एकल मूल्य को पढ़ने पर इसे किसी छोटे या int की तरह कॉपी करें और नकारात्मक संख्या को सकारात्मक मान में मैन्युअल रूप से परिवर्तित करें।

byte[] foobar = ..;
int value = foobar[10];
if (value < 0) value += 256//Patch up the 'falsely' negative value

सरणी में लिखते समय आप एक समान रूपांतरण कर सकते हैं।

0
जोड़ा
Int मान = (foobar [10] और 0xFF) करने के लिए बहुत आसान और अधिक कुशल;
जोड़ा लेखक Lawrence Dol, स्रोत
शायद, लेकिन मैं चाहता था कि मेरा कोड यथासंभव स्पष्ट और निर्देशक हो। साथ ही, मुझे नहीं पता कि जावा में नकारात्मक पूर्णांक के लिए '&' क्या करता है (कम से कम गुगलिंग के बिना नहीं), इसलिए मैंने इसे सुरक्षित खेला।
जोड़ा लेखक pauldoo, स्रोत
मैंने सोचा कि शायद 0xFF को हस्ताक्षरित बाइट (जो -1 होगा) के रूप में माना जाएगा, फिर साइन-इन को 32-बिट हस्ताक्षरित पूर्णांक (जो 0xFFFFFFFF उर्फ ​​-1 प्रदान करेगा) को '&' के तर्क के रूप में पारित करने से पहले बढ़ाया जाएगा। यह गलत परिणाम देगा। यह चर्चा से स्पष्ट है कि जावा ऐसा नहीं करेगा, लेकिन मैंने इसे सुरक्षित खेलने के लिए सबसे अच्छा सोचा।
जोड़ा लेखक pauldoo, स्रोत
क्यों नकारात्मक संख्याओं के लिए कुछ और अलग करेंगे। और यह एक बूलियन ऑपरेशन है जो यह अलग-अलग बिट्स पर काम करता है, अगर कोई संख्या सकारात्मक, नकारात्मक, या कोई अन्य मूल्य है, तो पता है, जांच या देखभाल करता है।
जोड़ा लेखक mP., स्रोत

इनट्स का उपयोग शॉर्ट्स का उपयोग करने से आम तौर पर बेहतर होता है क्योंकि जावा आंतरिक रूप से 32-बिट मानों का उपयोग करता है (यहां तक ​​कि बाइट्स के लिए, जब तक कि सरणी में नहीं) तो इनट्स का उपयोग करके बाइटकोड में छोटे मानों से अनावश्यक रूपांतरण से बच जाएगा।

0
जोड़ा
यह बहुत सच है, यद्यपि आप बाइट्स में मूल्यों को आगे बढ़ाने और वापस करने के लिए अतिरिक्त बाइटकोड प्राप्त करते हैं, इसलिए एक छोटा ओवरहेड होता है। पठनीयता> हालांकि छोटे अमूर्त लाभ।
जोड़ा लेखक izb, स्रोत
खैर, यदि मान हमेशा बाइट (यानी 8 बिट) होगा, तो बाइट का उपयोग करके स्पष्ट और बेहतर कोड के इरादे को व्यक्त करता है, इसलिए मैं इसे पठनीयता के लिए उपयोग करता हूं, भले ही यह उपयोग करता हो int के समान स्थान।
जोड़ा लेखक sleske, स्रोत
साथ ही, यह समझते हुए कि int आपके इच्छित उद्देश्य के लिए खुद को बेहतर बनाता है, यदि आप किसी लाइब्रेरी पर भरोसा करते हैं जो बाइट कहीं भी उपयोग करता है (एंड्रॉइड पर यूएसबी स्टैक दिमाग में आता है )।
जोड़ा लेखक user149408, स्रोत

शायद आपकी सबसे अच्छी शर्त बाइट की बजाय एक पूर्णांक का उपयोग करना है। इसमें बाइट को प्रतिस्थापित करने के लिए एक विशेष वस्तु बनाने के ऊपरी हिस्से के बिना 128 से अधिक संख्याओं की अनुमति देने का कमरा है।

यह मेरे द्वारा चुने गए लोगों द्वारा भी सुझाया जाता है (हर कोई)

0
जोड़ा

बिट मैनिपुलेशन/हस्ताक्षरित बाइट्स करने का सबसे अच्छा तरीका int s का उपयोग करके है। भले ही वे हस्ताक्षरित हैं, उनके पास एक हस्ताक्षरित बाइट के रूप में इलाज के लिए बहुत से अतिरिक्त बिट्स (32 कुल) हैं। साथ ही, सभी गणितीय ऑपरेटरों छोटे निश्चित सटीक संख्याओं को int में परिवर्तित कर देंगे। उदाहरण:

short a = 1s;
short b = 2s;
int c = a + b;//the result is up-converted
short small = (short)c;//must cast to get it back to short

इस वजह से केवल पूर्णांक के साथ रहना और उस बिट्स को प्राप्त करने के लिए मास्क करना सर्वोत्तम है जिसमें आप रुचि रखते हैं। उदाहरण:

int a = 32;
int b = 128;
int foo = (a + b) | 255;

Here is some more info on Java primitive types http://mindprod.com/jgloss/primitive.html

एक अंतिम मामूली नोट, जावा में एक हस्ताक्षरित निश्चित सटीक संख्या है। वह char आदिम है।

0
जोड़ा

I know this is a very late response, but I came across this thread when trying to do the exact same thing. The issue is simply trying to determine if a Java byte is >127.

सरल समाधान है:

if((val & (byte)0x80) != 0) { ... }

If the real issue is >128 instead, just adding another condition to that if-statement will do the trick.

0
जोड़ा

@pauldoo

अगर आप इसे ऐसा करते हैं तो अगर कथन और अतिरिक्त से छुटकारा पाने के लिए वास्तव में संभव है।

byte[] foobar = ..;
int value = (foobar[10] & 0xff);

इस प्रकार जावा बाइट को ऋणात्मक संख्या के रूप में नहीं समझता है और पूर्णांक पर साइन बिट को भी फ़्लिप करता है।

0
जोड़ा
दक्षता पर एक छोटा सा नोट: ऊपर की तरह एक अभिव्यक्ति को मूल मशीन निर्देशों में संकलित करते समय, जावा के हॉटस्पॉट क्लाइंट वीएम int पदोन्नति के लिए एक सामान्य बाइट करेगा ( साइन एक्सटेंशन ), उसके बाद एक और ऑपरेशन। हॉटस्पॉट सर्वर वीएम शून्य एक्सटेंशन के साथ प्रचार करने के लिए पर्याप्त स्मार्ट है, और एंड को छोड़ रहा है।
जोड़ा लेखक Boann, स्रोत