Binary Stream en Java
1. Introduction aux Binary Streams
Définition
Les binary streams (flux binaires) permettent de lire et d'écrire des données au
format binaire, contrairement aux character streams qui manipulent des données
sous forme de texte. Cela permet un traitement efficace de données comme des
images, des fichiers audio, des fichiers vidéo, ou encore des fichiers structurés.
En Java, les flux binaires sont représentés par des sous-classes de InputStream et
OutputStream.
Principales Classes de Flux Binaires
Classe Fonction
FileInputStream Lire des fichiers binaires (octet par octet).
FileOutputStream Écrire des données binaires dans un fichier.
BufferedInputStream Améliore les performances en ajoutant un tampon à un
flux d'entrée binaire.
BufferedOutputStream Améliore les performances en ajoutant un tampon à un
flux de sortie binaire.
DataInputStream Permet de lire des types de données primitifs (int, float,
char, etc.) depuis un flux binaire.
DataOutputStream Permet d’écrire des types de données primitifs dans un
flux binaire.
Pourquoi utiliser les Binary Streams ?
Performance : Manipuler directement les octets est plus rapide que traiter des
chaînes de caractères.
Compatibilité : Les fichiers binaires sont souvent requis pour des protocoles
réseau, des bases de données ou des formats spécifiques.
Taille réduite : Les fichiers binaires sont généralement plus compacts que
leurs équivalents textuels.
2. Écriture dans un fichier binaire
Exemple 1 : Écrire un tableau d’entiers dans un fichier binaire
import java.io.DataOutputStream;
import java.io.FileOutputStream;
1
L.KARBIL
import java.io.IOException;
public class BinaryStreamWriteExample {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
try (DataOutputStream dos = new DataOutputStream(new
FileOutputStream("data.bin"))) {
for (int num : numbers) {
dos.writeInt(num); // Écrit un entier dans le fichier
}
System.out.println("Données écrites avec succès !");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Exemple 2 : Écrire un fichier contenant du texte en binaire
import java.io.FileOutputStream;
import java.io.IOException;
public class BinaryWriteTextExample {
public static void main(String[] args) {
String message = "Bonjour, flux binaire en Java !";
try (FileOutputStream fos = new FileOutputStream("text.bin")) {
fos.write(message.getBytes()); // Conversion en tableau d'octets
System.out.println("Texte écrit avec succès en binaire !");
} catch (IOException e) {
e.printStackTrace();
}
}
}
2
L.KARBIL
3. Lecture d’un fichier binaire
Exemple 3 : Lire un tableau d’entiers depuis un fichier binaire
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BinaryStreamReadExample {
public static void main(String[] args) {
try (DataInputStream dis = new DataInputStream(new
FileInputStream("data.bin"))) {
while (dis.available() > 0) {
int num = dis.readInt(); // Lit un entier du fichier
System.out.println("Numéro lu : " + num);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Exemple 4 : Lire du texte depuis un fichier
import java.io.FileInputStream;
import java.io.IOException;
public class BinaryReadTextExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("text.bin")) {
byte[] buffer = fis.readAllBytes(); // Lit tous les octets
String message = new String(buffer); // Convertit les octets en chaîne
System.out.println("Message lu : " + message);
3
L.KARBIL
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. Combinaison avec des tampons pour améliorer les performances (30
minutes)
Exemple 5 : Utiliser des flux tamponnés
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedBinaryWriteExample {
public static void main(String[] args) {
String data = "Java Binary Streams avec buffer";
try (BufferedOutputStream bos = new BufferedOutputStream(new
FileOutputStream("buffered.bin"))) {
bos.write(data.getBytes());
System.out.println("Données écrites avec buffer !");
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. Travail Pratique : Manipulation de fichiers binaires (30 minutes)
Objectif :
Créer un fichier binaire contenant une liste de noms et d’âges, puis lire et afficher ces
informations.
Étape 1 : Écriture dans un fichier binaire
4
L.KARBIL
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TPBinaryWrite {
public static void main(String[] args) {
String[] names = {"Ali", "Fatou", "Amadou"};
int[] ages = {25, 30, 28};
try (DataOutputStream dos = new DataOutputStream(new
FileOutputStream("persons.bin"))) {
for (int i = 0; i < names.length; i++) {
dos.writeUTF(names[i]); // Écrit une chaîne
dos.writeInt(ages[i]); // Écrit un entier
}
System.out.println("Fichier créé avec succès !");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Étape 2 : Lecture depuis un fichier binaire
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class TPBinaryRead {
public static void main(String[] args) {
try (DataInputStream dis = new DataInputStream(new
FileInputStream("persons.bin"))) {
5
L.KARBIL
while (dis.available() > 0) {
String name = dis.readUTF(); // Lit une chaîne
int age = dis.readInt(); // Lit un entier
System.out.println("Nom : " + name + ", Âge : " + age);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
6. Bonnes pratiques et erreurs courantes
Utilisez les blocs try-with-resources : Gère automatiquement la fermeture
des ressources.
Testez l’existence des fichiers avant la lecture.
Évitez les fichiers binaires pour des données qui nécessitent une
modification manuelle.
Gardez une documentation claire du format binaire utilisé.
7. Questions et exercices complémentaires
1. Modifiez le TP pour ajouter une moyenne d’âge au fichier après les données.
2. Essayez de convertir un fichier image (PNG ou JPEG) en binaire, puis de le
recréer à partir des octets lus.
6
L.KARBIL
