Du fait que le flux d'octets ne peut fonctionner bien en lui-même une grande capacité pour les données unitaires (égal à un multiple caractère d'octet), le flux de caractères est nécessaire.
Un procédé utilisant l'entrée de caractères, le flux de sortie
1. Les courants d'entrée:
1). La FileReader (filename String);
2) la FileReader (nom de fichier);
Lisez ensuite le (); méthode.
2. Le flux de sortie:
. 1) FileWriter (filename String);
2) FileWriter (nom de fichier);
. 3) FileWriter (filename String, append Boolean);
. 4) FileWriter (nom de fichier du fichier, append Boolean);
Si l'ajout est vraie, octets sont écrits à la fin du fichier, l'équivalent des informations supplémentaires, écrit au début et vice - versa.
Ensuite, utilisez write (); méthode.
Les exemples sont les suivants:
import java.io.*;
public class Example{
public static void main(String args[]){
File sourceFile = new File("a.txt"); //读取的文件
File targetFile = new File("b.txt"); //写入的文件
char c[] = new char[19]; // char型数组
try{
Writer out = new FileWriter(targetFile,true); //指向目的地的输出
Reader in = new FileReader(sourceFile); //指向源的输入流
int n= -1;
while((n=in.read(c))! = -1){
out.write(c,0,n);
}
out.flush();
out.close();
}
catch(IOException e){
System.out.println("Error "+e);
}
}
}
II. Flux Buffered
flux tampon améliore la capacité de lire et les fichiers d'écriture. BufferedWriter objets BufferedReader et classes connues en tant que tampon pour créer une entrée, un flux de sortie. (Également désigné comme un flux de couche supérieure).
1. Le courant d' entrée de la mémoire tampon
1) constructeur: le BufferedReader (Reader);
2) flux de BufferReader peut être des lignes de lecture, en appelant la readLine ();
3) On peut créer un objet de BufferReader par passage d'un objet à une sous-classe de lecteur BufferedReader, tels que:
Utilisation flux d'entrée en mémoire tampon:
FileReader inOne = new FileReader("Student.txt");
BufferReader inTwo = BufferedReader(inOne);
String strLine = inTwo.readLine();
Le courant de sortie en utilisant un tampon similaire:
FileWriter tofile = new FileWriter("hello.txt");
BufferedWriter out = BufferedWriter(tofile);
Ensuite , peut appeler
écriture (String s, int off,
int len); chaîne écrite de la hello.txt, le paramètre est le décalage de la commencer au s, len est le nombre de caractères écrits. Il peut également être appelé newLine (); méthode de retour écrit un caractère dans le fichier.
III. Stream aléatoire
en Java, nous pouvons mettre en place un cours d' eau, le flux ne peut que lire les fichiers, les fichiers d'écriture aussi. C'est flux aléatoire classe RandomAccessFile créé.
Soit en tant que flux de source ponctuelle d' écoulement classe RandomAccessFile créé, il peut être utilisé comme un flux de destination.
1. Méthode:
1) constructeur:
un RandomAccessFile (String name, String MODE);
Nom du paramètre utilisé pour identifier un nom de fichier est donnée pour créer le courant de source (et destination). paramètres de mode de prise de R & lt (lecture seule) ou RW (lecture-écriture), la décision de créer un droit d'accès aux fichiers de flux.
RandomAccessFile (fichier fichier, String mode)
; ibid.
Note: flux aléatoire dans un fichier, le fichier est rafraîchi.
2. Méthode utilisée:
Fermer (),
fermez le fichier.
le getFilePointer (),
obtenir l'emplacement d'écriture en cours.
; Longueur ()
Retourne la taille du fichier.
Lecture ();
octet lu à partir des données de fichiers.
le readBoolean ();
lu à partir du fichier valeur booléenne 0 représente faux, d' autres représentants vrai.
le readByte ();
lit un octet à partir du fichier.
le readChar (),
la lecture d' un caractère à partir d' un fichier. (Deux octets)
la readDouble ();
lecture d' une valeur double virgule flottante de précision (8 octets) à partir du fichier
du readFloat ();
lu une simple précision à virgule flottante (quatre octets) du fichier
readFully (octet b []);
lu dans le tableau d'octets b.length b, remplit complètement le réseau
du readInt ();
la lecture d' une valeur d'int (4 octets) à partir du fichier
du readLine ();
pour lire une ligne de texte à partir du fichier
le readLong ();
lecture d' une valeur de temps (8 octets) à partir du fichier
du readShort ();
lecture d' une valeur de type court (deux octets) du fichier
readUnsignedByte ();
fichier lu à partir d' un mot non signé section (1 octet)
readUnsignedShort ();
fichier lu à partir d' une valeur à court non signé (2 octets)
la readUTF ();
lire une chaîne de caractères UTF à partir d' un fichier
seek (position longue),
le positionnement de la position de lecture
setLength (longue nouvelleLongueur);
à condition que longueur du fichier.
skipBytes (int n);
sauter un nombre donné d'octets dans le fichier.
écriture (byte b []);
écriture à un fichier de b.length octets
writeBoolean (boolean v);
la valeur booléenne comme une seule valeur d'octet est écrit dans un fichier
writeByte (int v);
écrire à un octet de fichier
writeByte ( string s),
écrit à une chaîne de fichier
writeChar (char c);
caractère écrit dans le fichier
writeChars (string s),
écrite en tant que données de chaîne de caractères dans le fichier
writeDouble (double - v);
l' écriture dans le fichier une double précision en virgule flottante
writeFloat (float v);
valeur en virgule flottante à simple précision d' écriture dans un fichier
writeInt (int v);
écriture à une valeur fichier int
writeLong (longue v);
Ecrire à déposer un entier long
writeShort (int v),
écriture d' une valeur courte au fichier
writeUTF (String s),
écrit un fichier à la chaîne UTF
