Buffer ou pas Buffer

Avec Buffer

Si vous utilisez un Buffer pour lire des données provenant dans notre exemple d’un fichier texte distant avec la méthode in.read(buffer) qui lit un certain nombre d’octets dans le buffer, vous allez constater que c’est plutôt rapide !

Bref, dans l’exemple, on écrit les données dans le fichier en sortie en utilisant la méthode write comme ceci : fos.write(buffer, 0, longueur)

Pourquoi cette méthode est-elle efficace ?

Cette méthode est plus efficace car elle permet de lire plusieurs octets à la fois au lieu de lire un octet après un octet… et donc nous réduisons les temps d’accès au disque que ce soit pour la lecture ou pour l’écriture !

Sans Buffer

Sans notre buffer, on lit les données avec la méthode in.read() qui lit un seul octet à la fois, ensuite on écrit les données dans notre fichier en sortie en utilisant la même méthode write avec la syntaxe suivante : fos.write(donnees). Cette méthode est moins efficace car elle nécessite plus d’opérations pour lire et écrire les données.

Démonstration

Exemple de code Java qui vous montre l’utilisation d’un chargement du fichier gutenberg.txt depuis mon site :

package fr.numerosoft.demo;

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * Exemple d'utilisation de lecture d'un fichier avec et sans Buffer !
 * @author phil
 *
 */
public class BufferPasBuffer {


	public static void main(String[] args) {
		
		/* Téléchargement d'un fichier distant en utilisant un buffer
		  il existe aussi la nanoTime() qui permet d'obtenir un
		  la durée en nanosecondes pour les puristes !
		*/
		long avantTraitement1 = System.currentTimeMillis();
		/*
		 autre façon d'écrire un try catch avec try(){...} catch {...}
		 cela permet de gérer la fermetures des ressources depuis java 7
		 nos 2 flux seront ici fermés qu'il y ait ou pas une exception, donc pas besoin de finally,
		 ça permet de faciliter la gestion des ressources et cette écrire s'appelle : "try-with-resources"
		 A utiliser sans modération !
		*/
		try (
				BufferedInputStream in = new BufferedInputStream(new URL("https://cours-devweb.numerosoft.fr/tests/gutenberg.txt").openStream());
				FileOutputStream fos = new FileOutputStream("gutenberg-avec-buffer.txt"))
			{
			/*
			 Ci-dessous, notre tableau de bytes soit un tampon de 1024 bytes.
			 Ce tableau va servir de tampon pour stocker les données lues avant de les écrire sur le disque !
			 */
		    byte[] buffer = new byte[1024];
		    int longueur;
		    // tant qu'il y a des données à lire 
		    while ((longueur = in.read(buffer)) != -1) {
		    	/*
		    	  write écrit les données stockées dans le tampon (le buffer)
		    	  sur le flux de sortie (fos).
		    	  Elle prend en paramètre le tampon :
		    	  	- index de début de l'écriture : 0
		    	  	- longueur des données à écrire (longueur).
		    	  	  ça permet d'écrire uniquement les données qui ont été lues à l'itération précédente
		    	  	  et non pas tout le tampon !
		    	 */
		        fos.write(buffer, 0, longueur);
		    }
		    long apresTraitement1 = System.currentTimeMillis();
			long tempsExecution = apresTraitement1 - avantTraitement1;
			System.out.println("Voilà la durée du traitement avec Buffer : " + tempsExecution + " millisecondes");
			
		} catch (IOException e) {
		    e.printStackTrace();
		}

		// Téléchargement d'un fichier sans utiliser de buffer
		long avantTraitement2 = System.currentTimeMillis();
		try (
				InputStream in = new URL("https://cours-devweb.numerosoft.fr/tests/gutenberg.txt").openStream();
				FileOutputStream fos = new FileOutputStream("gutenberg-sans-buffer.txt"))
		{
		    int donnees;
		    // tant qu'il y a des données à lire (sans tampon ;(
		    while ((donnees = in.read()) != -1) {
		        fos.write(donnees);
		    }
		    long apresTraitement2 = System.currentTimeMillis();
			long tempsExecution2 = apresTraitement2 - avantTraitement2;
			System.out.println("Voilà la durée du traitement sans Buffer : " + tempsExecution2 + " millisecondes");
		} catch (IOException e) {
		    e.printStackTrace();
		}

		// genre de résultats que vous obtiendrez :
		//Voilà la durée du traitement avec Buffer : 635 millisecondes
		//Voilà la durée du traitement sans Buffer : 7531 millisecondes
	}

}

Résultats que vous pouvez obtenir dans votre console :

Voilà la durée du traitement avec Buffer : 635 millisecondes
Voilà la durée du traitement sans Buffer : 7531 millisecondes

Conclusion

Le code parle de lui-même !

Un buffer ou tampon permet d’améliorer les performances lors du téléchargement de fichiers volumineux ou lorsque la bande passante est limitée.

Cependant, pour des fichiers plus petits ou pour des applications qui ne nécessitent pas de performances élevées, l’utilisation d’un buffer peut n’avoir aucun intérêt.