Déterminer la taille d'un InputStream

Ma situation actuelle: je dois lire un fichier et mettre le contenu dans InputStream. Par la suite j'ai besoin de placer le contenu de la InputStream dans un tableau d'octets qui nécessite (autant que je sache) de la taille de la InputStream. Des idées?

Comme demandé, je vais vous montrer le flux d'entrée que je suis entrain de créer à partir d'un fichier téléchargé

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 demande est une HttpServletRequest objet, qui est comme le FileItemFactory et ServletFileUpload est de l'Apache Commons FileUpload paquet.

InformationsquelleAutor ChronoXIII | 2009-07-13

12

Je voulais juste ajouter, Apache Commons IO a en charge des flux utilitaires pour effectuer la copie. (Btw, que voulez-vous dire en plaçant le fichier dans un inputstream? Pouvez-vous nous montrer ton code?)

Edit:

Bon, que voulez-vous faire avec le contenu de l'article?
Il y a un item.get() qui renvoie la chose entière dans un tableau d'octets.

Edit2

item.getSize() sera de retour le téléchargement de la la taille du fichier.
- Je suis actuellement enregistrez le fichier dans un champ blob dans la base de données et j'ai envoyer un binarystream (entrée comme un inputstream), maintenant j'ai besoin de l'inputstream dans un tableau d'octets depuis que j'ai besoin de faire une signature de données et la fonction ne prend que des tableaux d'octets.
- de l'élément.get() filets de vous le tableau d'octets, comme je l'ai mentionné. Et ne vous inquiétez pas au sujet de la performance d'une taille, sauf si vous travaillez avec plusieurs MO d'images.
- Ce peut être le cas, car l'image est téléchargé par un utilisateur, et je n'arrive pas à trouver un moyen d'auto rogner les images sur le serveur. 🙁
- Qu'entendez-vous par auto trim images? get() vous donnera l'intégralité du fichier téléchargé(image) as byte[]. Alors vous aller de l'avant et utiliser sur n'importe quel OutputStream.write(), l'envelopper de ByteArrayInputStream de nouveau, etc.
- J'ai changé la solution à ce poste depuis sa réponse a été plus affiné pour mon installation actuelle
InformationsquelleAutor akarnokd
39

C'est VRAIMENT un vieux thread, mais c'était toujours la première chose à pop-up quand j'ai googlé la question. Donc, je voulais juste ajouter ceci:
```
InputStream inputStream = conn.getInputStream();
int length = inputStream.available();
```
A fonctionné pour moi. Et BEAUCOUP plus simple que les autres réponses ici.
- Je ne pense pas que c'est exact. À partir de la documentation Javadoc: "Notez que tandis que certaines implémentations de InputStream sera de retour le nombre total d'octets dans le flux, beaucoup ne le seront pas. Il n'est jamais correct d'utiliser la valeur de retour de cette méthode pour allouer un tampon destiné à conserver toutes les données de ce flux." Donc il peut avoir travaillé sur votre VM, mais ne fonctionne pas sur quelqu'un d'autre. docs.oracle.com/javase/7/docs/api/java/io/...
- Oh psy. Belle prise! Je suppose que ce truc n'est pas bon pour le code qui doit être portable. Je l'utilise pour un projet d'école, il a travaillé pour moi. Merci bien, bon à savoir pour le futur!
- C'est parfait lorsque vous avez toutes les données dans la mémoire comme dans un ByteArrayInputStream.
- C'est FAUX! Comme le documentation, a déclaré à propos de la available() de "méthode de Noter que, tandis que certaines implémentations de InputStream sera de retour le nombre total d'octets dans le flux, beaucoup ne le seront pas. Il n'est jamais correct d'utiliser la valeur de retour de cette méthode pour allouer un tampon destiné à conserver toutes les données de ce flux."
- est.disponible retourne 0 si eof est atteint, sinon elle renvoie toujours 1
- La réponse est trompeuse, Qu'en Android docs, il est clairement indiqué: "Notez que cette méthode fournit une faible garantie il n'est pas très utile dans la pratique".
- À partir de la documentation: "vous ne devez pas utiliser cette méthode pour la taille d'un conteneur et d'assumer ce que vous pouvez lire l'intégralité des flux sans avoir besoin de redimensionner le conteneur"
InformationsquelleAutor W. B. Reed
34

