java - क्या जावा बाइट आदिम प्रकार के लिए कोई वास्तविक जीवन उपयोग है?




types byte (7)

8 बिट हस्ताक्षरित नमूनों के साथ डिजिटाइज्ड ध्वनि (या कोई अन्य सिग्नल) मेरे लिए एकमात्र उचित उदाहरण जैसा लगता है। बेशक बाइट्स पर हस्ताक्षर करने के लिए ऐसे संकेतों को संभालने की कोई आवश्यकता नहीं है और यह तर्क दिया जा सकता है कि जावा बाइट "पूरी तरह फिट बैठता है"।

व्यक्तिगत रूप से मुझे लगता है कि हस्ताक्षर नहीं किया गया एक गलती है। न केवल इसलिए कि बिना हस्ताक्षरित बाइट्स / इनट्स के लिए अधिक उपयोग है, लेकिन क्योंकि मैं एक मजबूत प्रकार की प्रणाली पसंद करता हूं। यह निर्दिष्ट करने में सक्षम होना अच्छा होगा कि ऋणात्मक संख्या मान्य नहीं हैं और उल्लंघन के लिए कंपाइलर चेक और रनटाइम अपवादों की अनुमति देते हैं।

कुछ अतुलनीय कारणों से जावा में byte आदिम प्रकार पर हस्ताक्षर किए गए हैं। इसका मतलब यह है कि मान्य मान -128..127 सामान्य 0..255 रेंज के बजाय बाइट में 8 महत्वपूर्ण बिट्स का प्रतिनिधित्व करते हैं (बिना साइन बिट के)।

इसका मतलब यह है कि सभी बाइट मैनिपुलेशन कोड आमतौर पर पूर्णांक गणना करता है और अंतिम 8 बिट्स को मास्किंग समाप्त करता है।

मैं सोच रहा था कि क्या कोई वास्तविक जीवन परिदृश्य है जहां जावा byte आदिम प्रकार पूरी तरह से फिट बैठता है या यदि यह केवल एक पूरी तरह से बेकार डिजाइन निर्णय है?

संपादित करें: मूल कोड के लिए एकमात्र वास्तविक उपयोग केस एकल-बाइट प्लेसहोल्डर था। दूसरे शब्दों में, जावा कोड के अंदर बाइट के रूप में छेड़छाड़ नहीं किया जाना चाहिए।

संपादित करें: मैंने अब एक जगह देखी है जहां एक आंतरिक तंग लूप को 7 (संख्या 0..32) से विभाजित करने की आवश्यकता है, इसलिए एक लुकअप टेबल बाइट्स के साथ डेटाटाइप के रूप में किया जा सकता है ताकि स्मृति उपयोग को एल 1 कैश उपयोग की कम सोच रखा जा सके । यह हस्ताक्षरित / हस्ताक्षरितता का संदर्भ नहीं देता है लेकिन वास्तविक उपयोग का मामला था।


8 बिट्स से बड़े शब्दों वाले मशीन पर यह कुछ हद तक उपयोगी होता है यदि आप एक एकल सरणी में 8-बिट रेंज में फिट होने वाले बहुत से मूल्यों को स्टोर करना चाहते हैं, लेकिन आम तौर पर इन्हें उपयोग करने का अच्छा विचार नहीं है अन्यथा बाइट वास्तव में है एक int की तुलना में स्मृति से बाहर निकलने के लिए और अधिक प्रयास।

याद रखें कि जावा को बहुत कम उपभोक्ता डिवाइस (सेट-टॉप टीवी बॉक्स) के लिए डिज़ाइन किया गया था। मुझे उम्मीद है कि अगर इसे छोटे 8-बिट माइक्रोप्रोसेसरों पर इस तरह इस्तेमाल किया गया था तो यह अधिक उपयोगी होता क्योंकि यह शब्द के आकार को ठीक से फिट करेगा और सामान्य "गणित" संचालन के लिए बहुत छोटे पैमाने पर उपयोग किया जा सकता है।

