Question

Laissez-moi préface ce post avec une seule mise en garde. Je suis un débutant total quand il s'agit de Java. J'ai été la programmation PHP et pendant un certain temps, mais je suis prêt à faire une application de bureau, alors j'ai décidé d'aller avec Java pour diverses raisons.

L'application je travaille est dans les étapes de début (moins de 5 classes) et je dois lire des octets à partir d'un fichier local. En règle générale, les fichiers sont actuellement moins de 512ko (mais peuvent obtenir plus à l'avenir). À l'heure actuelle, je me sers d'un FileInputStream pour lire le fichier en trois tableaux d'octets, qui satisfait parfaitement à mes besoins. Cependant, je l'ai vu BufferedInputStream mentionné, et je me demandais si la façon dont je suis en train de faire c'est le meilleur, ou si je dois utiliser un BufferedInputStream aussi bien.

J'ai fait quelques recherches et avoir lu quelques questions ici sur Stack Overflow, mais je suis toujours avoir la compréhension des problèmes de la meilleure situation pour le moment d'utiliser et ne pas utiliser la BufferedInputStream. Dans ma situation, le premier tableau que j'ai lu octets en est seulement quelques octets (moins de 20). Si les données que je reçois est bon dans ces octets, alors je lis le reste du fichier en deux tableaux plus d'octets de taille variable.

J'ai aussi entendu beaucoup de gens parler de profilage pour voir qui est plus efficace dans chaque cas spécifique, cependant, j'ai profiler aucune expérience et je ne suis pas vraiment sûr où commencer. J'aimerais quelques suggestions à ce sujet également.

Je suis désolé pour un long post, mais je veux vraiment apprendre et comprendre la meilleure façon de faire ces choses. J'ai toujours une mauvaise habitude de deuxième deviner mes décisions, j'aimerais quelques commentaires. Merci!

Était-ce utile?

La solution

Si vous faites petit lit toujours alors un BufferedInputStream vous donnera des performances nettement meilleures. Chaque requête de lecture sur un flux unbuffered se traduit généralement par un appel système au système d'exploitation de lire le nombre requis d'octets. Les frais généraux de faire un appel système est peut-être des milliers d'instructions de la machine par syscall. Un courant tamponnée réduit cela en faisant une large lecture pour (par exemple) jusqu'à 8K octets dans une mémoire tampon interne, puis distribuer des octets à partir de ce tampon. Ceci peut réduire considérablement le nombre d'appels système.

Cependant, si vous faites toujours un grand lit (par exemple 8k ou plus), puis les choses d'un BufferedInputStream. En général, vous ne réduisez pas le nombre de syscalls, et les introduit tampon une étape supplémentaire des données de la copie.

Dans votre cas d'utilisation (où vous lisez un morceau de 20 octets d'abord, puis beaucoup de gros morceaux), je dirais que l'utilisation d'un BufferedInputStream est plus susceptible de réduire les performances que l'augmenter. Mais en fin de compte, cela dépend des modèles de lecture réelle.

Autres conseils

Si vous utilisez un des tableaux relativement grandes pour lire les données d'un morceau à la fois, alors BufferedInputStream va simplement présenter une copie inutile. (Rappelez-vous, read ne lit pas nécessairement du tableau - vous pouvez DataInputStream.readFully). Où gagne BufferedInputStream est en faisant beaucoup de petites lectures.

BufferedInputStream lit plus du fichier que vous avez besoin à l'avance. Si je comprends bien, qu'il fait plus de travail à l'avance, comme, 1 grand disque lu vs faire Continuous beaucoup dans une boucle serrée.

En ce qui concerne le profilage - Je aime le profileur qui est intégré dans NetBeans. Il est vraiment facile de commencer avec. : -)

Je ne peux pas parler au profilage, mais de mon expérience dans le développement d'applications Java je trouve que l'utilisation de l'une des classes tampons - BufferedInputStream, StringBuffer - mes applications sont plus rapides exceptionnellement. En raison de ce qui, je les utilise même pour les plus petits fichiers ou opération string.

    import java.io.*;
    class BufferedInputStream
    {
            public static void main(String arg[])throws IOException
            {
                FileInputStream fin=new FileInputStream("abc.txt");
                BufferedInputStream bis=new BufferedInputStream(fin);
                int size=bis.available();
                while(true)
                {
                        int x=bis.read(fin);
                        if(x==-1)
                        {
                                bis.mark(size);
                                System.out.println((char)x);
                        }
                }
                        bis.reset();
                        while(true)
                        {
                                int x=bis.read();
                                if(x==-1)
                                {
                                    break;
                                    System.out.println((char)x);
                                }
                        }

            }

    }
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top