Scanner vs BufferedReader

Pour autant que je sache, les deux méthodes les plus courantes pour lire des données basées sur des caractères à partir d’un fichier en Java utilisent Scanner ou BufferedReader . Je sais également que BufferedReader lit les fichiers efficacement en utilisant un tampon pour éviter les opérations de disque physique. Mes questions sont:

  • Scanner fonctionne-t-il aussi bien que BufferedReader ?
  • Pourquoi choisir Scanner over BufferedReader ou vice versa?

Scanner est utilisé pour parsingr les jetons à partir du contenu du stream alors que BufferedReader lit simplement le stream et ne procède à aucune parsing particulière.

En fait, vous pouvez passer un BufferedReader à un scanner tant que source de caractères à parsingr.

Dans la dernière version de JDK6 (b27), le Scanner a un tampon plus petit ( 1024 caractères ) que le BufferedReader ( 8192 caractères ), mais c’est plus que suffisant.

En ce qui concerne le choix, utilisez le Scanner si vous souhaitez parsingr le fichier, utilisez le BufferedReader si vous souhaitez lire le fichier ligne par ligne. Voir également le texte d’introduction de leurs documentations d’API susmentionnées.

  • Analyse = interpréter l’entrée donnée sous forme de jetons (parties). Il est capable de vous rendre directement des parties spécifiques telles que int, ssortingng, decimal, etc. Voir aussi toutes les méthodes nextXxx() dans la classe Scanner .
  • Lecture = diffusion muette. Il vous restitue tous les caractères, que vous devez inspecter manuellement si vous souhaitez faire correspondre ou composer quelque chose d’utile. Mais si vous n’avez pas besoin de le faire, la lecture est suffisante.

Voir ce lien , est cité ci-dessous:

Un BufferedReader est une classe simple destinée à lire efficacement le stream sous-jacent. Généralement, chaque demande de lecture faite d’un lecteur comme un lecteur de fichiers entraîne une requête de lecture correspondante sur le stream sous-jacent. Chaque invocation de read () ou readLine () peut entraîner la lecture des octets du fichier, leur conversion en caractères, puis leur retour, ce qui peut être très inefficace. L’efficacité est sensiblement améliorée si un Reader est déformé dans un BufferedReader.

BufferedReader est synchronisé, donc les opérations de lecture sur un BufferedReader peuvent être effectuées en toute sécurité à partir de plusieurs threads.

En revanche, un scanner contient beaucoup plus de fromage. il peut faire tout ce qu’un BufferedReader peut faire et au même niveau d’efficacité. Cependant, un scanner peut en outre parsingr le stream sous-jacent pour les types primitifs et les chaînes utilisant des expressions régulières. Il peut également numériser le stream sous-jacent avec le délimiteur de votre choix. Il peut également effectuer une parsing en aval du stream sous-jacent sans tenir compte du délimiteur!

Un scanner n’est toutefois pas thread-safe, il doit être synchronisé en externe.

Le choix d’utiliser un lecteur BufferedReader ou un scanner dépend du code que vous écrivez, si vous écrivez un lecteur de journal simple. Le lecteur avec tampon est adéquat. Cependant, si vous écrivez un parsingur XML, le scanner est le choix le plus naturel.

Même en lisant l’entrée, si vous voulez accepter une entrée utilisateur ligne par ligne et que vous dites simplement l’append à un fichier, un BufferedReader est suffisant. D’un autre côté, si vous souhaitez accepter une entrée utilisateur en tant que commande avec plusieurs options, puis que vous souhaitez effectuer différentes opérations en fonction de la commande et des options spécifiées, un scanner convient mieux.

  1. BufferedReader dispose d’une mémoire tampon nettement supérieure à celle de Scanner. Utilisez BufferedReader si vous souhaitez obtenir de longues chaînes à partir d’un stream et utilisez Scanner si vous souhaitez parsingr un type de jeton spécifique à partir d’un stream.

  2. Scanner peut utiliser tokenize en utilisant un délimiteur personnalisé et parsingr le stream en types de données primitifs, tandis que BufferedReader peut uniquement lire et stocker la chaîne.

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

  4. Scanner masque IOException alors que BufferedReader lance immédiatement.

