Determinare la dimensione di un InputStream

Question

La mia situazione attuale è: devo leggere un file e mettere il contenuto in InputStream. Successivamente devo posizionare il contenuto della InputStream in un array di byte che richiede (per quanto ne so) la dimensione del InputStream. Tutte le idee?

Come richiesto, mi mostrerà il flusso di input che sto creando da un file caricato

InputStream uploadedStream = null;
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
java.util.List items = upload.parseRequest(request);      
java.util.Iterator iter = items.iterator();

while (iter.hasNext()) {
    FileItem item = (FileItem) iter.next();
    if (!item.isFormField()) {
        uploadedStream = item.getInputStream();
        //CHANGE uploadedStreambyte = item.get()
    }
}

La richiesta è un oggetto HttpServletRequest, che è come il FileItemFactory e ServletFileUpload è dal pacchetto Apache Commons FileUpload.

Answer 1

Volevo solo aggiungere, Apache Commons IO ha utilità di supporto di flusso per eseguire la copia. (A proposito, che cosa vuoi dire posizionando il file in un InputStream? Ci puoi mostrare il tuo codice?)

Modifica

D'accordo, che cosa si vuole fare con il contenuto della voce? C'è un href="http://commons.apache.org/fileupload/apidocs/org/apache/commons/fileupload/FileItem.html#get()" rel="noreferrer"> item.get() l'intera cosa in un array di byte.

Edit2

item.getSize() restituirà il file rel="noreferrer"> href="http://commons.apache.org/fileupload/apidocs/org/apache/commons/fileupload/FileItem.html#getSize()" .

Answer 2

Questa è una discussione molto vecchio, ma era pur sempre la prima cosa da pop-up quando ho cercato su google il problema. Quindi volevo solo aggiungere questo:

InputStream inputStream = conn.getInputStream();
int length = inputStream.available();

Ha lavorato per me. E molto più semplice rispetto alle altre risposte qui.

Answer 3

avrei letto in una ByteArrayOutputStream e quindi chiamare toByteArray () per ottenere la matrice di byte risultante. Non è necessario per definire la dimensione in anticipo (anche se è forse un'ottimizzazione se si sa che . In molti casi non sarà)

Answer 4

Non è possibile determinare la quantità di dati in un flusso senza leggerlo; È possibile, tuttavia, chiedere la dimensione di un file:

http: // java. sun.com/javase/6/docs/api/java/io/File.html#length ()

Se questo non è possibile, è possibile scrivere i byte che si leggono dal flusso di input ad un ByteArrayOutputStream che crescerà come richiesto.

Answer 5

è possibile ottenere la dimensione di InputStream usando getBytes (InputStream) di Utils.java controllare questo link seguente

Get byte dal InputStream

Answer 6

Per InputStream

org.apache.commons.io.IoUtils.toByteArray(inputStream).length

Per opzionale

Stream.of(multipartFile.get()).mapToLong(file->file.getSize()).findFirst().getAsLong()

Answer 7

Quando esplicitamente che fare con un ByteArrayInputStream poi in contrasto con alcuni dei commenti di questa pagina è possibile utilizzare la funzione di .available() per ottenere la dimensione. Basta avere a che fare prima di iniziare a leggere da esso.

Dalle JavaDocs:

  

Restituisce il numero di byte rimanenti che possono essere letti (o saltati   oltre) da questo flusso di input. Il valore restituito è contare - pos, che   è il numero di byte rimanenti da leggere dal buffer di ingresso.

https: // docs .oracle.com / JavaSE / 7 / docs / api / java / io / ByteArrayInputStream.html # disponibile ()

Answer 8

Se sapete che il vostro è un InputStream FileInputStream o un ByteArrayInputStream, è possibile utilizzare un po 'di riflessione per arrivare alla dimensione del flusso di senza leggere l'intero contenuto . Ecco un metodo di esempio:

static long getInputLength(InputStream inputStream) {
    try {
        if (inputStream instanceof FilterInputStream) {
            FilterInputStream filtered = (FilterInputStream)inputStream;
            Field field = FilterInputStream.class.getDeclaredField("in");
            field.setAccessible(true);
            InputStream internal = (InputStream) field.get(filtered);
            return getInputLength(internal);
        } else if (inputStream instanceof ByteArrayInputStream) {
            ByteArrayInputStream wrapper = (ByteArrayInputStream)inputStream;
            Field field = ByteArrayInputStream.class.getDeclaredField("buf");
            field.setAccessible(true);
            byte[] buffer = (byte[])field.get(wrapper);
            return buffer.length;
        } else if (inputStream instanceof FileInputStream) {
            FileInputStream fileStream = (FileInputStream)inputStream;
            return fileStream.getChannel().size();
        }
    } catch (NoSuchFieldException | IllegalAccessException | IOException exception) {
        // Ignore all errors and just return -1.
    }
    return -1;
}

Questo potrebbe essere esteso per supportare flussi di input supplementari, ne sono certo.

Answer 9

Con questo metodo, non resta che passare l'InputStream

public String readIt(InputStream is) {
    if (is != null) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is, "utf-8"), 8);

        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            sb.append(line).append("\n");
        }
        is.close();
        return sb.toString();
    }
    return "error: ";
}

Answer 10

    try {
        InputStream connInputStream = connection.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    int size = connInputStream.available();

int disponibili () Restituisce una stima del numero di byte che possono essere letti (o saltati) da questo flusso di input senza bloccare il successivo richiamo di un metodo per questo flusso di input. La prossima chiamata potrebbe essere lo stesso filo o altro thread. Una singola lettura o saltare questo molti byte non bloccheranno, ma possono leggere o saltare meno byte.

InputStream - Android SDK | Sviluppatori Android