java - जावा में बाइट सरणी में इनपुटस्ट्रीम कनवर्ट करें




bytearray inputstream (20)

मैं एक संपूर्ण InputStream को बाइट सरणी में कैसे InputStream ?


@Adamski: आप बफर से पूरी तरह से बच सकते हैं।

कोड http://www.exampledepot.com/egs/java.io/File2ByteArray.html से कॉपी किया गया है (हां, यह बहुत verbose है, लेकिन अन्य समाधान के रूप में स्मृति के आधे आकार की जरूरत है।)

// Returns the contents of the file in a byte array.
public static byte[] getBytesFromFile(File file) throws IOException {
    InputStream is = new FileInputStream(file);

    // Get the size of the file
    long length = file.length();

    // You cannot create an array using a long type.
    // It needs to be an int type.
    // Before converting to an int type, check
    // to ensure that file is not larger than Integer.MAX_VALUE.
    if (length > Integer.MAX_VALUE) {
        // File is too large
    }

    // Create the byte array to hold the data
    byte[] bytes = new byte[(int)length];

    // Read in the bytes
    int offset = 0;
    int numRead = 0;
    while (offset < bytes.length
           && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
        offset += numRead;
    }

    // Ensure all the bytes have been read in
    if (offset < bytes.length) {
        throw new IOException("Could not completely read file "+file.getName());
    }

    // Close the input stream and return bytes
    is.close();
    return bytes;
}

अन्य मामले सर्वर के लिए अनुरोध भेजने और प्रतिक्रिया के लिए इंतजार करने के बाद स्ट्रीम के माध्यम से सही बाइट सरणी प्राप्त करने के लिए।

/**
         * Begin setup TCP connection to PC app
         * to open integrate connection between mobile app and pc app (or mobile app)
         */
        mSocket = new Socket(IP, port);
       // mSocket.setSoTimeout(30000);

        DataOutputStream mDos = new DataOutputStream(mSocket.getOutputStream());

        String str = "MobileRequest#" + params[0] + "#<EOF>";

        mDos.write(str.getBytes());

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /* Since data are accepted as byte, all of them will be collected in the
        following byte array which initialised with accepted data length. */
        DataInputStream mDis = new DataInputStream(mSocket.getInputStream());
        byte[] data = new byte[mDis.available()];

        // Collecting data into byte array
        for (int i = 0; i < data.length; i++)
            data[i] = mDis.readByte();

        // Converting collected data in byte array into String.
        String RESPONSE = new String(data);


आप इस और समान कार्यों को संभालने के लिए अपाचे कॉमन्स IO का उपयोग कर सकते हैं।

IOUtils प्रकार में IOUtils पढ़ने और byte[] वापस करने के लिए एक स्थिर विधि है।

InputStream is;
byte[] bytes = IOUtils.toByteArray(is);

आंतरिक रूप से यह एक ByteArrayOutputStream बनाता है और आउटपुट में बाइट कॉपी करता है, फिर ByteArrayOutputStream toByteArray() कॉल करता है। यह 4KiB के ब्लॉक में बाइट्स कॉपी करके बड़ी फ़ाइलों को संभालता है।


इसे DataInputStream में लपेटें यदि वह किसी कारण से तालिका से बाहर है, तो बस उस पर हथौड़ा पढ़ने के लिए उपयोग करें जब तक कि यह आपको -1 या पूरे ब्लॉक के लिए नहीं देता है।

public int readFully(InputStream in, byte[] data) throws IOException {
    int offset = 0;
    int bytesRead;
    boolean read = false;
    while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
        read = true;
        offset += bytesRead;
        if (offset >= data.length) {
            break;
        }
    }
    return (read) ? offset : -1;
}

कोड के नीचे

public static byte[] serializeObj(Object obj) throws IOException {
  ByteArrayOutputStream baOStream = new ByteArrayOutputStream();
  ObjectOutputStream objOStream = new ObjectOutputStream(baOStream);

  objOStream.writeObject(obj); 
  objOStream.flush();
  objOStream.close();
  return baOStream.toByteArray(); 
} 

या

BufferedImage img = ...
ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
ImageIO.write(img, "jpeg", baos);
baos.flush();
byte[] result = baos.toByteArray();
baos.close();

जावा 7 और बाद में:

import sun.misc.IOUtils;
...
InputStream in = ...;
byte[] buf = IOUtils.readFully(in, -1, false);

