Plusieurs façons de lire des fichiers en Java 1. Lisez le contenu des fichiers de plusieurs manières.
1. Lire le contenu du fichier par octets
2. Lire le contenu du fichier par caractère
3. Lire le contenu du fichier ligne par ligne
4. Lire au hasard le contenu du fichier
*/
importer java.io.BufferedReader ;
importer java.io.File ;
importer java.io.FileInputStream ;
importer java.io.FileReader ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.io.InputStreamReader ;
importer java.io.RandomAccessFile ;
importer java.io.Reader ;
classe publique ReadFromFile {
/**
* Lire des fichiers en octets, souvent utilisé pour lire des fichiers binaires, tels que des images, des sons, des images, etc.
* @param fileName Le nom du fichier
*/
public static void readFileByBytes (String fileName) {
Fichier fichier = nouveau fichier (nom de fichier);
Flux d'entrée dans = null ;
essayer {
System.out.println("Lire le contenu du fichier en octets, un octet à la fois :");
//Lire un octet à la fois
in = nouveau FileInputStream(fichier);
int octet temporaire ;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
joindre();
} catch (IOException e) {
e.printStackTrace();
retour;
}
essayer {
System.out.println("Lire le contenu du fichier en octets, plusieurs octets à la fois :");
//Lire plusieurs octets à la fois
octet[] tempbytes = nouvel octet[100];
int lecture d'octets = 0 ;
in = nouveau FileInputStream(fileName);
ReadFromFile.showAvailableBytes(dans);
//Lire plusieurs octets dans le tableau d'octets, byteread est le nombre d'octets lus en même temps
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} attraper (Exception e1) {
e1.printStackTrace();
} enfin {
si (dans != null){
essayer {
joindre();
} catch (IOException e1) {
}
}
}
}
/**
* Lire des fichiers en unités de caractères, souvent utilisées pour lire du texte, des chiffres et d'autres types de fichiers
* @param fileName nom du fichier
*/
public static void readFileByChars (String fileName) {
Fichier fichier = nouveau fichier (nom de fichier);
Lecteur lecteur = nul ;
essayer {
System.out.println("Lire le contenu du fichier en unités de caractères, un octet à la fois :");
//Lire un caractère à la fois
lecteur = nouveau InputStreamReader (nouveau FileInputStream (fichier));
int tempchar;
while ((tempchar = reader.read()) != -1){
//Pour Windows, lorsque les deux caractères rn sont ensemble, ils représentent une nouvelle ligne.
//Mais si ces deux caractères sont affichés séparément, les lignes seront modifiées deux fois.
//Par conséquent, bouclier r, ou bouclier n. Sinon, il y aura beaucoup de lignes vides.
si (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
lecteur.close();
} attraper (Exception e) {
e.printStackTrace();
}
essayer {
System.out.println("Lire le contenu du fichier en unités de caractères, plusieurs octets à la fois :");
//Lire plusieurs caractères à la fois
char[] tempchars = nouveau char[30];
int charread = 0;
lecteur = nouveau InputStreamReader (nouveau FileInputStream (nom de fichier));
//Lire plusieurs caractères dans le tableau de caractères, charread est le nombre de caractères lus à la fois
while ((charread = reader.read(tempchars))!=-1){
//De la même manière, protégez r de l'affichage
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}autre{
pour (int i=0; i<charread; i++){
si(tempchars[i] == 'r'){
continuer;
}autre{
System.out.print(tempchars[i]);
}
}
}
}
} attraper (Exception e1) {
e1.printStackTrace();
}enfin {
si (lecteur != null){
essayer {
lecteur.close();
} catch (IOException e1) {
}
}
}
}
/**
* Lire des fichiers en unités de ligne, souvent utilisé pour lire des fichiers formatés en ligne
* @param fileName nom du fichier
*/
public static void readFileByLines (String fileName) {
Fichier fichier = nouveau fichier (nom de fichier);
Lecteur BufferedReader = null ;
essayer {
System.out.println("Lire le contenu du fichier en unités de ligne, en lisant une ligne entière à la fois :");
lecteur = nouveau BufferedReader (nouveau FileReader (fichier));
Chaîne tempString = null ;
ligne int = 1 ;
//Lire une ligne à la fois jusqu'à ce que null soit lu comme fin du fichier
while ((tempString = reader.readLine()) != null){
//afficher le numéro de ligne
System.out.println("line " + line + ": " + tempString);
ligne++;
}
lecteur.close();
} catch (IOException e) {
e.printStackTrace();
} enfin {
si (lecteur != null){
essayer {
lecteur.close();
} catch (IOException e1) {
}
}
}
}
/**
* Lire au hasard le contenu du fichier
* @param fileName nom du fichier
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
essayer {
System.out.println("Lire le contenu d'un fichier aléatoire :");
// Ouvrir un flux de fichiers à accès aléatoire en mode lecture seule
randomFile = new RandomAccessFile(fileName, "r");
//Longueur du fichier, nombre d'octets
long fileLength = randomFile.length();
//Lire la position de départ du fichier
int startIndex = (fileLength > 4) ?
// Déplacez la position de départ du fichier lu vers la position beginIndex.
randomFile.seek(beginIndex);
octet[] octets = nouvel octet[10];
int lecture d'octets = 0 ;
//Lire 10 octets à la fois. Si le contenu du fichier est inférieur à 10 octets, lisez les octets restants.
// Attribue le nombre d'octets lus à la fois à byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(octets, 0, byteread);
}
} catch (IOException e){
e.printStackTrace();
} enfin {
si (randomFile != null){
essayer {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* Afficher le nombre d'octets restants dans le flux d'entrée
* @param dans
*/
privé statique vide showAvailableBytes (InputStream in) {
essayer {
System.out.println("Le nombre d'octets dans le flux d'entrée d'octets actuel est :" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main (String[] arguments) {
String fileName = "C:/temp/newTemp.txt" ;
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
2. Ajouter du contenu à la fin du fichier
importer java.io.FileWriter ;
importer java.io.IOException ;
importer java.io.RandomAccessFile ;
/**
* Ajouter du contenu à la fin du fichier
*/
classe publique AppendToFile {
/**
*Une méthode pour ajouter des fichiers : utilisez RandomAccessFile
* @param fileName nom du fichier
* @param content contenu supplémentaire
*/
public static void appendMethodA (String fileName,
Contenu de la chaîne){
essayer {
// Ouvrir un flux de fichiers à accès aléatoire, en mode lecture et écriture
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
//Longueur du fichier, nombre d'octets
long fileLength = randomFile.length();
// Déplacez le pointeur du fichier d'écriture à la fin du fichier.
randomFile.seek(fileLength);
randomFile.writeBytes(contenu);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
}
}
/**
* Méthode B pour ajouter des fichiers : utilisez FileWriter
* @param nomfichier
* Contenu @param
*/
public static void appendMethodB (String fileName, String content){
essayer {
//Ouvre un rédacteur de fichier. Le deuxième paramètre vrai dans le constructeur signifie écrire le fichier sous forme d'ajout.
FileWriterwriter = new FileWriter(fileName, true);
écrivain.write(content);
écrivain.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main (String[] arguments) {
String fileName = "C:/temp/newTemp.txt" ;
Contenu de la chaîne = "nouvel ajout !";
//Ajouter des fichiers selon la méthode A
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. n");
//Afficher le contenu du fichier
ReadFromFile.readFileByLines(fileName);
//Ajouter des fichiers selon la méthode B
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. n");
//Afficher le contenu du fichier
ReadFromFile.readFileByLines(fileName);
}
}