Je suggère d’utiliser BufferedReader pour lire du texte. Scanner masque IOException alors que BufferedReader lance immédiatement.

  • BufferedReader est synchrone alors que Scanner ne l’est pas.
  • BufferedReader doit être utilisé si nous travaillons avec plusieurs threads.
  • BufferedReader dispose d’une mémoire tampon nettement supérieure à celle de Scanner .
  • Le Scanner a un petit tampon (1 Ko de tampon de caractères) contrairement au tampon BufferedReader (tampon de 8 Ko), mais c’est plus que suffisant.
  • BufferedReader est un peu plus rapide que Scanner car Scanner parsing les données en entrée et BufferedReader lit simplement la séquence de caractères.

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

La classe Scanner est le complément de la classe Formater (utilisée pour convertir les données binarys en texte formaté). Scanner lit les entrées formatées et les convertit sous sa forme binary. Bien qu’il ait toujours été possible de lire les entrées formatées, cela demandait plus d’efforts que la plupart des programmeurs préféraient. Grâce à l’ajout de Scanner, il est désormais facile de lire tous les types de valeurs numériques, chaînes et autres types de données, qu’ils proviennent d’un fichier disque, du clavier ou d’une autre source. Scanner peut être utilisé pour lire les entrées de la console, d’un fichier, d’une chaîne ou de toute autre source implémentant l’interface Readable ou ReadableByteChannel. Par exemple, vous pouvez utiliser Scanner pour lire un numéro du clavier et atsortingbuer sa valeur à une variable.

BufferedReader , d’autre part, est une classe d’E / S de stream de caractères. Les stream de caractères offrent un moyen pratique d’entrer et de sortir en termes de caractères (Unicode). BufferedReader est principalement utilisé pour saisir des données depuis la console, System.in . Il prend un object InputStreamReader comme argument.

Les principales différences:

  1. Scanner

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

Exemple

  Ssortingng 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(); 

imprime la sortie suivante:

  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 parsingr tous les quatre jetons à la fois:

  Ssortingng 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 d'un stream de saisie de caractères, en mettant en mémoire tampon des caractères pour 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 suffisamment grande pour la plupart des objectives.

En général, chaque demande de lecture effectuée par un lecteur provoque une demande de lecture correspondante du caractère sous-jacent ou du stream d'octets. Il est donc conseillé de placer un lecteur BufferedReader autour de n'importe quel 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 appel de read () ou readLine () pourrait entraîner la lecture des octets du fichier, leur conversion en caractères, puis leur retour, ce qui peut être très inefficace. Les programmes qui utilisent DataInputStreams pour une 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 lit uniquement les données, mais l’parsing parsing également les données.
  2. vous ne pouvez lire que Ssortingng avec BufferedReader, mais vous pouvez lire int, long ou float à l’aide de Scanner.
  3. BufferedReader est plus ancien que Scanner, il existe depuis jdk 1.1 alors que Scanner a été ajouté à la version JDK 5.
  4. La taille de la mémoire tampon de BufferedReader est grande (8 Ko) par rapport à 1 Ko de scanner.
  5. BufferedReader est plus adapté à la lecture de fichiers avec une longue chaîne alors que Scanner est plus adapté à la lecture de petites entrées utilisateur à partir d’une invite de commandes.
  6. BufferedReader est synchronisé, mais pas Scanner, ce qui signifie que vous ne pouvez pas partager Scanner entre plusieurs threads.
  7. BufferedReader est plus rapide que Scanner car il ne passe pas beaucoup de temps à l’parsing
  8. BufferedReader est un peu plus rapide que Scanner
  9. BufferedReader est issu du package java.io et Scanner est issu du package java.util sur la base des points que nous pouvons sélectionner.