जावा 8 रास्ता ( BufferedReader और एडम बिएन के लिए धन्यवाद)

private static byte[] readFully(InputStream input) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(input))) {
        return buffer.lines().collect(Collectors.joining("\n")).getBytes(<charset_can_be_specified>);
    }
}

ध्यान दें कि यह समाधान कैरिज रिटर्न ('\ r') मिटा देता है और अनुचित हो सकता है।


मामले में कोई भी निर्भरता के बिना समाधान ढूंढ रहा है && यदि आपके पास फ़ाइल है

1) DataInputStream

 byte[] data = new byte[(int) file.length()];
 DataInputStream dis = new DataInputStream(new FileInputStream(file));
 dis.readFully(data);
 dis.close();

2) ByteArrayOutputStream

 InputStream is = new FileInputStream(file);
 ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 int nRead;
 byte[] data = new byte[(int) file.length()];
 while ((nRead = is.read(data, 0, data.length)) != -1) {
     buffer.write(data, 0, nRead);
 }

3) RandomAccessFile

 RandomAccessFile raf = new RandomAccessFile(file, "r");
 byte[] data = new byte[(int) raf.length()];
 raf.readFully(data);

मुझे पता है कि यह बहुत देर हो चुकी है लेकिन यहां मुझे लगता है कि क्लीनर समाधान है जो अधिक पठनीय है ...

/**
 * method converts {@link InputStream} Object into byte[] array.
 * 
 * @param stream the {@link InputStream} Object.
 * @return the byte[] array representation of received {@link InputStream} Object.
 * @throws IOException if an error occurs.
 */
public static byte[] streamToByteArray(InputStream stream) throws IOException {

    byte[] buffer = new byte[1024];
    ByteArrayOutputStream os = new ByteArrayOutputStream();

    int line = 0;
    // read bytes from stream, and store them in buffer
    while ((line = stream.read(buffer)) != -1) {
        // Writes bytes from byte array (buffer) into output stream.
        os.write(buffer, 0, line);
    }
    stream.close();
    os.flush();
    os.close();
    return os.toByteArray();
}

मैंने कचरा डेटा लिखने के लिए फिक्स के साथ @ नमन के जवाब को संपादित करने की कोशिश की लेकिन संपादन अस्वीकार कर दिया गया। जबकि कोड का यह छोटा टुकड़ा कुछ भी शानदार नहीं है, मैं किसी अन्य बेहतर उत्तर को नहीं देख सकता। यहां मुझे सबसे ज्यादा समझ में आता है:

ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024]; // you can configure the buffer size
int length;

while ((length = in.read(buffer)) != -1) out.write(buffer, 0, length); //copy streams
in.close(); // call this in a finally block

byte[] result = out.toByteArray();

बीटीडब्ल्यू ByteArrayOutputStream बंद नहीं होना चाहिए। कोशिश / आखिरकार पठनीयता के लिए छोड़ा गया है


यदि आप Google अमरूद का उपयोग करते हैं, तो यह उतना आसान होगा जितना:

byte[] bytes = ByteStreams.toByteArray(inputStream);

यदि आप अपाचे कॉमन्स-आईओ लाइब्रेरी का उपयोग नहीं करना चाहते हैं, तो यह स्निपेट सूरज से लिया जाता है। मिस्त्री कक्षा। बाइटबफर का उपयोग करके सामान्य कार्यान्वयन के रूप में यह लगभग दोगुना तेज़ है:

public static byte[] readFully(InputStream is, int length, boolean readAll)
        throws IOException {
    byte[] output = {};
    if (length == -1) length = Integer.MAX_VALUE;
    int pos = 0;
    while (pos < length) {
        int bytesToRead;
        if (pos >= output.length) { // Only expand when there's no room
            bytesToRead = Math.min(length - pos, output.length + 1024);
            if (output.length < pos + bytesToRead) {
                output = Arrays.copyOf(output, pos + bytesToRead);
            }
        } else {
            bytesToRead = output.length - pos;
        }
        int cc = is.read(output, pos, bytesToRead);
        if (cc < 0) {
            if (readAll && length != Integer.MAX_VALUE) {
                throw new EOFException("Detect premature EOF");
            } else {
                if (output.length != pos) {
                    output = Arrays.copyOf(output, pos);
                }
                break;
            }
        }
        pos += cc;
    }
    return output;
}

