
| |
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 {
URL url = new URL (urlPath);
URLConnection connection = url.openConnection ( );
int length = connection.getContentLength ();
if (length = = - 1 ){
throw new IOException (" Fichier vide " );
}
InputStream is = new BufferedInputStream (connection.getInputStream ());
byte [] data = new byte [length];
int currentBit = 0 ;
int deplacement = 0 ;
while (deplacement < length){
currentBit = is.read (data, deplacement, data.length- deplacement);
if (currentBit = = - 1 )break ;
deplacement + = currentBit;
}
is.close ();
if (deplacement ! = length){
throw new IOException (" Le fichier n'a pas été lu en entier (seulement "
+ deplacement + " sur " + length + " ) " );
}
FileOutputStream destinationFile = new FileOutputStream (destination);
destinationFile.write (data);
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 " );
|
|
| |
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.
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 ();
}
|
|
| |
Simple test
package models;
import java.io.File;
import java.util.ArrayList;
import java.util.StringTokenizer;
import javax.swing.filechooser.FileFilter;
@author
public class FiltreMultiple extends FileFilter{
private String description;
private String extension;
private ArrayList< String> acceptedExtensions = new ArrayList< String> ();
@param
@param
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 ());
}
}
@param
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 ));
}
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);
|
|
| |
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;
@author
public class Stock< T> implements Iterable< T> {
private ArrayList< T> datas = null ;
private ArrayList< Integer> ids = null ;
private int position = - 1 ;
public Stock (){
super ();
ids = new ArrayList< Integer> ();
datas = new ArrayList< T> ();
}
@param
@param
public void put (int id, T value){
ids.add (id);
datas.add (value);
}
@param
@return
public T getValueOf (int id){
int index = ids.indexOf (id);
if (index >= 0 ){
return (T)datas.get (index);
}
return null ;
}
@param
@return
public Integer getIdOf (T value){
int index = datas.indexOf (value);
if (index > 0 ){
return (Integer)ids.get (index);
}
return null ;
}
@return
public int getItemCount (){
return datas.size ();
}
@return
public boolean hasNext (){
return position < datas.size () - 1 ;
}
@return
public T next (){
position+ + ;
return datas.get (position);
}
@return
public int getCurrentId (){
return ids.get (position);
}
public void first (){
position = - 1 ;
}
@param
@return
public boolean containsID (Integer id){
return ids.contains (id);
}
@param
@return
public boolean containsValue (T value){
return datas.contains (value);
}
public Iterator< T> iterator () {
return datas.iterator ();
}
}
|
|
| |
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");"
@param
@return
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;
}
|
|
| |
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;
@author
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 = " C:\\Documents and Settings\\Propriétaire\\Bureau\\JTheque V4 " + File.separator + " Logs " + File.separator;
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);
}
private static synchronized void syncInstance (){
if (instance = = null ){
instance = new MyLogger ();
}
}
@return
public static MyLogger getInstance (){
if (instance = = null ){
syncInstance ();
}
return instance;
}
@param
public void message (String message){
logger.info (message);
}
@param
public void request (String request){
logger.info (request);
}
@param
@param
@param
public void exception (String classe, String methode, Throwable exception){
logger.throwing (classe, methode, exception);
}
public void closeHandler (){
handler.close ();
}
}
|
|
| |
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;
@author
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;
@param
@return
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;
@param
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);
}
@param
public IntDate (Calendar calendar){
super ();
this .calendar = calendar;
}
@return
public int getDay (){
return calendar.get (Calendar.DAY_OF_MONTH);
}
@return
public int getYear (){
return calendar.get (Calendar.YEAR);
}
@return
public int getMonth (){
return calendar.get (Calendar.MONTH);
}
@return
public int getDate (){
return Integer.parseInt (getStrDate ());
}
@param
@param
public void add (int field, int toAdd){
if (Fields.isValid (field)){
calendar.add (field, toAdd);
} else {
throw new IllegalArgumentException ();
}
}
@param
@param
public void set (int field, int value){
if (Fields.isValid (field)){
calendar.set (field, value);
} else {
throw new IllegalArgumentException ();
}
}
@return
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
|