Scanner contre BufferedReader

Dans la dernière version/construction JDK6 (b27), le Scanner a un tampon plus petit (1024 caractères ) par opposition au BufferedReader (8192 caractères ), mais c'est plus que suffisant.

, Comme pour le choix, l'utilisation de la Scanner si vous voulez analyser le fichier, utilisez le BufferedReader si vous voulez read le fichier ligne par ligne. Voir également le texte d'introduction de leurs documentations API susmentionnées.

• Analyse = interprétation de la entrée donnée sous forme de jetons (pièces). Il est capable de vous redonner des parties spécifiques directement comme int, string, decimal, etc. Voir aussi toutes ces méthodes nextXxx() dans la classe Scanner.
• Lecture = streaming muet. Il continue de vous redonner tous les personnages, que vous devez à votre tour inspecter manuellement si vous souhaitez faire correspondre ou composer quelque chose d'utile. Mais si vous n'avez pas besoin de le faire de toute façon, alors la lecture est suffisante.

Voir ce lien, ce qui suit est cité à partir de là:

Un BufferedReader est une classe simple destinée à lire efficacement à partir du sous-fifre de flux. Généralement, chaque demande de lecture faite d'un Lecteur comme un FileReader provoque une demande de lecture correspondante à flux sous-jacent. Chaque appel de read() ou readLine () pourrait faire lire des octets à partir du fichier, les convertir en caractères, et puis retourné, ce qui peut être très inefficace. L'efficacité est améliorer sensiblement si un Lecteur est déformé dans un BufferedReader.

BufferedReader est synchronisé, donc lire les opérations sur un BufferedReader peut être fait en toute sécurité à partir de plusieurs threads.

Un scanner d'autre part a beaucoup plus de fromage intégré dedans; il peut faire tout ce qu'un BufferedReader peut faire et au même niveau de l'efficacité ainsi. Cependant, en outre, un scanner peut analyser le flux sous-jacent pour les types primitifs et les chaînes utilisant regular expression. Il peut aussi marquer le flux sous-jacent avec le caractère de votre choix. Il peut également faire le balayage en avant du flux sous-jacent sans tenir compte du délimiteur!

Un scanner n'est cependant pas thread safe, il doit être externe synchronis.

Le choix d'utiliser un BufferedReader ou un Scanner dépend du code vous écrivez, si vous écrivez un simple lecteur de journal mis en mémoire tampon lecteur adéquat. Cependant si vous écrivez un analyseur XML Scanner est le plus de choix naturel.

Même en lisant l'entrée, si vous voulez accepter la ligne d'entrée utilisateur par ligne et dire juste l'ajouter à un fichier, un BufferedReader est assez bon. D'autre part si vous souhaitez accepter l'entrée utilisateur en tant que commande avec plusieurs options, puis l'intention d'effectuer différentes opérations en fonction de la commande et des options spécifiées, un scanner conviendra mieux.

1. BufferedReader a une mémoire tampon beaucoup plus grande que le scanner. Utiliser BufferedReader si vous souhaitez obtenir de longues chaînes à partir d'un flux, et d'utiliser Scanner si vous souhaitez analyser spécifiques type de jeton à partir d'un flux.

2. Scanner peut utiliser tokenize en utilisant un délimiteur personnalisé et analyser le flux en types primitifs de données, tandis que BufferedReader ne peut lire et stocker que des chaînes.

3. BufferedReader est synchrone alors que Scanner ne l'est pas. Utilisez BufferedReader si vous travaillez avec plusieurs threads.

4. Scanner masque IOException tandis que BufferedReader le lance immédiatement.

Je suggère d'utiliser BufferedReader pour lire du texte. Scanner cache IOException tandis que BufferedReader le lance immédiatement.

