Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :

logo
Sommaire > Java
        Downloader un fichier depuis une URL
        Télécharger la source d'une page WEB en un String
        Filtre multiple pour JFileChooser
        Classe permettant de gérer un couple clé-objet
        Méthode permettant de vérifier la validité d'une date
        Classe permettant de faire des logs
        Gérer une date comme int au format yyyymmdd
        1.1. Fractales de Sierpinski (2)
                Dessinner le tapis de Sierpinski
                Dessinner le triangle de Sierpinski
        1.2. Fractales divers et autres dessins (7)
                Dessinner un dégradé
                Dessinner une simple fractale carrée
                Fractale un peu louche
                Dessinner un nuage de trait
                Dessinner une sorte de soleil
                Dessin à base de super formula
                Dessinne un treillis à base de carré



Auteur : Baptiste Wicht
Version : 27.09.2006
Downloader un fichier depuis une URL
Cette méthode permet de télécharger un fichier disponible sur internet, par exemple, un fichier xml et de le sauvegarder sur votre disque dur.

**
  * 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();
       }   
 }
Pour l'utilisation c'est très simple, il vous suffit d'appeller la méthode avec en paramètre, le chemin source et le chemin vers la destination.

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

Auteur : Baptiste Wicht
Version : 27.09.2006
Télécharger la source d'une page WEB en un String
Cette méthode vous permettra de récupérer le code d'une page WEB sous forme de String, cela peut être utile dans le cas ou vous cherchez des informations sur une page WEB.

/**
* 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();
}

Auteur : Baptiste Wicht
Version : 27.09.2006
Filtre multiple pour JFileChooser
Simple test

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;
	}
}
L'utilisation est très simple, il suffit de définir un nouveau filtre et de lui passer un nom et une description

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

Auteur : Baptiste Wicht
Version : 27.09.2006
Classe permettant de gérer un couple clé-objet
Cette classe vous permet de gérer un couple clé - objet. Vous pourrez donc gérer une liste de personnes par leur ids. De plus, elle est générique donc vous pouvez y mettre ce que vous voulez et est itérable, donc employable dans une boucle foreach.

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();
	}
}

Auteur : Baptiste Wicht
Version : 28.09.2006
Méthode permettant de vérifier la validité d'une date
Cette méthode permet de crypter un mot de passer avec l'algoryhtme SHA-256. Vous pouvez ausssi employer d'autres algos en modifiant la ligne "MessageDigest.getInstance("SHA-256");"

/**
	 * 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;
	}

Auteur : Baptiste Wicht
Version : 28.09.2006
Classe permettant de faire des logs
Cette classe permet de logger des messages dans des fichiers. Pour l'utiliser, il vous suffit de modifier la variable logFolder et y mettre un dossier de log.

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();
	}
}

Version : 11/07/2007
Gérer une date comme int au format yyyymmdd

Cette classe permet d'utiliser un int au format yyyymmdd (par exemple 20071002)

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Locale;

/*
 *     This file is part of JTheque.
 * 	   
 * 	   JTheque is free software; you can redistribute it and/or modify
 * 	   it under the terms of the GNU General Public License as published by
 * 	   the Free Software Foundation; either version 2 of the License, or
 * 	   (at your option) any later version.
 * 	   
 * 	   JTheque is distributed in the hope that it will be useful,
 * 	   but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 	   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * 	   GNU General Public License for more details.
 * 	   
 * 	   You should have received a copy of the GNU General Public License
 * 	   along with ExtendedFrame; if not, write to the Free Software
 * 	   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 * 	   
 */

/**
 * Cette classe permet de gérer une date int (yyyymmdd) de manière simplifiée
 * @author Baptiste Wicht
 *
 */
public class IntDate {
	public static final class Fields {
		public static final int MONTH = Calendar.MONTH;
		public static final int DAY = Calendar.DAY_OF_MONTH;
		public static final int YEAR = Calendar.YEAR;
		
		/**
		 * Permet de tester la validité d'un champ
		 * @param field Le champ à tester
		 * @return true si le champ est un champ accepté sinon false
		 */
		public static boolean isValid(int field){
			return field == MONTH || field == DAY || field == YEAR;
		}
	}
	
	private static IntDate today = null;
	
	private final SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy", Locale.getDefault());
	private final Calendar calendar;
	
	/**
	 * Constructeur de la date, il construit les différentes propriétés de la date
	 * @param date La date sous forme de int
	 */
	public IntDate(int date){
		super();
		
		String dateString = Integer.toString(date);
		
		calendar = Calendar.getInstance();
		calendar.clear();
		
		int day = Integer.parseInt(dateString.substring(6, 8));
		int month = Integer.parseInt(dateString.substring(4, 6)) - 1;
		int year = Integer.parseInt(dateString.substring(0, 4));
		
		calendar.set(year, month, day);
	}
	
	/**
	 * Construit un objet IntDate à partir d'un objet Calendar
	 * @param calendar Le calendar de la date à représenter
	 */
	public IntDate(Calendar calendar){
		super();
		
		this.calendar = calendar;
	}
	
	/**
	 * Retourne le jour de la date
	 * @return Le jour
	 */
	public int getDay(){
		return calendar.get(Calendar.DAY_OF_MONTH);
	}
	
	/**
	 * Retourne l'année de la date
	 * @return L'année
	 */
	public int getYear(){
		return calendar.get(Calendar.YEAR);
	}
	
	/**
	 * Retourne le mois de la date 
	 * @return Le mois
	 */
	public int getMonth(){
		return calendar.get(Calendar.MONTH);
	}
	
	/**
	 * Cette méthode permet de récupérer la date en int
	 * @return La date
	 */
	public int getDate(){
		return Integer.parseInt(getStrDate());
	}
	
	/**
	 * Cette méthode permet d'ajouter quelque chose à la date
	 * @param field Le champ en question
	 * @param toAdd Ce qu'il faut lui ajouter
	 */
	public void add(int field, int toAdd){
		if(Fields.isValid(field)){
			calendar.add(field, toAdd);
		} else {
			throw new IllegalArgumentException();
		}
	}
	
	/**
	 * Cette méthode permet de modifier quelque chose à la date
	 * @param field Le champ en question
	 * @param value La nouvelle valeur qu'il faut lui attribuer
	 */
	public void set(int field, int value){
		if(Fields.isValid(field)){
			calendar.set(field, value);
		} else {
			throw new IllegalArgumentException();
		}
	}
	
	/**
	 * Retourne la date sous forme de chaîne de caractères
	 * @return Une chaîne de caractères représentant la date
	 */
	public String getStrDate(){
		StringBuilder builder = new StringBuilder();
		
		builder.append(getYear());
		
		String strMonth = getMonth() < 10 ? "0" + getMonth() : Integer.toString(getMonth());
		builder.append(strMonth);
		
		String strDay = getDay() < 10 ? "0" + getDay() : Integer.toString(getDay());
		builder.append(strDay);
		
		return builder.toString();
	}
	
	public static IntDate today(){
		if(today == null){
			Calendar calendar = Calendar.getInstance();
			
			today = new IntDate(calendar);
		}
		
		return today;
	}
	
	public int intValue(){
		return getDate();
	}
	
	@Override
	public String toString(){
		return formatter.format(calendar.getTime());
	}
}


Consultez les autres pages sources


Valid XHTML 1.0 TransitionalValid CSS!