Konwertuj strumień wejściowy na tablicę bajtów w Javie

Musisz odczytać każdy bajt z InputStream i zapisać go do ByteArrayOutputStream. Następnie można pobrać bazową tablicę bajtów, wywołując toByteArray(); np.

InputStream is = ...
ByteArrayOutputStream buffer = new ByteArrayOutputStream();

int nRead;
byte[] data = new byte[16384];

while ((nRead = is.read(data, 0, data.length)) != -1) {
  buffer.write(data, 0, nRead);
}

buffer.flush();

return buffer.toByteArray();

Wreszcie, po dwudziestu latach, jest proste rozwiązanie bez potrzeby korzystania z biblioteki stron trzecich, dzięki Java 9:

InputStream is;
…
byte[] array = is.readAllBytes();

Zwróć również uwagę na metody wygodyreadNBytes(byte[] b, int off, int len) oraz transferTo(OutputStream) zaspokajanie powtarzających się potrzeb.

Jeśli zdarzy ci się użyć Google guava , będzie to tak proste, jak:

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

Użyj metody vanilla Java DataInputStream i jej metody readFully (istnieje od co najmniej Javy 1.4):

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

Istnieją inne smaki tej metody, ale używam tego cały czas w tym przypadku użycia.

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();
}

Jak zawsze, również Spring framework (spring-core od wersji 3.2.2) ma coś dla ciebie: StreamUtils.copyToByteArray()

Czy naprawdę potrzebujesz obrazu jako byte[]? Czego dokładnie oczekujesz w byte[] - pełnej zawartości pliku obrazu, zakodowanej w dowolnym formacie pliku obrazu, lub wartości pikseli RGB?

Inne odpowiedzi tutaj pokazują, jak odczytać plik do byte[]. Twój byte[] będzie zawierał dokładną zawartość pliku, i musisz go dekodować, aby zrobić cokolwiek z danymi obrazu.

Standardowym API Javy do odczytu (i zapisu) obrazów jest ImageIO API, które można Znajdź w opakowaniu javax.imageio. Można odczytać obraz z pliku zawierającego tylko jedną linię kodu:

BufferedImage image = ImageIO.read(new File("image.jpg"));

To da ci BufferedImage, a nie byte[]. Aby uzyskać dane obrazu, możesz zadzwonić getRaster() na BufferedImage. To daje Raster obiekt, który ma metody dostępu do danych pikseli (ma kilka getPixel() / getPixels() metody).

Przeszukuje dokumentację API dla javax.imageio.ImageIO, java.awt.image.BufferedImage, java.awt.image.Raster itd.

ImageIO domyślnie obsługuje wiele formatów obrazów: JPEG, PNG, BMP, WBMP i GIF. Możliwe jest dodanie obsługi większej liczby formatów (potrzebna będzie wtyczka implementująca interfejs dostawcy usług ImageIO).

Zobacz także poniższy samouczek: praca z obrazkami

Jeśli nie chcesz korzystać z biblioteki Apache commons-io, ten fragment jest pobrany ze słońca.misc.Zajęcia joutils. Jest prawie dwa razy szybsza od zwykłej implementacji wykorzystującej Bytebuffery:

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;
}

W przypadku, gdy ktoś nadal szuka rozwiązania bez zależności i Jeśli Masz plik .

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);

@Adamski: można całkowicie uniknąć bufora.

Kod skopiowany z http://www.exampledepot.com/egs/java.io/File2ByteArray.html (tak, jest bardzo gadatliwy, ale potrzebuje o połowę mniej pamięci niż inne rozwiązanie.)

// 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;
}

ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
while (true) {
    int r = in.read(buffer);
    if (r == -1) break;
    out.write(buffer, 0, r);
}

byte[] ret = out.toByteArray();

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();
bos.close();

Java 9 da Ci wreszcie fajną metodę:

InputStream in = ...;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
in.transferTo( bos );
byte[] bytes = bos.toByteArray();

Wiem, że jest za późno, ale tutaj myślę, że jest czystsze rozwiązanie, które jest bardziej czytelne...