Merci

Les différences entre BufferedReader et Scanner sont les suivantes:

  1. BufferedReader est synchronisé mais Scanner n’est pas synchronisé .
  2. BufferedReader est thread-safe mais Scanner n’est pas thread-safe .
  3. BufferedReader a une mémoire tampon plus grande mais Scanner a une mémoire tampon plus petite .
  4. BufferedReader est plus rapide mais Scanner est plus lent dans l’exécution .
  5. Code pour lire une ligne depuis la console:

    BufferedReader :

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

    Scanner :

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

Il existe différentes manières de saisir des données en Java comme:

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

BufferedReader Lit le texte d’un stream de saisie de caractères, en mettant en mémoire tampon des caractères afin de permettre une lecture efficace des caractères, des tableaux et des lignes.

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

si vous écrivez un simple lecteur de journal Le lecteur avec tampon est adéquat. Si vous écrivez un parsingur XML, le scanner est le choix le plus naturel.

Pour plus d’informations s’il vous plaît se référer:

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

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

Lorsque vous lisez une entrée depuis la console, il existe deux options pour y parvenir. En utilisant d’abord Scanner , un autre utilisant BufferedReader . Les deux ont des caractéristiques différentes. Cela signifie des différences sur la façon de l’utiliser.

Scanner traité en entrée comme jeton. BufferedReader lit simplement les entrées ligne par ligne sous forme de chaîne. Scanner elle-même fournit des fonctionnalités d’parsing comme nextInt (), nextFloat ().

Mais, quelles sont les autres différences entre?

  • Scanner traité en entrée comme jeton. BufferedReader comme ligne de stream / chaîne
  • Scanner tokenized entrée donnée en utilisant regex. Utiliser BufferedReader doit écrire du code supplémentaire
  • BufferedReader plus rapide que Scanner * point no. 2
  • Scanner non synchronisé, BufferedReader synchronisé

Le scanner vient avec JDK version 1.5 plus haut.

Quand faut-il utiliser Scanner ou Buffered Reader?

Examinez les principales différences entre les deux, l’une utilisant les jetons, les autres utilisant la ligne de stream. Lorsque vous avez besoin de fonctions d’parsing, utilisez Scanner à la place. Mais, je suis plus à l’aise avec BufferedReader. Lorsque vous devez lire un fichier, utilisez BufferedReader, car il utilise un tampon lors de la lecture d’un fichier. Ou vous pouvez utiliser BufferedReader en entrée de Scanner.

Liste quelques …

java.util.Scanner classe java.util.Scanner est un simple parsingur de texte pouvant parsingr les types et les chaînes de primitives. Il utilise en interne des expressions régulières pour lire différents types.

Java.io.BufferedReader classe Java.io.BufferedReader lit le texte d’un stream de saisie de caractères, en Java.io.BufferedReader mémoire tampon des caractères afin de 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 possède une mémoire tampon beaucoup plus importante que Scanner . Le Scanner a un petit tampon (1 Ko de tampon de caractères) contrairement au tampon BufferedReader (tampon de 8 Ko), mais c’est plus que suffisant.

3) BufferedReader est un peu plus rapide que Scanner car Scanner parsing les données en entrée et BufferedReader lit simplement la séquence de caractères.

  1. BufferedReader vous donnera probablement de meilleures performances (car Scanner est basé sur InputStreamReader, regardez les sources). ups, pour lire des fichiers qu’il utilise nio. Lorsque j’ai testé les performances de nio par rapport aux performances de BufferedReader pour les gros fichiers, nio affiche de meilleures performances.
  2. Pour lire un fichier, essayez Apache Commons IO.

Je préfère Scanner car il ne lance pas les exceptions vérifiées et son utilisation se traduit par un code plus rationnel.