**
  * Cette méthode permet de télécharger un fichier depuis une URL
  * @param urlPath chemin du fichier source (site web)
  * @param destination chemin de destination
  */
 private void downloadFile(String urlPath, String destination) { 
  try { 
   //On crée l'URL
          URL url = new URL(urlPath);
 
   //On crée une connection vers cet URL
   URLConnection connection = url.openConnection( );
 
   //On récupère la taille du fichier
   int length = connection.getContentLength();
 
   //Si le fichier est inexestant, on lance une exception
   if(length == -1){
    throw new IOException("Fichier vide");
         }
 
   //On récupère le flux du fichier
   InputStream is = new BufferedInputStream(connection.getInputStream());
 
   //On prépare le tableau de bits pour les données du fichier
   byte[] data = new byte[length];
 
   //On déclare les variables pour se retrouver dans la lecture du fichier
   int currentBit = 0;
   int deplacement = 0;
 
   //Tant que l'on n'est pas à la fin du fichier, on récupère des données
   while(deplacement < length){
    currentBit = is.read(data, deplacement, data.length-deplacement); 
    if(currentBit == -1)break; 
    deplacement += currentBit;
   }
 
   //On ferme le stream
   is.close();
 
   //Si on est pas arrivé à la fin du fichier, on lance une exception
   if(deplacement != length){
    throw new IOException("Le fichier n'a pas été lu en entier (seulement "
 + deplacement + " sur " + length + ")");
   }  
 
   //On crée un flux sortant vers la destination
   FileOutputStream destinationFile = new FileOutputStream(destination); 
 
   //On écrit les données du fichier dans ce flux
   destinationFile.write(data);
 
   //On vide le tampon et on ferme le stream
   destinationFile.flush();
   destinationFile.close();
 
       } catch (MalformedURLException e) { 
         System.err.println("Problème avec l'URL : " + urlPath); 
       } catch (IOException e) { 
         e.printStackTrace();
       }   
 }

	downloadFile("www.XXX.com/XXX/XXX.xxx", "C:\\XXX\XXX.xxx");

/**
* Cette méthode permet de récupérer la source d'une page WEB sous forme de String
*/
publig String getSourceOfWebPage(String page){
	URLConnection urlConnection = new URL(page).openConnection();
	urlConnection.setUseCaches(false);
	urlConnection.connect();
				
	Scanner scanner = new Scanner(urlConnection.getInputStream());
	StringBuffer source = new StringBuffer();
	
	while(scanner.hasNextLine()){
		source.append(scanner.nextLine());
	}
	
	return source.toString();
}

package models;
import java.io.File;
import java.util.ArrayList;
import java.util.StringTokenizer;
import javax.swing.filechooser.FileFilter;
 
/**
* Classe de filtre pour JFileChooser, permet de selectionner différents 
types de fichier. On peut passer plusieurs extensions de fichiers en 
paramètres, mais il faut les séparer par des virgules
* @author Wichtounet
*
*/
public class FiltreMultiple extends FileFilter{//Description et extension acceptée par le filtre
	private String description;
	private String extension;
	private ArrayList<String> acceptedExtensions = new ArrayList<String>();
	
	/**
	* Constructeur du filtre
	* @param description Description du filtre
	* @param extensions Extensions valides donc à afficher
	*/
	public FiltreMultiple(String description, String extensions){
		if(description == null || extensions ==null){
			throw new NullPointerException("La description (ou extension) ne peut être null.");
		}
		
		this.description = description;
		this.extension = extensions;
		 
		StringTokenizer token = new StringTokenizer(extension,",");
		 
		while(token.hasMoreTokens()){
			acceptedExtensions.add(token.nextToken());
		}
	}
 
	/**
	* Méthode qui dit si un fichier doit etre affiché ou pas en fonction de son extension
	* @param file Fichier qui demande à etre accepté ou pas
	*/
	public boolean accept(File file){String nomFichier = file.getName().toLowerCase(); 
		if(file.isDirectory()) { 
			return true; 
		} 
			else{for(short i = 0; i < acceptedExtensions.size();i++){
				if(nomFichier.endsWith(acceptedExtensions.get(i)))return true;
			}
		}
		
		return nomFichier.endsWith(acceptedExtensions.get(acceptedExtensions.size()-1));
	}
 
	/**
	* Méthode qui retourne la description du filtre
	*/
	public String getDescription(){
		return description;
	}
}

FiltreMultiple filtre = new FiltreMultiple("Images","bmp,jpg,gif,png");
fileChooser.setFilter(filtre);

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Cette classe permet la gestion d'une liste de couple clé-valeur. On peut récupérer soit la valeur soit 
 * l'id via l'autre partie du couple et récupérer le valeur en fonction de sa place dans la liste.
 * @author Wichtounet
 *
 */
public class Stock<T> implements Iterable<T>{
	/* Listes contentants les ids et les objets*/
	private ArrayList<T> datas = null;
	private ArrayList<Integer> ids = null;
	
	//Position actuelle de lecture
	private int position = -1;
	
	/**
	 * Constructeur de la classe, il initialise les deux listes de données
	 *
	 */
	public Stock(){
		super();
		
		ids = new ArrayList<Integer>();
		datas = new ArrayList<T>();
	}
	
	/**
	 * Méthode pour ajouter un nouveau couple dans la collection
	 * @param id, l'id du couple
	 * @param value, la valeur du couple
	 */
	public void put(int id, T value){
		ids.add(id);
      	datas.add(value);
	}
	
