Bestimmen Sie die Größe eines Input

Question

Meine aktuelle Situation ist: Ich habe eine Datei zu lesen und den Inhalt in InputStream setzen. Danach muss ich den Inhalt des InputStream in ein Byte-Array platziert werden, die erfordert (soweit ich weiß) die Größe des InputStream. Irgendwelche Ideen?

Wie gewünscht, werde ich den Eingangsstrom zeigt, dass ich aus einer hochgeladenen Datei erschaffe

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

Die Anforderung ist ein HttpServletRequest Objekt, das wie die FileItemFactory und ServletFileUpload aus dem Fileupload-Paket Apache Commons ist.

Answer 1

Ich wollte nur hinzufügen, Apache Commons IO hat Strom Support-Dienstprogramme die Kopie auszuführen. (Btw, was meinen Sie, indem Sie die Datei in einen Eingabestrom platzieren? Können Sie uns Ihren Code zeigen?)

Edit:

Okay, was wollen Sie mit dem Inhalt des Artikels zu tun? Es gibt eine item.get() die das ganze in einem Byte-Array.

EDIT2

item.getSize() die hochgeladen Datei zurück Größe .

Answer 2

Dies ist ein wirklich alter Thread, aber es war immer noch das erste, was Pop-up, wenn ich das Problem gegoogelt. Also wollte ich das nur hinzufügen:

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

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

Answer 3

Ich würde lesen in eine ByteArrayOutputStream und rufen Sie dann toByteArray () das resultierende Byte-Array zu erhalten. Sie brauchen nicht die Größe im Voraus zu definieren (obwohl es möglicherweise eine Optimierung , wenn Sie wissen, dass es . In vielen Fällen werden Sie nicht)

Answer 4

Sie können nicht die Menge der Daten in einem Strom bestimmen, ohne sie zu lesen; Sie können aber fragen Sie nach der Größe einer Datei:

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

Wenn das nicht möglich ist, können Sie das Bytes, die Sie aus dem Eingangsstrom lesen, schreiben auf ein ByteArrayOutputStream die je nach Bedarf wachsen wird.

Answer 5

Sie die Größe des Input bekommen kann mit getBytes (input) von Utils.java überprüfen Sie diese folgenden Link

Get Bytes von INPUTSTREAM-

Answer 6

Für Input

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

Für Optional

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

Answer 7

Wenn explizit mit einem ByteArrayInputStream dann im Gegensatz zu einigen der Kommentare auf dieser Seite tun haben Sie die .available() Funktion können Sie die Größe erhalten. muß es nur tun, bevor Sie von ihm zu lesen beginnen.

Von dem JavaDocs:

  

Gibt die Anzahl der verbleibenden Bytes, die gelesen werden können (oder übersprungen   over) von diesem Eingabestrom. Der zurückgegebene Wert ist zählen - pos, die   die Anzahl der Bytes wird verbleibenden aus dem Eingangspuffer gelesen werden.

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

Answer 8

Wenn Sie wissen, dass Ihr InputStream ein FileInputStream oder ein ByteArrayInputStream, können Sie ein wenig Reflexion verwenden, um den Strom Größe zu erhalten ohne den gesamten Inhalt lesen . Hier ist ein Beispiel-Methode:

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

Dies könnte erweitert werden, zusätzliche Eingangsströme zu unterstützen, bin ich sicher.

Answer 9

Mit dieser Methode können Sie nur die Inputgeben haben

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 vorhanden () Gibt eine Schätzung der Anzahl der Bytes, die gelesen werden können (oder übersprungen) von diesem Eingabestrom ohne durch den nächsten Aufruf einer Methode für diesen Eingangsstrom zu blockieren. Der nächste Aufruf könnte derselbe Faden oder ein anderer Thread sein. Ein einzelner lesen oder überspringen dieser vielen Bytes werden nicht blockieren, aber weniger Bytes gelesen oder überspringen.

Input - Android SDK | Android Developers