Bestimmen Sie die Größe eines InputStreams

Meine aktuelle Situation ist: Ich muss eine Datei lesen und den Inhalt einfügen InputStream. Danach muss ich den Inhalt von InputStreamin ein Byte-Array einfügen, das (soweit ich weiß) die Größe von erfordert InputStream. Irgendwelche Ideen?

Wie gewünscht, zeige ich den Eingabestream an, den ich aus einer hochgeladenen Datei erstelle

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

Der Antrag ist ein HttpServletRequestObjekt, das wie das ist FileItemFactoryund ServletFileUploadist aus dem Apache Commons Fileupload - Paket.

Ich wollte nur hinzufügen, Apache Commons IO hat Stream-Support-Dienstprogramme, um die Kopie durchzuführen. (Übrigens, was meinst du mit dem Platzieren der Datei in einem Inputstream? Kannst du uns deinen Code zeigen?)

Bearbeiten:

Okay, was möchten Sie mit dem Inhalt des Artikels machen? Es gibt eine, item.get() die das Ganze in einem Byte-Array zurückgibt .

Edit2

item.getSize()gibt die hochgeladene Dateigröße zurück .

Dies ist ein WIRKLICH alter Thread, aber es war immer noch das erste, was auftauchte, als ich das Problem googelte. Also wollte ich nur folgendes hinzufügen:

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

Hat für mich gearbeitet. Und VIEL einfacher als die anderen Antworten hier.

Warnung Diese Lösung liefert keine zuverlässigen Ergebnisse hinsichtlich der Gesamtgröße eines Streams. Außer aus dem JavaDoc:

Beachten Sie, dass einige Implementierungen von {@code InputStream} * die Gesamtzahl der Bytes im Stream zurückgeben, viele jedoch nicht.

Ich würde in einen ByteArrayOutputStream einlesen und dann toByteArray () aufrufen , um das resultierende Byte-Array zu erhalten. Sie müssen die Größe nicht im Voraus definieren (obwohl dies möglicherweise eine Optimierung ist, wenn Sie sie kennen . In vielen Fällen werden Sie dies nicht tun ).

Sie können die Datenmenge in einem Stream nicht bestimmen, ohne sie zu lesen. Sie können jedoch nach der Größe einer Datei fragen:

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

Wenn dies nicht möglich ist, können Sie die aus dem Eingabestream gelesenen Bytes in einen ByteArrayOutputStream schreiben, der nach Bedarf wächst.

Für InputStream

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

Für optionales <MultipartFile>

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

Sie können die Größe von InputStream mit getBytes (inputStream) von Utils.java ermitteln. Überprüfen Sie diesen folgenden Link

Holen Sie sich Bytes von Inputstream

Wenn Sie sich explizit mit einem ByteArrayInputStreamdann entgegen einigen Kommentaren auf dieser Seite befassen , können Sie die .available()Funktion verwenden, um die Größe zu ermitteln. Sie müssen es nur tun, bevor Sie anfangen, daraus zu lesen.

Aus den JavaDocs:

Gibt die Anzahl der verbleibenden Bytes zurück, die von diesem Eingabestream gelesen (oder übersprungen) werden können. Der zurückgegebene Wert ist count - pos. Dies ist die Anzahl der Bytes, die noch aus dem Eingabepuffer gelesen werden müssen.

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

Wenn Sie wissen, dass InputStreames sich um ein FileInputStreamoder ein handelt ByteArrayInputStream, können Sie eine kleine Reflexion verwenden, um die Stream-Größe zu ermitteln, ohne den gesamten Inhalt zu lesen . Hier ist eine Beispielmethode:

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

Ich bin mir sicher, dass dies erweitert werden könnte, um zusätzliche Eingabestreams zu unterstützen.

Verwenden Sie diese Methode, Sie müssen nur den InputStream übergeben

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

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

    int size = connInputStream.available();

int available () Gibt eine Schätzung der Anzahl der Bytes zurück, die aus diesem Eingabestream gelesen (oder übersprungen) werden können, ohne beim nächsten Aufruf einer Methode für diesen Eingabestream blockiert zu werden. Der nächste Aufruf kann der gleiche Thread oder ein anderer Thread sein. Ein einzelnes Lesen oder Überspringen dieser vielen Bytes blockiert nicht, kann jedoch weniger Bytes lesen oder überspringen.

InputStream - Android SDK | Android-Entwickler