	/**
	 * Cette méthode permet de récupérer une valeur à partir d'un id
	 * @param id, id de la valeur à récupérer
	 * @return La valeur correspondant à l'id
	 */
	public T getValueOf(int id){
		int index = ids.indexOf(id);
		
		if (index >= 0){
			return (T)datas.get(index);          
		}
		
		return null;
	}
	
	/**
	 * Cette méthode permet de récupérer un id à partir d'une valeur
	 * @param value, valeur dont on recherche l'id
	 * @return L'id
	 */
	public Integer getIdOf(T value){
		int index = datas.indexOf(value);
		
		if(index > 0){
			return (Integer)ids.get(index);
		}
		
		return null;
	}
	
	/**
	 * Méthode qui retourne le nombre d'éléments du tableau
	 * @return Le nombre d'éléments de la collection
	 */
	public int getItemCount(){
		return datas.size();
	}
	
	/**
	 * Méthode qui dit s'l reste encore des éléments avant la fin du parcous
	 * @return true ou false
	 */
	public boolean hasNext(){		
		return position < datas.size() -1;
	}
	
	/**
	 * Méthode qui retourne l'élément suivant dans la collection
	 * @return La valeur de l'élément
	 */
	public T next(){
		position++;
		return datas.get(position);
	}
	
	/**
	 * Méthode qui retourne l'id de l'élément courant
	 * @return id de l'élément courant
	 */
	public int getCurrentId(){
		return ids.get(position);
	}
	
	/**
	 * Méthode qui revient au début de la collection pour permettre un deuxième parcours
	 *
	 */
	public void first(){
		position = -1;
	}
	
	/**
	 * Cette méthode permet de vérifier si un id est déja contenu ou non dans la liste
	 * @param id L'id à rechercher
	 * @return true si l'id est trouvé et false s'il ne l'est pas
	 */
	public boolean containsID(Integer id){
		return ids.contains(id);
	}
	
	/**
	 * Cette méthode permet de vérifier si une valeur est déja contenu ou non dans la liste
	 * @param value La valeur à rechercher
	 * @return true si la valeur est trouvée et false s'elle ne l'est pas
	 */
	public boolean containsValue(T value){
		return datas.contains(value);
	}
	
	/**
	 * Cette méthode permet de générer un itérateur des données contenues dans le classe
	 */
	public Iterator<T> iterator() {
		return datas.iterator();
	}
}

/**
	 * Cette méthode permet d'encrypter un password avec l'algorythme de cryptage SHA-256
	 * @param password à encrypter
	 * @return le password encrypté
	 */
	private static String encryptPassword(String password){
		String passwordEncoded = "";
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
			
			md.update(password.getBytes());
			
			passwordEncoded = new String(md.digest());
			
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} finally{
			md.reset();
		}
		
		return passwordEncoded;
	}

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

/**
 * Cette classe permet de gérer le log des erreurs, des requêtes et des messages dans des fichiers, elle fonctionne
 * en verrouillage à double tour. 
 * @author Wichtounet
 *
 */
public class SimpleLogger{
	
	private static MyLogger instance = null;
	private Logger logger = null;
	private Handler handler = null;
	private DateFormat dateFormat = new SimpleDateFormat("ddMMyy");
	//private String logsFolder = System.getProperty("user.dir") + File.separator + "Logs" + File.separator;
	private String logsFolder = "C:\\Documents and Settings\\Propriétaire\\Bureau\\JTheque V4" + File.separator + "Logs" + File.separator;
	
	/**
	 * Construcuteur du loggeur, il est privé pour permettre le verrouillage
	 *
	 */
	private MyLogger(){
		super();
		
		logger = Logger.getLogger("utils.MyLogger");
		logger.setLevel(Level.FINER);
		
		String date = dateFormat.format(new Date());
		
		try {
			File logFile = new File(logsFolder + date + ".log");
			
			if(logFile.exists()){
				handler = new FileHandler(logFile.getAbsolutePath(), true);
			}else{
				logFile.createNewFile();
				handler = new FileHandler(logFile.getAbsolutePath());
			}
			
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		handler.setFormatter(new SimpleFormatter());
		
		logger.addHandler(handler);
	}
	
	/**
	 * Cette méthode permet de charger instance en tant que nouvelle instance de Language, il est synchronisé
	 * pour ne pas avoir de problèmes avec le multi-thread
	 *
	 */
	private static synchronized void syncInstance(){
		if(instance == null){
			instance = new MyLogger();
		}
	}
	
	/**
	 * Cette méthode retourne l'instance unique du logger
	 * @return L'instance de logger
	 */
	public static MyLogger getInstance(){
		if(instance == null){
			syncInstance();
		}
		
		return instance;
	}
	
	/**
	 * Cette méthode logge un nouveau message
	 * @param message le message à logger
	 */
	public void message(String message){
		logger.info(message);
	}
	
	/**
	 * Cette méthode logge une nouvelle requête
	 * @param request la requête à logger
	 */
	public void request(String request){
		logger.info(request);
	}
	
	/**
	 * Cette méthode logge une nouvelle exception
	 * @param classe la classe d'ou vient l'exception
	 * @param methode la méthode d'ou vient l'exception
	 * @param exception l'exception qui a été levée
	 */
	public void exception(String classe, String methode, Throwable exception){
		logger.throwing(classe, methode, exception);
	}
	
	/**
	 * Cette méthode permet de fermer proprement le fichier de log
	 *
	 */
	public void closeHandler(){
		handler.close();
	}
}