/**
 * 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();
}

Próbowałem edytować odpowiedź @ numan z poprawką do zapisu danych śmieci, ale edycja została odrzucona. Chociaż ten krótki fragment kodu nie jest niczym genialnym, nie widzę innej lepszej odpowiedzi. Oto co ma dla mnie największy sens:

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();

Btw ByteArrayOutputStream nie musi być zamknięty. try / finally konstrukty pominięte dla czytelności

Zobacz InputStream.available() dokumentację:

Jest szczególnie ważne, aby zdać sobie sprawę, że nie wolno używać tego sposób na rozmiar kontenera i założenie, że można odczytać całość strumienia bez konieczności zmiany rozmiaru pojemnika. Tacy rozmówcy powinni chyba napisać wszystko, co przeczytali do ByteArrayOutputStream i przekonwertować ją na tablicę bajtów. Alternatywnie, jeśli czytasz z pliku, Pliku.length zwraca bieżącą długość pliku (choć zakładając, że długość pliku nie może ulec zmianie może być nieprawidłowa, odczyt pliku jest z natury racy).

Java 7 i Później:

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

Java 8 way (dzięki BufferedReader i Adam Bien)

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>);
    }
}

Zauważ że to rozwiązanie usuwareturn ('\R') i może być nieodpowiednie.

Drugi przypadek, aby uzyskać poprawną tablicę bajtów poprzez stream, po wysłaniu żądania do serwera i oczekiwaniu na odpowiedź.

/**
         * 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);

Robisz dodatkową kopię, jeśli używasz ByteArrayOutputStream. Jeśli znasz długość strumienia przed rozpoczęciem jego czytania (np. strumień wejściowy jest w rzeczywistości strumieniem plików i możesz wywołać plik.length() na pliku, lub InputStream jest wpisem zipfile InputStream i możesz wywołać zipEntry.length ()), wtedy o wiele lepiej jest zapisywać Bezpośrednio do tablicy byte [] -- zużywa połowę pamięci i oszczędza czas.

// Read the file contents into a byte[] array
byte[] buf = new byte[inputStreamLength];
int bytesRead = Math.max(0, inputStream.read(buf));

// If needed: for safety, truncate the array if the file may somehow get
// truncated during the read operation
byte[] contents = bytesRead == inputStreamLength ? buf
                  : Arrays.copyOf(buf, bytesRead);

N. B. ostatnia linijka powyżej dotyczy plików uzyskiwanych okrojona podczas odczytu strumienia, jeśli trzeba obsłużyć tę możliwość, ale jeśli plik zostanie dłuższy podczas odczytu strumienia, zawartość tablicy bajtu[] nie zostanie wydłużona w celu uwzględnienia nowej zawartości pliku, tablica zostanie po prostu obcięta do starej długości inputStreamLength.

Używam tego.

public static byte[] toByteArray(InputStream is) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        try {
            byte[] b = new byte[4096];
            int n = 0;
            while ((n = is.read(b)) != -1) {
                output.write(b, 0, n);
            }
            return output.toByteArray();
        } finally {
            output.close();
        }
    }

To jest moja wersja kopiuj-wklej:

@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();
}

Owinąć go w DataInputStream jeśli to jest poza tabelą z jakiegoś powodu, po prostu użyj read, aby młotkować go, dopóki nie da ci -1 lub cały blok, o który prosiłeś.

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;
}

Możesz spróbować Cactoos :

byte[] array = new BytesOf(stream).bytes();

Widzimy pewne opóźnienie dla kilku transakcji AWS podczas konwersji obiektu S3 na ByteArray.

Uwaga: obiekt S3 to dokument PDF (maksymalny rozmiar to 3 mb).

Używamy opcji # 1 (org.apache.commons.io.ioutils), aby przekonwertować obiekt S3 na ByteArray. Zauważyliśmy, że S3 dostarcza wbudowaną metodę IOUtils do konwersji obiektu S3 na ByteArray, prosimy o potwierdzenie, jaki jest najlepszy sposób konwersji obiektu S3 na ByteArray, aby uniknąć opóźnienia.

Opcja #1:

import org.apache.commons.io.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

Opcja # 2:

import com.amazonaws.util.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

Daj mi również znać, jeśli mamy inny lepszy sposób na przekonwertowanie obiektu s3 na bytearray

Oto zoptymalizowana wersja, która stara się unikać kopiowania bajtów danych w jak największym stopniu:

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;
   }
}

Poniżej Kody

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(); 
} 

Lub

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

/*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();
}

To działa dla mnie,

if(inputStream != null){
                ByteArrayOutputStream contentStream = readSourceContent(inputStream);
                String stringContent = contentStream.toString();
                byte[] byteArr = encodeString(stringContent);
            }

ReadSourceContent ()

public static ByteArrayOutputStream readSourceContent(InputStream inputStream) throws IOException {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        int nextChar;
        try {
            while ((nextChar = inputStream.read()) != -1) {
                outputStream.write(nextChar);
            }
            outputStream.flush();
        } catch (IOException e) {
            throw new IOException("Exception occurred while reading content", e);
        }

        return outputStream;
    }

EncodeString ()

public static byte[] encodeString(String content) throws UnsupportedEncodingException {
        byte[] bytes;
        try {
            bytes = content.getBytes();

        } catch (UnsupportedEncodingException e) {
            String msg = ENCODING + " is unsupported encoding type";
            log.error(msg,e);
            throw new UnsupportedEncodingException(msg, e);
        }
        return bytes;
    }