यह मेरा कॉपी-पेस्ट संस्करण है:

@SuppressWarnings("empty-statement")
public static byte[] inputStreamToByte(InputStream is) throws IOException {
    if (is == null) {
        return null;
    }
    // Define a size if you have an idea of it.
    ByteArrayOutputStream r = new ByteArrayOutputStream(2048);
    byte[] read = new byte[512]; // Your buffer size.
    for (int i; -1 != (i = is.read(read)); r.write(read, 0, i));
    is.close();
    return r.toByteArray();
}

यहां एक अनुकूलित संस्करण है, जो डेटा बाइट्स को जितना संभव हो कॉपी करने से बचने का प्रयास करता है:

private static byte[] loadStream (InputStream stream) throws IOException {
   int available = stream.available();
   int expectedSize = available > 0 ? available : -1;
   return loadStream(stream, expectedSize); }

private static byte[] loadStream (InputStream stream, int expectedSize) throws IOException {
   int basicBufferSize = 0x4000;
   int initialBufferSize = (expectedSize >= 0) ? expectedSize : basicBufferSize;
   byte[] buf = new byte[initialBufferSize];
   int pos = 0;
   while (true) {
      if (pos == buf.length) {
         int readAhead = -1;
         if (pos == expectedSize) {
            readAhead = stream.read();       // test whether EOF is at expectedSize
            if (readAhead == -1) {
               return buf; }}
         int newBufferSize = Math.max(2 * buf.length, basicBufferSize);
         buf = Arrays.copyOf(buf, newBufferSize);
         if (readAhead != -1) {
            buf[pos++] = (byte)readAhead; }}
      int len = stream.read(buf, pos, buf.length - pos);
      if (len < 0) {
         return Arrays.copyOf(buf, pos); }
      pos += len; }}

वेनिला जावा के DataInputStream का उपयोग करें और इसकी readFully विधि (कम से कम जावा 1.4 के बाद से मौजूद है):

...
byte[] imgDataBa = new byte[(int)imgFile.length()];
DataInputStream dataIs = new DataInputStream(new FileInputStream(imgFile));
dataIs.readFully(imgDataBa);
...

इस विधि के कुछ अन्य स्वाद हैं, लेकिन मैं इस उपयोग के मामले में हर समय इसका उपयोग करता हूं।


InputStream.available() दस्तावेज़ देखें:

यह विशेष रूप से महत्वपूर्ण है कि आपको इस विधि का उपयोग कंटेनर के आकार के लिए नहीं करना चाहिए और मान लें कि आप कंटेनर का आकार बदलने के बिना स्ट्रीम की संपूर्णता को पढ़ सकते हैं। ऐसे कॉलर्स को शायद बाइटएरे ऑटपुटस्ट्रीम में जो कुछ भी पढ़ा जाता है उसे लिखना चाहिए और इसे बाइट सरणी में परिवर्तित करना चाहिए। वैकल्पिक रूप से, यदि आप किसी फ़ाइल से पढ़ रहे हैं, तो फ़ाइल। लम्बाई फ़ाइल की वर्तमान लंबाई लौटाती है (हालांकि फ़ाइल की लंबाई को बदलना गलत नहीं हो सकता है, हालांकि फ़ाइल को पढ़ना मूल रूप से दुर्लभ है)।


/*InputStream class_InputStream = null;
I am reading class from DB 
class_InputStream = rs.getBinaryStream(1);
Your Input stream could be from any source
*/
int thisLine;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((thisLine = class_InputStream.read()) != -1) {
    bos.write(thisLine);
}
bos.flush();
byte [] yourBytes = bos.toByteArray();

/*Don't forget in the finally block to close ByteArrayOutputStream & InputStream
 In my case the IS is from resultset so just closing the rs will do it*/

if (bos != null){
    bos.close();
}

Input Stream is ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int next = in.read();
while (next > -1) {
    bos.write(next);
    next = in.read();
}
bos.flush();
byte[] result = bos.toByteArray();

public static byte[] getBytesFromInputStream(InputStream is) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(); 
    byte[] buffer = new byte[0xFFFF];
    for (int len = is.read(buffer); len != -1; len = is.read(buffer)) { 
        os.write(buffer, 0, len);
    }
    return os.toByteArray();
}






inputstream