java - मैं लांग से बाइट[] और जावा में वापस कैसे परिवर्तित करूं?




byte long-integer (7)

मैं लंबे समय से बाइट [] और जावा में वापस कैसे परिवर्तित करूं? मैं एक लंबे समय तक बाइट को परिवर्तित करने की कोशिश कर रहा हूं [] ताकि मैं एक टीसीपी कनेक्शन पर बाइट [] भेज सकूं। दूसरी ओर मैं उस बाइट [] को लेना चाहता हूं और इसे दोबारा में बदलना चाहता हूं। किसी भी युक्तियां की सराहना की जाएगी।


अंतर्निहित ByteArrayOutputStream साथ बस DataOutputStream तक लंबा लिखें। ByteArrayOutputStream से आप बाइट-सरणी के माध्यम से बाइट-एरे प्राप्त कर सकते हैं toByteArray() :

class Main
{

        public static byte[] long2byte(long l) throws IOException
        {
        ByteArrayOutputStream baos=new ByteArrayOutputStream(Long.SIZE/8);
        DataOutputStream dos=new DataOutputStream(baos);
        dos.writeLong(l);
        byte[] result=baos.toByteArray();
        dos.close();    
        return result;
        }


        public static long byte2long(byte[] b) throws IOException
        {
        ByteArrayInputStream baos=new ByteArrayInputStream(b);
        DataInputStream dos=new DataInputStream(baos);
        long result=dos.readLong();
        dos.close();
        return result;
        }


        public static void main (String[] args) throws java.lang.Exception
        {

         long l=123456L;
         byte[] b=long2byte(l);
         System.out.println(l+": "+byte2long(b));       
        }
}

तदनुसार अन्य प्राइमेटिव के लिए काम करता है।

संकेत: टीसीपी के लिए आपको मैन्युअल रूप से बाइट [] की आवश्यकता नहीं है। आप एक Socket socket और इसकी धाराओं का उपयोग करेंगे

OutputStream os=socket.getOutputStream(); 
DataOutputStream dos=new DataOutputStream(os);
dos.writeLong(l);
//etc ..

बजाय।



आपको बाइट [] की आवश्यकता क्यों है? इसे सॉकेट में क्यों न लिखें?

मुझे लगता है कि आप लंबे समय के बजाय लंबा मतलब है, बाद वाले को शून्य मानों की अनुमति देने की आवश्यकता है।

DataOutputStream dos = new DataOutputStream(
     new BufferedOutputStream(socket.getOutputStream()));
dos.writeLong(longValue);

DataInputStream dis = new DataInputStream(
     new BufferedInputStream(socket.getInputStream()));
long longValue = dis.readLong();

मैं एक और जवाब जोड़ूंगा जो सबसे तेज़ संभव है ׂ (हाँ, स्वीकृत उत्तर से भी अधिक), लेकिन यह हर मामले के लिए काम नहीं करेगा। हालांकि, यह हर कल्पनीय परिदृश्य के लिए काम करेगा:

आप स्ट्रिंग को इंटरमीडिएट के रूप में आसानी से उपयोग कर सकते हैं। ध्यान दें, यह आपको सही परिणाम देगा, भले ही ऐसा लगता है कि स्ट्रिंग का उपयोग करने से गलत परिणाम मिलते हैं, क्योंकि आप जानते हैं कि आप "सामान्य" STRINGS के साथ काम कर रहे हैं। यह प्रभावशीलता बढ़ाने और कोड को सरल बनाने का एक तरीका है जो बदले में डेटा स्ट्रिंग्स पर कुछ मान्यताओं का उपयोग करना चाहिए।

इस विधि का उपयोग करने का कॉन: यदि आप ASCII तालिका की शुरुआत में इन प्रतीकों जैसे कुछ ASCII वर्णों के साथ काम कर रहे हैं, तो निम्न पंक्तियां विफल हो सकती हैं, लेकिन चलिए इसका सामना करते हैं - आप शायद उन्हें कभी भी उपयोग नहीं करेंगे।

इस विधि का उपयोग करने के प्रो: याद रखें कि ज्यादातर लोग आमतौर पर किसी भी असामान्य पात्रों के बिना कुछ सामान्य तारों के साथ काम करते हैं और फिर विधि जाने का सबसे सरल और तेज़ तरीका है।

लांग से बाइट []:

byte[] arr = String.valueOf(longVar).getBytes();

बाइट [] से लांग तक:

long longVar = Long.valueOf(new String(byteArr)).longValue();

यदि आप एक तेज़ अनियंत्रित संस्करण की तलाश में हैं, तो यह चाल चलाना चाहिए, 8 की लंबाई के साथ "बी" नामक एक बाइट सरणी मानना ​​चाहिए:

long l = ((((long) b[7]) << 56) | (((long) b[6] & 0xff) << 48) | (((long) b[5] & 0xff) << 40)
            | (((long) b[4] & 0xff) << 32) | (((long) b[3] & 0xff) << 24) | (((long) b[2] & 0xff) << 16)
            | (((long) b[1] & 0xff) << 8) | (((long) b[0] & 0xff)));

यदि आप पहले से सॉकेट को लिखने के लिए DataOutputStream का उपयोग कर रहे हैं, तो DataOutputStream एक अच्छा फिट हो सकता है। यहाँ एक उदाहरण है:

// Assumes you are currently working with a SocketOutputStream.

SocketOutputStream outputStream = ...
long longValue = ...

DataOutputStream dataOutputStream = new DataOutputStream(outputStream);

dataOutputStream.writeLong(longValue);
dataOutputStream.flush();

short , int , float , आदि के लिए समान तरीके हैं। फिर आप प्राप्त करने वाले पक्ष पर DataInputStream उपयोग कर सकते हैं।


public byte[] longToBytes(long x) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.putLong(x);
    return buffer.array();
}

public long bytesToLong(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.put(bytes);
    buffer.flip();//need flip 
    return buffer.getLong();
}

या बार-बार बाइटबफर बनाने से बचने के लिए कक्षा में लपेटा गया है:

public class ByteUtils {
    private static ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);    

    public static byte[] longToBytes(long x) {
        buffer.putLong(0, x);
        return buffer.array();
    }

    public static long bytesToLong(byte[] bytes) {
        buffer.put(bytes, 0, bytes.length);
        buffer.flip();//need flip 
        return buffer.getLong();
    }
}

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






long-integer