1. Classe BufferedReader
. Bibliothèque de classe:
java.lang.object
Java.io.reader
Java.io.BufferedReader
. Concepts de base:
La classe publique BufferedReader étend le lecteur
Lisez le texte du flux d'entrée de caractères et tamponnez des caractères individuels, permettant ainsi une lecture efficace des caractères, des tableaux et des lignes. Vous pouvez spécifier la taille du tampon, ou la taille par défaut peut être utilisée. Dans la plupart des cas, la valeur par défaut est suffisamment grande.
En règle générale, chaque demande de lecture faite par un lecteur se traduit par une demande de lecture correspondante pour le caractère sous-jacent ou le flux d'octet. Par conséquent, il est recommandé d'envelopper tous les lecteurs dont les opérations Read () peuvent être coûteuses (comme FileReader et InputStreamReader) avec BufferedReader.
Le flux BufferedReader est capable de lire les lignes de texte et crée un objet BufferedReader en passant un objet de lecteur au BufferedReader. En effet, FileReader ne fournit pas la fonction de lire les lignes de texte.
. Démo:
Capturez l'instruction entrée via leader BufferedReader:
import java.io. *; class bufferedReaderDemo {public static void main (string [] args) lève ioException {buffereDaDer buffereDReader = new BufferedReader (new InputStreamReader (System.in)); System.out.print ("Veuillez entrer une série de texte, qui peut inclure des espaces:"); String text = BufferedReader.Readline (); System.out.println ("Veuillez saisir le texte:" + texte); }}annotation:
lance iOException lance une exception
InputStreamReader est le pont entre l'écoulement des octets et le flux de caractères
2. Classe InputStreamReader
InputStreamReader convertit un flux d'octet en flux de caractères. C'est le pont entre l'écoulement des octets et l'écoulement des caractères. Si l'encodage des jeux de caractères n'est pas spécifié, le processus de décodage utilisera le codage de caractères par défaut de la plate-forme, tel que: GBK.
Méthode de construction:
InputStreamReader ISR = new inputStreamReader (inputStream in); // Construire une classe InputStreamReader avec l'ensemble de codage par défaut
InputStreamReader ISR = new inputStreamReader (inputStream in, String CharSetName); // construire un ensemble de codage spécifié
Classe InputStreamReader.
Le paramètre dans l'objet est obtenu par InputStream dans = System.in;. // Lire les données sur le clavier.
Ou InputStream dans = new FileInputStream (String FileName); // Lisez les données dans le fichier. On peut voir que FileInputStream est une sous-classe de InputStream.
Méthode principale: int read (); // lire un seul caractère.
int lic (char [] cbuf); // Enregistrez les caractères de lecture dans le tableau. Renvoie le nombre de caractères lus.
. Démo:
Importer java.io. *; class inputStreamReaderDemo {public static void transreadnobuf () lève ioException {/ ** * Il n'y a pas de tampon, vous ne pouvez qu'utiliser la méthode read (). * / // Lire Byte Stream // InputStream dans = System.in; // Lire l'entrée du clavier. InputStream dans = new FileInputStream ("D: //demo.txt"); // Lisez les données du fichier. // Conversion des octets fluide en flux de caractères. Pour permettre une conversion efficace des octets en caractères, // vous pouvez lire plus d'octets du flux sous-jacent à l'avance. InputStreamReader ISR = new inputStreamReader (in); // read // Comprehensive en une phrase. // inputStreamReader isr = new inputStreamReader (// new FileInputStream ("d: //demo.txt")); char [] cha = nouveau char [1024]; int len = isr.read (cha); System.out.println (nouvelle chaîne (Cha, 0, Len)); isr.close (); } public static void transreadbybuf () lève ioException {/ ** * utiliser des tampons pour utiliser les méthodes read () et readLine () de l'objet tampon. * / // Lire Byte Stream // InputStream dans = System.in; // Lire les données sur le clavier InputStream dans = new FileInputStream ("D: //demo.txt"); // Lisez les données sur le fichier. // Conversion des octets fluide en flux de caractères. InputStreamReader ISR = new inputStreamReader (in); // read // créer du tampon de caractéristique bufferedReader bufr = new BuffereDaDer (ISR); // tampon // buffereDaDer bufr = new buttereDaDer (// new InputStreamReader (new FileInputStream ("d: //demo.txt")); peut être combiné en une phrase. / * int ch = 0; ch = bufr.read (); System.out.println ((char) ch); * / Chaîne de chaîne; while ((line = bufr.readline ())! = null) {System.out.println (line); } isr.close (); }}3. Cas réels de leader InputStreamReader et BufferedReader (ensemble non codé)
import java.io. *; class utilResource {private void initialisereSource () {try {// lire le fichier et l'écrire dans le formulaire utf-8 buttereDreder bufread; Chaîne lecture; bufread = new BufferedReader (new InputStreamReader (ResourceHelper .getResourceInputStream ("pinyin.txt"))); while ((read = bufread.readline ())! = null) {System.out.println (read); } bufread.close (); } catch (filenotFoundException ex) {ex.printStackTrace (); } catch (ioException ex) {ex.printStackTrace (); }}}Remarque: pinyin.txt est placé dans le répertoire racine du projet
Importer Java.io.BufferedInputStream; Importer Java.io.fileInputStream; Importer Java.io.FilenotFoundException; Class ResourceHelper {/ ** * @param ResourceName * @return * @return * / static BufferedInputStream GetResourceInputStream (String ResourceName) {Try {Retour New BufferdinIn FileInputStream (ResourceName)); } catch (filenotfoundException e) {// TODO Block de capture généré automatiquement e.printStackTrace (); } return null; }}Résumer:
Classe InputStreamReader
Il s'agit du pont entre l'écoulement des octets et l'écoulement des caractères, en entourant le rythme entrée à l'intérieur. Il lit les caractères un à un à la fois dans un niveau supérieur, les entrées / sorties au format texte et peut spécifier le format de codage;
Classe BufferedReader
BufferedReader est étendu par la classe de lecture, fournissant une lecture générale de texte tamponnée et fournit une ligne de lecture très pratique, qui lit une ligne de texte, lit le texte à partir d'un flux d'entrée de caractère, et tamponne chaque caractère, fournissant ainsi une lecture efficace des caractères, des tableaux et des lignes.
PS: la relation entre InputStream, InputStreamReader et Reader
InputStream: le résultat est le flux d'entrée d'octet. Après InputStream.Read ("FileName"), le résultat est le flux d'octet.
Lecteur: lire un flux de personnage
InputStreamReader: un pont des octets aux caractères. InputStreamReader (inputStream.read ("FileName"));
Reader.read (InputStreamReader (InputStream in)); peut être changé de l'octet en caractère, et imprimé et affiché.
java.io.reader et java.io.inputStream Formez la classe d'entrée Java.
Le lecteur est utilisé pour lire des caractères 16 bits, c'est-à-dire des caractères codés par Unicode; tandis que InputStream est utilisé pour lire les caractères ASCII et les données binaires.
Lecteur prend en charge la sortie de caractères Unicode 16 bits et InputStream prend en charge la sortie de caractères 8 bits.
Le lecteur et l'entrée sont deux ensembles de mécanismes de niveau parallèle et indépendants fournis par la bibliothèque d'E / S, respectivement. 1Byte = 8Bits InputStream et OutputStream sont utilisés pour traiter les flux 8 bits, et le lecteur et l'écrivain sont utilisés pour traiter les flux 16 bits.
Dans la langue Java, le type d'octet est 8 bits et le type de char est 16 bits, vous devez donc utiliser le lecteur et l'écrivain lors du traitement chinois.
Il convient de noter qu'en vertu de ces deux niveaux de mécanismes, il existe également un pont InputStreamReader et OutputStreamWriter, qui est responsable de l'adaptation de InputStream à Reader et de l'adaptation de OutputStream à l'écrivain.
En Java, il existe différents types de flux d'entrée de lecture qui correspondent à différentes sources de données:
FileReader est utilisé pour saisir un fichier; CharArayReader est utilisé pour saisir un tableau de caractères dans le programme; StringReader est utilisé pour saisir une chaîne du programme; PipeDreader est utilisé pour lire les données écrites dans le pipeline à partir d'un PipedWriter dans un autre thread.
Il existe également différents types de flux d'entrée InputStream correspondant à différentes sources de données: FileInputStream, ByteArrayInputStream, StringBufferInputStream, PipedInputStream.
De plus, il existe deux flux d'entrée InputStream qui n'ont pas de type de lecture correspondant: la prise est utilisée pour les prises; L'URLConnection est utilisée pour les connexions URL. Ces deux classes utilisent getInputStream () pour lire les données.
De même, il existe des différences similaires entre java.io.writer et java.io.outputStream.
En ce qui concerne InputStream.Read (byte [] b) et inputStream.read (byte [] b, int off, int len) Les deux méthodes sont utilisées pour lire plusieurs octets à partir d'un flux. Les programmeurs expérimentés constateront que ces deux méthodes ne peuvent souvent pas lire le nombre d'octets qu'ils souhaitent lire. Par exemple, dans la première méthode, les programmeurs espèrent souvent que le programme peut lire les octets B.Length, mais la situation réelle est que le système ne peut souvent pas en lire autant. Après avoir soigneusement lu les instructions de l'API Java, vous constaterez que cette méthode ne garantit pas qu'elle peut lire autant d'octets, il peut seulement garantir qu'il peut lire autant d'octets (au moins 1). Par conséquent, si vous voulez que le programme lise les octets de comptage, il est préférable d'utiliser le code suivant:
octet [] b = nouveau octet [count]; int ReadCount = 0; // le nombre d'octets qui ont été lus avec succès while (ReadCount <count) {ReadCount + = in.Read (Bytes, ReadCount, Count - ReadCount); } Ce code peut garantir que les octets de comptage sont lus à moins qu'une exception IO ne soit rencontrée au milieu ou à la fin du flux de données (EofException)