• BufferedReader est synchrone alors que Scanner ne l'est pas.
• BufferedReader devrait être utilisé si nous travaillons avec plusieurs threads.
• BufferedReader a une mémoire tampon nettement plus grande que Scanner.
• Le Scanner a un petit tampon (tampon de char de 1 Ko) par opposition au BufferedReader (tampon d'octet de 8 Ko), mais c'est plus que suffisant.
• BufferedReader est un peu plus rapide que Scanner car Scanner est-ce que l'analyse des données d'entrée et BufferedReader lit simplement la séquence de caractère.

========================================================================

La classe Scannerest le complément de la classe Formater (utilisée pour convertir des données binaires en texte formaté). Scanner lit l'entrée formatée et la convertit dans sa forme binaire. Bien qu'il ait toujours été possible de lire des entrées formatées, cela a nécessité plus d'efforts que la plupart des programmeurs ne le préféreraient. Grâce à l'ajout du scanner, il est maintenant facile de lire tous les types de valeurs numériques, de chaînes et d'autres types de données, qu'elles proviennent d'un fichier disque, du clavier ou une autre source. Scanner peut être utilisé pour lire l'entrée de la console, un fichier, une chaîne ou toute autre source qui implémente l'interface lisible ou ReadableByteChannel. Par exemple, vous pouvez utiliser Scanner pour lire un nombre à partir du clavier et affecter sa valeur à une variable.

BufferedReader , d'autre part, est une classe d'E/S de flux de caractères. Les flux de caractères fournissent un moyen pratique pour l'entrée et la sortie en termes de caractères (Unicode). BufferedReader est principalement utilisé pour prise d'entrée de la console, System.in. Il prend un objet InputStreamReader comme argument.

Les Principales Différences:

1. Scanner

• Un scanner de texte simple qui peut analyser les types primitifs et les chaînes en utilisant des expressions régulières.
• Un scanner décompose son entrée en jetons à l'aide d'un modèle de délimiteur, qui correspond par défaut aux espaces. Les jetons résultants peuvent ensuite être convertis en valeurs de différents types en utilisant les différentes méthodes suivantes.

Exemple

 String input = "1 fish 2 fish red fish blue fish";
 Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
 System.out.println(s.nextInt());
 System.out.println(s.nextInt());
 System.out.println(s.next());
 System.out.println(s.next());
 s.close(); 

Affiche ce qui suit sortie:

 1
 2
 red
 blue 

La même sortie peut être générée avec ce code, qui utilise une expression régulière pour analyser les quatre jetons à la fois:

 String input = "1 fish 2 fish red fish blue fish";

 Scanner s = new Scanner(input);
 s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
 MatchResult result = s.match();
 for (int i=1; i<=result.groupCount(); i++)
     System.out.println(result.group(i));
 s.close(); `

1. BufferedReader:

   • Lit le texte à partir d'un flux d'entrée de caractères, mettant en mémoire tampon les caractères de manière à permettre une lecture efficace des caractères, des tableaux et des lignes.

   • La taille du tampon peut être spécifiée ou la taille par défaut peut être utilisée. La valeur par défaut est assez grande pour la plupart but.

En général, chaque demande de lecture faite par un lecteur entraîne une demande de lecture correspondante du flux de caractères ou d'octets sous-jacent. Il est donc conseillé d'envelopper un BufferedReader autour de tout Lecteur dont les opérations read() peuvent être coûteuses, telles que FileReaders et InputStreamReaders. Par exemple,

BufferedReader in
   = new BufferedReader(new FileReader("foo.in"));

Mettra en mémoire tampon l'entrée du fichier spécifié. Sans mise en mémoire tampon, chaque invocation de read () ou readLine () peut entraîner lire à partir du fichier, converti en caractères, puis renvoyé, ce qui peut être très inefficace. Les programmes qui utilisent DataInputStreams pour l'entrée textuelle peuvent être localisés en remplaçant chaque DataInputStream par un BufferedReader approprié.

Source:Lien

Voici les différences entre BufferedReader et Scanner

1. BufferedReader ne lit que les données, mais le scanner analyse également les données.
2. vous ne pouvez lire que la chaîne en utilisant BufferedReader, mais vous pouvez lire int, long ou flottant en utilisant le scanner.
3. BufferedReader est plus ancien de Scanner, il existe à partir de jdk 1.1 tandis que Scanner a été ajouté sur la version JDK 5.
4. La taille du tampon de BufferedReader est grande (8 Ko) par rapport à 1 Ko de scanner.
5. BufferedReader est plus approprié pour lire un fichier avec une chaîne longue tandis que le scanner est plus approprié pour lire la petite entrée d'utilisateur de l'invite de commande.
6. BufferedReader est synchronisé mais Scanner ne l'est pas, ce qui signifie que vous impossible de partager le scanner entre plusieurs threads.
7. BufferedReader est plus rapide que Scanner car il ne passe pas de temps sur l'analyse
8. BufferedReader est un peu plus rapide que Scanner
9. BufferedReader est de java.io le paquet et le scanner proviennent de java.package util sur la base de la points nous pouvons sélectionner notre choix.

Merci

Différence entre BufferedReader et Scanner sont les suivantes:

1. BufferedReader est synchronisé, mais le Scanner est pas synchronisés.
2. BufferedReader est thread-safe, mais le Scanner est pas thread-safe.
3. BufferedReader a plus grande mémoire tampon, mais Scanner a plus petite mémoire tampon.
4. BufferedReader est rapidement, mais le Scanner est plus lente en exécution .

5. Code pour lire une ligne de la console:

   BufferedReader:

    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br= new BufferedReader(isr);
    String st= br.readLine();
   

   Scanner:

   Scanner sc= new Scanner(System.in);
   String st= sc.nextLine();
   

Il existe différentes façons de prendre des entrées en java comme:

1) BufferedReader 2) Scanner 3) Arguments de ligne de commande

BufferedReader Lit le texte à partir d'un flux d'entrée de caractères, mettant en mémoire tampon les caractères de manière à permettre une lecture efficace des caractères, des tableaux et des lignes.

Où Scanner est un scanner de texte simple qui peut analyser les types primitifs et les chaînes en utilisant des expressions régulières.

Si vous écrivez un lecteur de journal simple, le lecteur en mémoire tampon est adéquat. si vous écrivez un analyseur XML Scanner est le choix le plus naturel.

Pour plus d'informations, veuillez consulter:

Http://java.meritcampus.com/t/240/Bufferedreader?tc=mm69

La réponse ci-dessous est tirée de Lecture de la console: JAVA Scanner vs BufferedReader

Lors de la lecture d'une entrée de la console, il existe deux options pour y parvenir. D'abord en utilisant Scanner, un autre en utilisant BufferedReader. Deux d'entre eux ont des caractéristiques différentes. Cela signifie différences comment l'utiliser.

Le scanner a traité l'entrée donnée comme un jeton. BufferedReader lit simplement ligne par ligne donnée en entrée sous forme de chaîne. Scanner il fournit lui même des capacités d'analyse tout comme nextInt(), nextFloat().

Mais, quelles sont les autres différences entre?

• Le scanner a traité l'entrée donnée comme un jeton. BufferedReader comme ligne de flux / chaîne
• Scanner tokenisé en entrée donnée en utilisant regex. L'utilisation de BufferedReader doit écrire du code supplémentaire
• BufferedReader plus rapide que Scanner * point no. 2
• Scanner n'est pas synchronisé, BufferedReader synchronisé

Scanner livré avec depuis la version JDK 1.5 supérieure.

Quand devrait utiliser Scanner, ou Lecteur tamponné?

Regardez les principales différences entre les deux, l'une utilisant tokenized, l'autre utilisant stream line. Lorsque vous avez besoin de fonctionnalités d'analyse, utilisez plutôt Scanner. Mais, je suis plus à l'aise avec BufferedReader. Lorsque vous devez lire à partir d'un fichier, utilisez BufferedReader, car il utilise buffer lors de la lecture d'un fichier. Ou vous pouvez utiliser BufferedReader comme entrée au scanner.

Liste peu...

java.util.Scanner class est un scanner de texte simple qui peut analyser les types primitifs et les chaînes. Il utilise en interne des expressions régulières pour lire différents types.

Java.io.BufferedReader la classe lit le texte à partir d'un flux d'entrée de caractères, mettant en mémoire tampon les caractères de manière à permettre une lecture efficace de la séquence de caractères

1) BufferedReader est synchrone alors que Scanner ne l'est pas. BufferedReader doit être utilisé si nous travaillons avec plusieurs threads.

2)BufferedReader a mémoire tampon significativement plus grande que Scanner. Le Scanner a un petit tampon (tampon de caractères de 1 Ko) par opposition au BufferedReader (tampon d'octets de 8 Ko), mais c'est plus que suffisant.

3)BufferedReader est un peu plus rapide par rapport à Scanner parce que Scanner analyse les données d'entrée et BufferedReader lit simplement la séquence de caractères.

1. BufferedReader vous donnera probablement de meilleures performances (car le scanner est basé sur InputStreamReader, regardez les sources). ups, pour la lecture à partir de fichiers, il utilise nio. Lorsque j'ai testé les performances de nio par rapport aux performances de BufferedReader pour les gros fichiers, nio montre des performances un peu meilleures.
2. Pour lire à partir du fichier, essayez Apache Commons IO.

Je préfère Scanner car il ne lève pas d'exceptions vérifiées et donc son utilisation entraîne un code plus simplifié.