Je lis dans un ByteArrayOutputStream et ensuite appeler toByteArray() pour obtenir la résultante tableau d'octets. Vous n'avez pas besoin de définir la taille à l'avance (même si c'est peut-être une optimisation si vous savez qu'il. Dans de nombreux cas, vous n'aurez pas)
- Il me semble avoir constaté que inputstream ont une méthode toString() et puis je peux juste appeler un getBytes() pour créer un tableau d'octets hors de la chaîne. Je me demandais si il y a des problèmes de performances de faire cela?
- Vous devez être prudent avec les octets/conversions de caractères. Est-ce à l'origine d'un flux d'octets ? Si elle contient des caractères, comment sont-ils codés etc. Si vous êtes arriver à ces via une connexion réseau, je pense que c'est votre principal goulot d'étranglement des performances et je ne vous inquiétez pas au sujet de la conversion de frais généraux
- Je suis actuellement lire la inputstream avec l'image dans une base de données comme un binarystream, ce qui semble très bien fonctionner comme je peux lire le fichier de retour postfaces et de son encore une image
- Qui sonne bien!
- Merci pour votre aide tout le monde, à moins qu'il n'y a aucune raison de ne pas aller avec un de convertir des flux à l'aide de la chaîne .toString() et ensuite pour le tableau d'octets à l'aide .getBytes(), je vais continuer avec cette solution.
- Je wopuld ont pensé que c'est plus facile à lire en boucle à partir de votre inputstream pour le tableau d'octets du flux de sortie, puis obtenir le tableau d'octets, évitant ainsi de char d'encodages. Mais si vous êtes heureux que toString() fonctionne...
- Oui, il est. Chaîne de caractères.getBytes() aura des problèmes de conversion.
- Ok donc si la Chaîne.getBytes a vraiment une conversion de type de question sera les modifications suivantes au code du travail (indiqué dans le post initial avec //CHANGER)
- Oui. Vous obtenez le plein brutes tableau d'octets, pas de conversion, pas de problèmes.
- Ok merci
- N'est-ce pas vraiment la mémoire inefficace si tout ce que vous voulez, c'est la taille?
InformationsquelleAutor Brian Agnew
17

Vous ne pouvez pas déterminer la quantité de données dans un flux sans le lire; vous pouvez, cependant, de demander la taille d'un fichier:

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

Si ce n'est pas possible, vous pouvez écrire les octets lus à partir du flux d'entrée pour un ByteArrayOutputStream qui va grandir en tant que de besoin.
- Dans mon scénario, l'inputstream contient un fichier téléchargé à partir d'un formulaire HTML, je ne peux pas obtenir la taille du fichier puisque je ne suis pas à charger le fichier sur le disque dur.
- Si votre flux d'entrée est cochée() de support, vous pouvez marquer au début et il suffit de lire à travers elle tout à fait, puis reset() et de commencer à les traiter.
- le fichier est une image (potentiellement important) donc, la lecture dans le courant deux fois serait causer des problèmes de performance ne serait-il pas?
- Essayez-la. Si c'est très lent, vous avez des problèmes de performances. Autrement, vous ne pouvez pas. C'est aussi simple que cela.
- Vrai. C'est pourquoi j'ai demandé un petit exemple de code pour que nous puissions voir votre scénario. Si votre image est déjà en mémoire (grâce à fileupload ou quelque chose), puis il s'ouvre à d'autres options.
InformationsquelleAutor Andrew Duffy
4

vous pouvez obtenir la taille de InputStream à l'aide de getBytes(inputStream) de Utils.java vérifier le lien suivant

Obtenir des Octets de Inputstream
- Ne devrait-il pas être une réponse correcte? Aucun problème avec cette solution?
- Si vous prévoyez d'utiliser votre flux d'entrée, il aura déjà été lu.
InformationsquelleAutor Gnanam R
4

Pour InputStream
```
IoUtils.toByteArray(inputStream).length
```
Pour Option < MultipartFile >
```
Stream.of(multipartFile.get()).mapToLong(file->file.getSize()).findFirst().getAsLong()
```
- Je ne trouve pas IoUtils n'importe où. Je suppose que tu veux dire org.apache.commons.io.IOUtils,
InformationsquelleAutor amstegraf
0

Quand explicitement traiter avec un ByteArrayInputStream puis contrairement à certains commentaires sur cette page, vous pouvez utiliser le .available() fonction pour obtenir la taille. Suffit de le faire avant de commencer la lecture à partir d'elle.

De la Javadoc:

Renvoie le nombre d'octets qui peut être lu (ou sauté
plus) à partir de ce flux d'entrée. La valeur retournée est le comte de point de vente, qui
est le nombre d'octets restant à être lu à partir de la mémoire tampon d'entrée.

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

InformationsquelleAutor Sverrir Sigmundarson

Si vous savez que votre InputStream est un FileInputStream ou un ByteArrayInputStream, vous pouvez utiliser un peu de réflexion pour obtenir le flux de la taille sans lire tout le contenu. Voici un exemple de méthode:

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

Cela pourrait être étendu pour prendre en charge d'autres flux d'entrée, j'en suis sûr.

InformationsquelleAutor Travis Parks

-1

Utiliser cette méthode, vous avez juste à passer le 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: ";
}
```
- -1, ce qui suppose le InputStream est toujours une Chaîne de caractères (pas nécessaire car il peut être binaire de données), et en tout cas il n'a pas de retour de la taille du cours d'eau qui est ce que la question posée. En outre, il ajoute des octets (\n) pour les données sb.length() sera également inexacte.
- Ok, je comprends, donc c'est utile lorsque vous savez que vous vous attendez à recevoir un String flux. \n est vraiment nécessaire, parce que vous avez à donner un format aux commentaires reçus, je ne veux pas de chorizo long String, de sorte que même ceux \ncompte.
InformationsquelleAutor Carlos.V
-1
```
    try {
        InputStream connInputStream = connection.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    int size = connInputStream.available();
```
int disponible ()
Renvoie une estimation du nombre d'octets qui peut être lu (ou ignorée) à partir de ce flux d'entrée sans blocage par la prochaine invocation d'une méthode de ce flux d'entrée. La prochaine invocation peut-être le même thread ou un autre thread. Une seule lecture ou de sauter de ce nombre d'octets ne va pas bloquer, mais peut lire ou passer moins d'octets.

InputStream - SDK Android | Développeurs Android

InformationsquelleAutor Ashnet

Vous devez vous connecter pour publier un commentaire.