एकमात्र कारण यह है कि मैं इसे हस्ताक्षर करने के लिए देख सकता हूं कि एक इंटिनेटेड बाइट एक इंट के साथ इंटरैक्टिंग थोड़ा उलझन में हो सकता है - लेकिन मुझे विश्वास नहीं है कि यह एक हस्ताक्षरित व्यक्ति से ज्यादा भ्रमित है!


जब मैं प्रोग्रामिंग सॉफ्टवेयर और जे 2 एमई के लिए गेम प्रोग्रामिंग करता था तो मैंने इसे अक्सर इस्तेमाल किया। अधिकांश जे 2 एमई-डिवाइसों पर, आपके पास सीमित संसाधन हैं, इसलिए उदाहरण के लिए संग्रह करना बाइट-सरणी में एक स्तर का नक्शा एक इंट-एरे में संग्रहीत करने से कम संसाधन-गहन है।


जावा कार्ड के लिए एप्लेट विकास में byte का व्यापक उपयोग है। चूंकि कार्ड सीमित संसाधन हैं, स्मृति की हर बिट कीमती है। वैसे ही कार्ड प्रोसेसर की पूर्णांक मानों की प्रसंस्करण में सीमाएं होती हैं। int टाइप समर्थन वैकल्पिक है और java.lang.String समर्थित नहीं है इसलिए सभी पूर्णांक ऑपरेशन और डेटा संग्रहण byte और short चर और सरणी द्वारा किया जाता है। चूंकि पूर्णांक अक्षर int प्रकार के होते हैं, इसलिए उन्हें स्पष्ट रूप से पूरे कोड में byte या short करने के लिए डाला जाना चाहिए। कार्ड के साथ संचार एपीडीयू कमांड के माध्यम से जाता है जिसे एप्लेट को byte एस के सरणी के रूप में सौंप दिया जाता है जिसे byte एस को कमांड क्लास, निर्देश और पैरामीटर को डीकोड करने के लिए विघटित किया जाना चाहिए। निम्नलिखित कोड को देखते हुए आप देखते हैं कि जावा कार्ड विकास के लिए कितने byte और short प्रकार महत्वपूर्ण हैं:

package somepackage.SomeApplet;

import javacard.framework.*;
import org.globalplatform.GPSystem;
import org.globalplatform.SecureChannel;

public class SomeApplet extends Applet {

    // Card status
    private final static byte ST_UNINITIALIZED     = (byte) 0x01;
    private final static byte ST_INITIALIZED       = (byte) 0x02;

    // Instructions & Classes
    private final static byte PROP_CLASS           = (byte) 0x80;     

    private final static byte INS_INIT_UPDATE      = (byte) 0x50;
    private final static byte INS_EXT_AUTH         = (byte) 0x82;

    private final static byte INS_PUT_DATA         = (byte) 0xDA;
    private final static byte INS_GET_RESPONSE     = (byte) 0xC0;
    private final static byte INS_GET_DATA         = (byte) 0xCA;


    private final static short SW_CARD_NOT_INITIALIZED       = (short) 0x9101;  
    private final static short SW_CARD_ALREADY_INITIALIZED   = (short) 0x9102;  

    private final static byte OFFSET_SENT = 0x00;
    private final static byte OFFSET_RECV = 0x01;
    private static short[] offset;

    private static byte[] fileBuffer;
    private static short fileSize = 0;

    public static void install(byte[] bArray, short bOffset, byte bLength) {
        new SomeApplet( bArray, bOffset, bLength);
    }

    public RECSApplet(byte[] bArray, short bOffset, byte bLength) {
        offset = JCSystem.makeTransientShortArray((short) 2, JCSystem.CLEAR_ON_RESET);
        fileBuffer = new byte[FILE_SIZE];

        byte aidLen = bArray[bOffset];
        if (aidLen== (byte)0){
            register();
        } else {
            register(bArray, (short)(bOffset+1), aidLen);
        }
    }

