La Programmation Orientée Objet en Java : Les fichiers et flux Entrée/Sortie
Le paquetage java.io contient presque toutes les classes dont vous pourriez avoir besoin pour effectuer des entrées et des sorties (E/S) en Java. Tous ces flux représentent une source d'entrée et une destination de sortie. Le flux dans le paquetage java.io prend en charge de nombreuses données telles que les primitives, les objets, les caractères localisés, etc.
Un flux peut être défini comme une séquence de données. InputStream est utilisé pour lire des données à partir d'une source et OutputStream est utilisé pour écrire des données vers une destination.
Java fournit un support fort mais flexible pour les E/S liées aux fichiers et aux réseaux, mais cette partie couvre des fonctionnalités très élémentaires liées aux flux et aux E/S. Nous verions l'exemple le plus couramment utilisé, un par un:
Flux d'octets
Les flux d’octets Java sont utilisés pour effectuer des entrées et des sorties d'octets de 8 bits. Bien qu'il existe de nombreuses classes liées aux flux d'octets, mais les classes les plus fréquemment utilisées sont FileInputStream et FileOutputStream . Voici un exemple qui utilise ces deux classes pour copier un fichier d'entrée dans un fichier de sortie:
public class CopyFile {
public static void main(String args[]) throws IOException
{
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("input.txt");
out = new FileOutputStream("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
Maintenant, nous avons un fichier input.txt avec le contenu suivant:
This is test for copy file.
À l'étape suivante, compilez le programme ci-dessus et exécutez-le, ce qui entraînera la création du fichier output.txt avec le même contenu que dans input.txt. Alors, mettons le code ci-dessus dans le fichier CopyFile.java et faisons ce qui suit:
javac CopyFile.java
java CopyFile
Flux de caractères
Les flux d’octets de Java sont utilisés pour effectuer l'entrée et la sortie d'octets de 8 bits, où les flux de caractères Java sont utilisés pour effectuer l'entrée et la sortie pour unicode 16 bits. Bien qu'il existe de nombreuses classes liées aux flux de caractères, mais les classes les plus fréquemment utilisées sont, FileReader Et FileWriter. Bien que FileReader utilise FileInputStream et FileWriter utilise FileOutputStream mais ici, la différence majeure est que FileReader lit deux octets à la fois et FileWriter écrit deux octets à la fois.
Nous pouvons réécrire l'exemple ci-dessus qui utilise ces deux classes pour copier un fichier d'entrée (ayant des caractères unicode) dans un fichier de sortie:
import java.io.*;
public class CopyFile {
public static void main(String args[]) throws IOException
{
FileReader in = null;
FileWriter out = null;
try {
in = new FileReader("input.txt");
out = new FileWriter("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
Maintenant, nous avons un fichier input.txt avec le contenu suivant:
This is test for copy file.
À l'étape suivante, compilez le programme ci-dessus et exécutez-le, ce qui entraînera la création du fichier output.txt avec le même contenu que dans input.txt. Alors, mettons le code ci-dessus dans le fichier CopyFile.java et faisons ce qui suit:
javac CopyFile.java
java CopyFile
Flux standard
Tous les langages de programmation prennent en charge les E/S standard où le programme de l'utilisateur peut prendre une entrée à partir d'un clavier, puis produire une sortie sur l'écran de l'ordinateur. Si vous êtes au courant des langages de programmation C ou C++, vous devez connaître trois périphériques standards STDIN, STDOUT et STDERR. De façon similaire, Java fournit les trois flux standard suivants
- Entrée standard: Ceci sert à alimenter les données au programme de l'utilisateur et généralement un clavier est utilisé comme flux d'entrée standard et représenté sous System.in.
- Sortie standard: Ceci permet de produire les données produites par le programme de l'utilisateur et généralement un écran d'ordinateur est utilisé pour le flux de sortie standard et représenté sous System.out.
- Erreur standard: Ceci permet de publier les données d'erreur produites par le programme de l'utilisateur et généralement un écran d'ordinateur est utilisé pour le flux d'erreur standard et représenté sous System.err.
Voici un programme simple qui crée InputStreamReader pour lire le flux d'entrée standard jusqu'à ce que l'utilisateur tape un "q":
import java.io.*;
public class ReadConsole {
public static void main(String args[]) throws IOException
{
InputStreamReader cin = null;
try {
cin = new InputStreamReader(System.in);
System.out.println("Enter characters, 'q' to quit.");
char c;
do {
c = (char) cin.read();
System.out.print(c);
} while(c != 'q');
}finally {
if (cin != null) {
cin.close();
}
}
}
}
Gardons le code ci-dessus dans le fichier ReadConsole.java et essayons de le compiler et de l'exécuter comme ci-dessous. Ce programme poursuit la lecture et la sortie du même caractère jusqu'à ce que nous appuyions sur 'q':
javac ReadConsole.java
java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q
Lecture et écriture de fichiers
Comme décrit précédemment, un flux peut être défini comme une séquence de données. InputStream est utilisé pour lire des données à partir d'une source et OutputStream est utilisé pour écrire des données vers une destination.
Voici une hiérarchie de classes pour traiter les flux d'entrée et de sortie.
Les deux flux importants sont FileInputStream et FileOutputStream, qui seront abordés dans cette partie:
FileInputStream
Ce flux est utilisé pour lire des données à partir des fichiers. Les objets peuvent être créés à l'aide du mot-clé new et il existe plusieurs types de constructeurs disponibles.
Le constructeur suivant prend un nom de fichier en tant que chaîne pour créer un objet de flux d'entrée pour lire le fichier:
InputStream f = new FileInputStream("C:/java/hello");
Le constructeur suivant prend un objet de type File pour créer un objet de flux de saisie pour lire le fichier. Tout d'abord, nous créons un objet de fichier à l'aide de la méthode File( ) comme suit:
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);
Une fois que vous avez l'objet InputStream en main, il existe une liste de méthodes auxiliaires qui peuvent être utilisées pour lire ou diffuser ou effectuer d'autres opérations sur le flux.
|
SN |
Méthodes avec description |
|
1 |
public void close() throws IOException{} |
|
2 |
protected void finalize()throws IOException {} |
|
3 |
public int read(int r)throws IOException{} |
|
4 |
public int read(byte[] r) throws IOException{} |
|
5 |
public int available() throws IOException{} Donne le nombre d'octets qui peuvent être lus à partir de ce flux de saisie de fichier. Renvoie un entier. |
FileOutputStream
FileOutputStream est utilisé pour créer un fichier et y écrire des données. Le flux créerait un fichier, s'il n'existe pas déjà, avant de l'ouvrir pour la sortie.
Voici deux constructeurs qui peuvent être utilisés pour créer un objet FileOutputStream.
Le constructeur suivant prend un nom de fichier en tant que chaîne pour créer un objet de flux de saisie pour écrire le fichier:
OutputStream f = new FileOutputStream("C:/java/hello")
Le constructeur suivant prend un objet de type File pour créer un objet de flux de sortie pour écrire le fichier. Tout d'abord, nous créons un objet de fichier à l'aide de la méthode File ( ) comme suit:
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
Une fois que vous avez l'objet OutputStream en main, il existe une liste de méthodes auxiliaires, qui peuvent être utilisées pour écrire ou diffuser ou effectuer d'autres opérations sur le flux.
|
SN |
Méthodes avec description |
|
1 |
public void close() throws IOException{} |
|
2 |
protected void finalize()throws IOException {} |
|
3 |
public void write(int w)throws IOException{} |
|
4 |
public void write(byte[] w) |
Exemple:
Voici l'exemple pour démontrer InputStream et OutputStream :
import java.io.*;
public class fileStreamTest{
public static void main(String args[]){
try{
byte bWrite[] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x=0; x < bWrite.length ; x++){
os.write( bWrite[x] ); // writes the bytes
}
os.close();
InputStream is = new FileInputStream("test.txt");
int size = is.available();
for(int i=0; i< size; i++){
System.out.print((char)is.read() + " ");
}
is.close();
}catch(IOException e){
System.out.print("Exception");
}
}
}
Le code ci-dessus créerait le fichier test.txt et écrirait des nombres donnés en format binaire. La même chose serait affichée sur l'écran stdout.
Navigation des fichiers et E/S
Il existe plusieurs autres classes que nous rencontrerons pour connaître les bases de Navigation des fichiers et des E/S.
- Classe de File
- Classe FileReader
- Classe FileWriter
Répertoires en Java
Un répertoire est un fichier qui peut contenir une liste d'autres fichiers et répertoires. Vous utilisez l'objet File pour créer des répertoires, pour lister les fichiers disponibles dans un répertoire. Pour un détail complet, vérifiez une liste de toutes les méthodes que vous pouvez appeler sur l'objet File et celles relatives aux répertoires.
Création de répertoires
Il existe deux méthodes utiles de la classe File, qui peuvent être utilisées pour créer des répertoires:
- La méthode mkdir( ) crée un répertoire, renvoie true en cas de réussite et false lors de l'échec. L'échec indique que le chemin spécifié dans l'objet File existe déjà ou que le répertoire ne peut pas être créé car le chemin d'accès complet n'existe pas encore.
- La méthode mkdirs( ) crée à la fois un répertoire et tous les parents du répertoire.
L'exemple suivant crée un répertoire "/tmp/user/java/bin":
import java.io.File;
public class CreateDir {
public static void main(String args[]) {
String dirname = "/tmp/user/java/bin";
File d = new File(dirname);
// Create directory now.
d.mkdirs();
}
}
Compilez et exécutez le code ci-dessus pour créer "/tmp/user/java/bin".
Remarque: Java prend automatiquement en charge les séparateurs de chemin sur UNIX et Windows selon les conventions. Si vous utilisez une barre oblique (/) sur une version Windows de Java, le chemin sera toujours résolu.
Liste des répertoires
Vous pouvez utiliser la méthode list( ) fournie par l’objet File pour répertorier tous les fichiers et répertoires disponibles dans un répertoire comme suit:
import java.io.File;
public class ReadDir {
public static void main(String[] args) {
File file = null;
String[] paths;
try{
//create new file object
file = new File("/tmp");
//array of files and directory
paths = file.list();
//for each name in the path array
for(String path:paths)
{
//prints filename and directory name
System.out.println(path);
}
}catch(Exception e){
//if any error occurs
e.printStackTrace();
}
}
}
Cela produirait le résultat suivant en fonction des répertoires et des fichiers disponibles dans votre répertoire /tmp :
test1.txt
test2.txt
ReadDir.java
ReadDir.class