    public void process(APDU apdu) {
        if (selectingApplet()) {
            return;
        }
        byte[] buffer = apdu.getBuffer();
        short len = apdu.setIncomingAndReceive(); 

        byte cla = buffer[ISO7816.OFFSET_CLA];
        byte ins = buffer[ISO7816.OFFSET_INS];
        short lc = (short) (buffer[ISO7816.OFFSET_LC] & 0x00ff); 

        while (len < lc) {
            len += apdu.receiveBytes(len);
        }

        SecureChannel sc = GPSystem.getSecureChannel();
        if ((short)(cla & (short)0x80) == ISO7816.CLA_ISO7816) {
            switch (ins) {
                case INS_PUT_DATA:
                    putData(buffer, ISO7816.OFFSET_CDATA, offset[OFFSET_RECV], len);

                    if ((cla & 0x10) != 0x00) {
                        offset[OFFSET_RECV] += len;
                    } else {
                        fileSize = (short) (offset[OFFSET_RECV] + len);
                        offset[OFFSET_RECV] = 0;
                    }
                    return;

                case INS_GET_DATA:
                case INS_GET_RESPONSE:
                    sendData(apdu);
                    return;
                default:
                    ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
            }

        }
        else if ((byte) (cla & PROP_CLASS) == PROP_CLASS) {
            switch (ins) {
                case INS_INIT_UPDATE:
                case INS_EXT_AUTH:
                    apdu.setOutgoingAndSend(ISO7816.OFFSET_CDATA, sc.processSecurity(apdu));
                    return;
                default:
                    ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
            }
        } else
            ISOException.throwIt(ISO7816.SW_CLA_NOT_SUPPORTED);
    }

    // Some code omitted

}

बाइट का आकार 8 बिट्स है। बाइट का आकार किसी फ़ाइल को लिखने या फ़ाइल से पढ़ने जैसे कार्यों को निष्पादित करते समय इनपुट और आउटपुट को प्रोसेस करने में मदद करता है। उस परिदृश्य पर विचार करें जिसमें आप कीबोर्ड से या किसी भी फ़ाइल से इनपुट पढ़ना चाहते हैं। यदि आप "बाइट" डेटा संरचना का उपयोग करते हैं, तो आप जानते हैं कि एक समय में आप एक वर्ण प्राप्त कर रहे हैं क्योंकि आकार 8 बिट्स है। इसलिए हर बार जब आप एक इनपुट स्ट्रीम प्राप्त करते हैं, तो आप जानते हैं कि आप वास्तव में एक समय में एक चरित्र प्राप्त कर रहे हैं।


मुझे लगता है कि यह संक्षिप्त और int के साथ संगत होने के लिए हस्ताक्षरित है।

यह कितना उपयोग किया जाता है, यह एक प्राचीन के बजाय "बाइट सरणी" की धारणा बनाता है।

यह वास्तव में मेरे पास है। :)


byte, short, char प्रकार अधिकतर बेकार होते हैं, सिवाय जब अंतरिक्ष बचाने के लिए सरणी में उपयोग किया जाता है।

न तो जावा या जेवीएम के लिए उनके लिए कोई वास्तविक समर्थन है। उन पर लगभग सभी परिचालन उन्हें पहले या long बढ़ावा देंगे। हम कुछ भी लिख नहीं सकते हैं

short a=1, b=2;
a = a + b;  // illegal
a = a << 1; // illegal

फिर क्यों बिल्ली भी byte, short, char प्रकारों पर परिभाषित परिभाषाओं से परेशान है?

वे जो भी करते हैं वे रूपांतरणों को चौड़ा करने में घुसपैठ कर रहे हैं जो प्रोग्रामर को आश्चर्यचकित करेंगे।





byte