JAVA

    Le JDK de sun se compose d'un ensemble d'utilitaires permettant la compilation, 
    l'exécution ,... de vos classes mais aussi un ensemble de classes effectuant les tâches 
    de bas niveau
    	- Gestion des fichiers
    	- Gestion du réseau
    	- Gestion du clavier
    	- ...
    	
    Ces classes sont regroupées dans les packages suivants : (Liste non exhaustive)
    	- java.util.* : Utilitaire (Tableau, Ressource, fichier de propriété, ...)
    	- java.io.* : Gestion des fichiers lecture, écriture, création, ...
    	- java.lang.* : Gestion du langage java (classes, processus)
    	- java.text.* : Gestion du formatage des chaînes de caractères (représentation d'un 
    	numérique, d'une date, ...)
    	- java.sql.* : Gestion des ordres et types SQL.
    	- java.net.*  : Gestion des réseaux (liens avec les serveurs , sockets, ...)
    	- javax.servlet.* : Gestion des servlets
    	- javax.sql.* : Gestion des pools de connexions.

Manipulation de chaînes de caractères : 
    Java propose deux classes permettant de gérer les chaînes de caractères
    	- String : Classe permettant la représentation d'une chaîne de caractères.
    	- StringBuffer : Classe permettant la manipulation de chaînes de caractères.

Classe String 
    Les chaînes de caractères sont représentées par l'objet String du package java.lang. 
    L'objet String est le seul objet qui ne respecte pas les mêmes règles que tous les objets.
    
    Création d'une chaîne de caractères : 
    	- String maChaine = new String("Formation Volubis");
    	- String maChaine = "Formation Volubis";
    
    Manipulation : 
    	- Longueur : maChaine.length();
    	- Suppression des blancs : maChaine.trim();
    	- Extraction : maChaine.substring(0, 3);
    	- Position d'une chaîne : maChaine.indexOf("Vol");
    	- Majuscule / minuscule : maChaine.toUpperCase(); maChaine.toLowerCase();
    	- Concaténation : 
    		String chaine1 = "Formation";
    		String chaine2 = "Volubis";
    		String chaine3 = chaine1 + " " + chaine2;
    
    Particularité : 
    	String maChaine = "Formation";
    	       Objet       Objet
    	Il est possible d'utiliser les méthodes de l'objet String avec la variable mais 
    	aussi avec l'expression littérale : 
    		maChaine.length();
    		maChaine.toUpperCase();
    		"Formation".length();
    		"Formation".toUpperCase();
    	
    	Comparaison de chaîne de caractères : 
    		String chaine1 = "Formation";
    		String chaine2 = "Formation";
    		chaine1==chaine2; renvoi faux
    		chaine1.equals(chaine2); renvoi vrai
    		chaine1.equalsIgnoreCase(chaine2); renvoi vrai
    		
    Un objet String est un tableau de caractères : String maChaine = "Ceci est une chaine";

    maChaine.charAt(0) -> C
    maChaine.charAt(9) -> u
    maChaine.length() -> 19
    

    maChaine.substring(9,12) -> une
    

Méthodes de l'objet String : 
    	- charAt(int pos) : Retourne le caractère qui est à la position "pos"
    	- compareTo(String) : Compare 2 chaînes de caractères
    	- copyValueOf(char[] data) : Transforme un tableau de char en une chaîne
    	- endsWith(String) : Retourne un booléen indiquant si la chaîne se finit par
    	le suffixe passé en paramètre.
    	- startsWith(String): Retourne un booléen indiquant si la chaîne se finit par
    	le préfixe passé en paramètre.
    	- equalsIgnoreCase(String) : Retourne un booléen indiquant la comparaison
    	- indexOf(char c) : Retourne la position d'une char dans la chaîne
    	- indexOf(String s) : Retourne la position du début de la chaîne passée en paramètre
    	- indexOf(String c, int i) : Retourne la position d'une chaîne dans la chaîne
    	courante à partir de la position passée en paramètre 
    	- lastIndexOf(String s) : retourne la dernière position d'une chaîne passée en 
    	paramètre
    	- length() : Retourne la longueur de la chaîne.
    	- replace(char old, char new) : Remplace un caractère par un autre dans la chaîne.
    	- substring(int pos) : Retourne la partie de la chaîne se trouvant après la
    	position passée en paramètre.
    	- substring(int debut, in fin) : Retourne la partie de la chaîne se trouvant entre
    	la position de début et de fin passées en paramètre.
    	- toCharArray() : Retourne la chaîne sous la forme d'un tableau de char
    	- toLowerCase() : Retourne la chaîne en minuscule
    	- toUpperCase() : Retourne la chaîne en majuscule
    	- valueOf(int i) : Convertit un entier en chaîne.
    	- valueOf(double d) : Convertit un réel en chaîne.
    	- valueOf(char c) : Convertit un char en chaîne.



		
    

package formation.sintaxe;

    
public class NomFichier {
 	private String fullPath;
    private char pathSeparator, extensionSeparator;

/**
 * Constructeur sans arguments de la classe NomFichier
 */
public NomFichier() {
	super();
}
/**
 * Constructeur Permettant d'initialiser les attributs de la classe
 * String str : Chemin et nom du fichier
 * char sep : caractère de séparation des répertoires
 * char ext : caractère délimitant le nom duf cichier et l'extension
 */
public NomFichier (String str, char sep, char ext) {
	fullPath = str;
	pathSeparator = sep;
	extensionSeparator = ext;
}
/**
*	Méthode permettant de donner la valeur de l'extension du ficher
*	
*/
public String extension() {
	int point  = fullPath.lastIndexOf(extensionSeparator);
	return fullPath.substring(point + 1);
}
/**
*	Méthode permettant de donner le nom du ficher
*	
*/
public String nomDuFichier() {
	int point = fullPath.lastIndexOf(extensionSeparator);
	int sep = fullPath.lastIndexOf(pathSeparator);
	return fullPath.substring(sep + 1, point);
}
/**
*	Méthode permettant de donner le chemin du ficher
*	
*/
public String path() {
	int sep = fullPath.lastIndexOf(pathSeparator);
	return fullPath.substring(0, sep);
}
/**
*	Méthode permettant de donner le type de l'extension du ficher
*	
*/
public String typeExtension() {
	String valRet = nomDuFichier() + " n'est pas un fichier Web.";
	String ext = extension();
	    	  
	if(ext.equalsIgnoreCase("html")||ext.equalsIgnoreCase("htm")){
		valRet = nomDuFichier() + " est un fichier Web.";
	}
	return valRet;
}
}

package formation.sintaxe;

 //Création d'un programme permettant d'appeler cette classe
 public class NomFichierDemo {
    public static void main(String[] args) {
        NomFichier fichier = new NomFichier ("/home/file/index.html",
                                           '/', '.');
        System.out.println("Extension = " + fichier.extension());
        System.out.println("Filename = " + fichier.nomDuFichier());
        System.out.println("Path = " + fichier.path());
        System.out.println("Type = " + fichier.typeExtension());
    }
}

Concaténation de chaîne : Utilisation de la classe StringBuffer
    La concaténation de chaîne intuitive se fait de la façon suivante :
     
    System.out.println("Type = " + fichier.typeExtension());
    
    fichier.extension renvoi une chaîne de caractère.
    
    cependant l'interpréteur java transforme cette instruction en utilisant la
    classe StringBuffer. En effet, il est préférable d'utiliser la classe
    StringBuffer pour concaténer des chaînes de caractères. Les gains de performances
    sont réels. L'utilisation de cette classe est fortement conseillee par SUN.
    
    Notre instruction devient alors : 
       StringBuffer strb = new StringBuffer();
       strb.append("Type = ");
       strb.append(fichier.typeExtension());
       System.out.println(strb.toString());

    Méthode de la classe StringBuffer : 
    	- append(String s) : Ajoute la chaîne passée en paramètre à la chaîne en cours.
    	- append(char[] data) : Ajoute le tableau de char passé en paramètre à 
    	la chaîne en cours.
    	- append(int i) : Ajoute l'entier passé en paramètre à la chaîne en cours.
    	- charAt(int pos) : Retourne le char qui est à la position passée en paramètre.
    	- delete(int deb, int fin) : Supprime les caractères compris entre la position
    	de début et la position de fin
    	- insert(int pos, String s) : Insère une chaîne à partir d'une position
    	- length() : Retourne la longueur de la chaîne.
    	- replace(int deb, int fin, String s) : remplace un morceau de chaîne
    	- reverse() : inverse la chaîne en cours
    	- substring(int pos) : Retourne la partie de la chaîne se trouvant après la
    	position passée en paramètre.
    	- substring(int debut, in fin) : Retourne la partie de la chaîne se trouvant entre


 Exercice :    

public class InversionDeChaine{
        //Constructeur		
    public InversionDeChaine(){}
        
      public String inverserChaine(String source) {
       //Créer une variable qui va contenir la nouvelle chaîne
       //Créer une variable qui contient la longueur de la source
		
	   //Coder une boucle permettant d'inverser la chaîne
	   
        //Retourner la valeur    
      }
} 
    
//Création d'un programme permettant d'appeler cette classe 
public class InversionDemo { 
 //Créer la méthode qui va permettre d'afficher la chaîne inversée. 
} 
        

Corrigé

package formation.sintaxe;

/**
 * Classe peremttant d'inverser une chaîne de caractère
 */
public class InversionDeChaine {
	
/**
 * Constructeur de la classe InversionDeChaine 
 */
public InversionDeChaine() {
	super();
}
/**
 * Méthode retournant la chaîne de caractère inverser
 * Creation date: (31/10/2002 10:56:14)
 * @return java.lang.String
 * @param source java.lang.String
 */
public String inverserChaine(String source) {
	//Longueur de la chaine
	int longueur = source.length()-1;
	
	StringBuffer cible = new StringBuffer(longueur);
	//Boucle permettant d'inverser la chaîne
	do{
		cible.append(source.charAt(longueur));
	}while(--longueur >= 0);
	
	return cible.toString();
}
}

Expression arithmétique : 

public class ArithmetiqueDemo {
    public static void main(String[] args) {

        //Déclaration
        int i = 37;
        int j = 42;
        double x = 27.475;
        double y = 7.22;

        //Afficher l'additionner les chiffres
        System.out.println("Additionner...");
        //Additionner i et j
        //Additionner x et y

        //Afficher la soustraction des chiffres
        System.out.println("Soustraire...");
	//Soustraire i et j
	//Soustraire x et y

        //Afficher les multiplications
        System.out.println("Multiplication...");
        //Multiplier i et j
        //Multiplier x et y

        //Afficher les Divisions
        System.out.println("Division...");
        //Diviser i par j
        //Diviser x par y

        //Afficher le reste des divisions
        System.out.println("Modulo...");
        //Modulo i par j
        //Modulo x par y

    }
}
        

    
    Corrigé
    
    

package formation.sintaxe;

/**
 * Illustration des foncions arithméthiques
 * Creation date: (31/10/2002 14:25:15)
 * @author: Administrator
 */
public class ArithmetiqueDemo {
/**
 * Constructeur de la classe ArithmetiqueDemo.
 */
public ArithmetiqueDemo() {
	super();
}
/**
 * Méthode principale
 * Creation date: (31/10/2002 14:25:39)
 * @param args java.lang.String[]
 */
public static void main(String[] args) {
	
	//Déclaration des variables
	int i = 5;
	int j = 10;
	double x = 20.475;
	double y = 7.22;
	
	//Afficher l'addition des chiffres

	StringBuffer chaine1 = new StringBuffer();
	StringBuffer chaine10 = new StringBuffer();
	chaine1.append("le résultat de l'addition est : ");
	chaine1.append(i+j);
	System.out.println(chaine1.toString());
	chaine10.append("le résultat de l'addition est : ");
	chaine10.append(x+y);
	System.out.println(chaine10.toString()); 
	
	//Afficher la sousttraction des chiffres

	StringBuffer chaine2 = new StringBuffer();
	chaine2.append("le résultat de la soustraction est : ");
	chaine2.append(j-i);
	System.out.println(chaine2.toString()); 
	StringBuffer chaine20 = new StringBuffer();
	chaine20.append("le résultat de la soustraction est : ");
	chaine20.append(x - y);
	System.out.println(chaine20.toString()); 

	//Afficher la multiplcation des chiffres

	StringBuffer chaine3 = new StringBuffer();
	chaine3.append("le résultat de la multiplication est : ");
	chaine3.append(j*i);
	System.out.println(chaine3.toString());
	StringBuffer chaine30 = new StringBuffer();
	chaine30.append("le résultat de la multiplication est : ");
	chaine30.append(x * y);
	System.out.println(chaine30.toString()); 
	
	//Afficher la division des chiffres

	StringBuffer chaine4 = new StringBuffer();
	chaine4.append("le résultat de la division est : ");
	chaine4.append(j/i);
	System.out.println(chaine4.toString());
	StringBuffer chaine40 = new StringBuffer();
	chaine40.append("le résultat de la division est : ");
	chaine40.append(x/y);
	System.out.println(chaine40.toString()); 
	
	//Afficher le reste des division

	StringBuffer chaine5 = new StringBuffer();
	chaine5.append("le reste de la division est : ");
	chaine5.append(j%i);
	System.out.println(chaine5.toString());
	StringBuffer chaine50 = new StringBuffer();
	chaine50.append("le reste de la division est : ");
	chaine50.append(x%y);
	System.out.println(chaine50.toString()); 
	
	}
}

        

Manipulation des boucles et expression : 
    
    Tri d'un tableau d'entier : 
    
     

public class TriDemo {
    public static void main(String[] args) {
    //Déclarer un tableau d'entier initialiser avec les valeurs sauivantes :
    	32, 87, 3, 589, 12, 1076, 2000, 8 622, 127
		
        for (int i = tableauEntier.length; --i >= 0; ) {
            //Créer une boucle qui va inverser les valeurs
            pour j=0 et j<i
            	si tableau[j]>tableau[j+1] alors
            		sauvegarder la valeur de tableau de j
            		affecter à tableau[j] la valeur de tableau[j+1]
            		affecter à tableau[j+1] la sauvegarde
            	finsi
            fin pour
        }
	

	// Créer une boucle qui affiche les valeurs du tableau
	// dans l'ordre
    }
}
        

    
    Corrigé
    
    

package formation.sintaxe;

/**
 * Illustration de l'utilisation des arrays
 * Creation date: (31/10/2002 14:59:17)
 * @author: Administrator
 */
public class TriDemo {
/**
 * Constructeur de la classe TriDemo 
 */
public TriDemo() {
	super();
}
/**
 * Méthode principale
 * Creation date: (31/10/2002 14:59:38)
 * @param args java.lang.String[]
 */
public static void main(String[] args) {
	
	// Déclaration d'un tableau d'entier initialiser avec les valeurs suivantes

	int tabNombre[] = {32,87,3,589,12,1076,2000,8622,127};
	
	for (int i = tabNombre.length - 1;i>=0;--i){
		
		//Créer une boucle qui va inverser les valeurs
		for (int j=0;j<i;j++){
			if (tabNombre[j]>tabNombre[i]){
				int sauve = tabNombre[j];
				tabNombre[j] = tabNombre[j+1];
				tabNombre[j+1]= sauve;				
			}//end if
		}//end for
	}//end for

	//Créer une boucle qui affiche les valeur du tableau dans l'ordre
	for (int i=0;i<tabNombre.length;i++){
		StringBuffer chaine1 = new StringBuffer();
		chaine1.append("le résultat est :" );
		chaine1.append(tabNombre[i]);
		System.out.println(chaine1.toString());
	}//end for	

}//end main
}

        

Manipulation des boucles et expression : 
    
    Tri d'un tableau d'entier : 
    
     

public class WhileDemo {
    public static void main(String[] args) {

        String source = "Copier la chaine jusqu'a rencontrer la lettre z.";
        StringBuffer cible = new StringBuffer();
		
		//Créer une boucle while pour copier
		// la chaine source dans le StrinBuffer cible
		
		//Afficher le contenu de cible après la copie
    }
}
        

    
    Corrigé
    
    

package formation.sintaxe;

/**
 * Illustration de la boucle while
 * Creation date: (31/10/2002 16:10:14)
 * 
 */
public class WhileDemo {
/**
 * Constructeur de la classe WhileDemo .
 */
public WhileDemo() {
	super();
}
/**
 * Méthode principale
 * Creation date: (31/10/2002 16:11:04)
 * @param args java.lang.String[]
 */
public static void main(String[] args) {
	String source = "Copier la chaine jusqu'a rencontrer la chaine z.";
	StringBuffer cible = new StringBuffer();

	// Créer une boucle while pour copier la chaine source dans le StringBuffer cible
	int i = 0;
	char chaine=source.charAt(i);
	while(chaine!='z'){	
		cible.append(chaine);
		chaine=source.charAt(++i);
		}

		// Afficher le contenu de cible après la copie
		System.out.println(cible.toString());
	}
}
   

Manipulation des boucles et expression : 
    
    Exemple d'utilisation de l'instruction switch 
    Affichage du nombre de jour d'un mois : 
    
     

public class SwitchDemo2 {
    public static void main(String[] args) {
	if(args.length<2){
		System.out.println("Argument obligatoire");
	}else{
		//Transformer les arguments chaînes en entier
		// Argument 0 = mois
		// Argument 1 = annee

		int nombreJours = 0;
		//Initialiser la variable nombre de jour en fonction du mois.
		//avec l'instruction switch

		//affichage du résultat
        System.out.println("Nombre de jour = " + nombreJours);
    }
}
        

 
       
    Corrigé
    
    

public class SwitchDemo2 {
    public static void main(String[] args) {
	if(args.length<2){
		System.out.println("Argument obligatoire");
	}else{
        Integer m = new Integer(args[0]);
        int mois = m.intValue();
        Integer a = new Integer(args[1]);
        int annee = a.intValue();
		int nombreJours = 0;
		
        switch (mois) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                nombreJours = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                nombreJours = 30;
                break;
            case 2:
                if ( ((annee % 4 == 0) && !(annee % 100 == 0))
                     || (annee % 400 == 0) )
                    nombreJours = 29;
                else
                    nombreJours = 28;
                break;
        }
        System.out.println("Nombre de jour = " + nombreJours);
    }
}

Manipulation de fichier :  (Package java.io.*)
    La gestion d'un fichier se fait à l'aide de plusieurs classes : 
    	- File : classe permettant l'ouverture ou la création d'un fichier ou d'un répertoire
    	- FileReader : classe permettant de lire un fichier
    	- FileWriter : classe permettant d'écrire dans un fichier
    	
    	Méthode de la classe File : 
    		- canRead() : Indique le droit de lire le fichier
    		- canWrite() : Indique le droit d'écrire le fichier
    		- createNewFile() : Crée un nouveau fichier
    		- delete() : supprime un fichier ou un répertoire
    		- exist()( : indique si le fichier existe
    		- getPath() : Retourne le chemin du fichier
    		- isDirectory() : vrai si répertoire
    		- isFile() : vrai si fichier
    		- length() : Retourne la longueur du fichier
    		- list() : liste les fichiers et répertoires du répertoire
    		- list(FileNameFilter) : Liste les fichiers et répertoires qui 
    		correspondent au filtre
    		- listFiles() : liste les fichiers du répertoire
    		- mkdir() : crée un répertoire
    		- renameTo() : Renomme le fichier
    		- setReadonly() : rend le fichier non modifiable
    	
    	Méthode de la classe FileReader : 
    		- read() : Lit un caractère du fichier

    	Méthode de la classe FileWriter : 
    		- write() : Lit un caractère du fichier
    		
  Exemple :   	

package formation.exercise
        import java.io.*;
        public class Copy {
    public static void main(String[] args) throws IOException {
	File inputFile = new File("entree.txt");
	File outputFile = new File("sortie.txt");

        FileReader in = new FileReader(inputFile);
        FileWriter out = new FileWriter(outputFile);
        
        int c = in.read;

        while (c != -1){
           out.write(c);
           c = in.read();
	}
	//fermeture des fichiers
        in.close();
        out.close();
    }
}

    
Autre méthode d'accès aux fichiers : 
	Utilisation des classes BufferedWriter et BufferedReader
	Ces classes permettent d'écrire et de lire des lignes complètes 
	dans un fichiers texte.
	
	Instanciation des classes : 
		File inputFile = new File("essai.txt"); 
		FileReader in = new FileReader(inputFile );
		BufferedReader br = new BufferedReader(in);

		File outputFile = new File("sortie.txt"); 
		FileWriter out = new FileWriter(outputFile);
		BufferedWriter br = new BufferedWriter(out);
		
	Exemple
    
    

package formation.exercise
        import java.io.*;
        public class Copy {
    public static void main(String[] args) throws IOException {
    	//Ecrire le programme de copie d'un fichier
    	//avec les classes BufferedWriter et BufferedReader.
    }
}

Corrigé

package formation.exercise
        import java.io.*;
        public class Copy {
    public static void main(String[] args) throws IOException {
	File inputFile = new File("entree.txt");
	File outputFile = new File("sortie.txt");

        FileReader in = new FileReader(inputFile);
        FileWriter out = new FileWriter(outputFile);
        
        BufferedReader br = new BufferedReader(in);
        BufferedWriter bw = new BufferedWriter(out);
        
        String ligne;
		ligne = br.readLine();
        while (ligne != null){
           bw.write(ligne);
           bw.newLine();
           ligne = br.readLine();
        }
        
        //Fermeture des fichiers
		br.close();
		bw.close();
        in.close();
        out.close();
    }
}

Formatage des numériques : 
    Les numériques sont représentés par 9 classes : 
    
    

Les numériques peuvent être formatés par la classe NumberFormat.
    Exemple de formatage du numérique 49247.65 
    	Français : 49 247,65
    	Allemand : 49.247,65
    	Anglais  : 49,247.65
    
    Méthode de la classe NumberFormat : 
    	- getNumberInstance() : Retourne un formateur de numérique
    	- getCurrencyInstance() : Retourne un formateur monétaire
    	- getPercentInstance() : Retourne un formateur de pourcentage
    	- format(double) : Retourne une chaîne avec le nombre formaté
    	 en fonction de la langue
    	- setMaximumFractionDigits(int) : Affecte le nombre max de décimale
    	- setMinimumFractionDigits(int) : Affecte le nombre min de décimale
    	- parse(String) : Convertit une chaîne en numérique
    
    Classe Locale :
    	Afin de pouvoir internationaliser vos applications, Java dispose d'une
    	classe permettant de préciser la langue dans laquelle vous voulez travailler.
    	La définition d'une langue se fait avec deux arguments : 
    		- Langue
    		- Région
    	
    	exemple
    		fr_FR : Langue français région France
    		fr_CA : Langue français région Canada

Pour illustrer l'exemple ci-dessous, nous allons utiliser une classe abstraite.
   Une classe abstraite permet d'utiliser ses méthodes sans avoir été instanciée.
   Pour qu'une classe soit abstraite, le modificateur d'accès doit être abstract
   Exemple
	public abstract class MaClasseStatic{}
   

package formation.sintaxe;

import java.util.*;
import java.text.*;

public class NumberFormatDemo {
   
/**
 * NumberFormatDemo constructor comment.
 */
public NumberFormatDemo() {
	super();
}
static public void displayCurrency(Locale currentLocale) {

    Double currency = new Double(9876543.21);
    NumberFormat currencyFormatter;
    String currencyOut;
	//Obtention d'une instance d'une classe de formattage de monétaire
    currencyFormatter = NumberFormat.getCurrencyInstance(currentLocale);
    currencyOut = currencyFormatter.format(currency);
    System.out.println(currencyOut + "   " + currentLocale.toString());
}
static public void displayNumber(Locale currentLocale) {

    Integer quantity = new Integer(123456);
    Double amount = new Double(345987.246);
    NumberFormat numberFormatter;
    String quantityOut;
    String amountOut;

    //Obtention d'une instance d'une classe de formattage de numérique
    numberFormatter = NumberFormat.getNumberInstance(currentLocale);
    quantityOut = numberFormatter.format(quantity);
    amountOut = numberFormatter.format(amount);
    System.out.println(quantityOut + "   " + currentLocale.toString());
    System.out.println(amountOut + "   " + currentLocale.toString());
}
static public void displayPercent(Locale currentLocale) {

    Double percent = new Double(0.75);
    NumberFormat percentFormatter;
    String percentOut;
	//Obtention d'une instance d'une classe de formattage de pourcentage
    percentFormatter = NumberFormat.getPercentInstance(currentLocale);
    percentOut = percentFormatter.format(percent);
    System.out.println(percentOut + "   " + currentLocale.toString());
}
static public void main(String[] args) {

    Locale[] locales =
        { new Locale("fr", "FR"), new Locale("de", "DE"), new Locale("en", "US")};

    for (int i = 0; i < locales.length; i++) {
        System.out.println();
        displayNumber(locales[i]);
        displayCurrency(locales[i]);
        displayPercent(locales[i]);
    }
}
}

Gestion et Formatage des dates : 
    La gestion des dates en java est représentée par 2 classes : 
    	- Date (package java.util) : 
    		Représentation d'un instant donné en date et heure.
    		La classe Date contient un certain nombres de méthodes qui permettent 
    		de manipuler les dates. Cependant ces méthodes sont dépréciées.
    		Pour obtenir la date et heure du jour il suffit d'instancier la classe : 
    		Date dateJour = new Date();
    	- GregorianCalendar (package java.util) : Classe permettant la manipulation 
    		des dates. Cette classe hérite de la classe Calendar qui est abstraite.
    		La classe Calendar contient un certain nombre de constantes : 
    			- MONTH
    			- DAY
    			- DAY_OF_MONTH
    			- DAY_OF_WEEK
    			- HOUR_OF_DAY
    			- MINUTE
    		Ces constantes permettent à la classe GregorianCalendar d'effectuer
    		des traitements comme ajouter la valeur 3 à une date donnée
    		pour la constante MINUTE ou DAY ou ...
    
    	
    Méthodes de la classe GregorianCalendar : 
    	- add (int field, int nombre)  : Ajoute le paramètre nombre à un mois ou 
    		une heure ou ...
    	- after (Object when) boolean : Compare deux dates
    	- before (Object when) boolean : Compare deux dates
    	- isLeapYear (int year) boolean : indique si l'année est bissextile
    	- computeTime () : Transforme l'heure en millisecondes
    	- set(int field, int value) : Fixe une valeur pour le mois, l'année ...
    	- set(int field) : retourne une valeur pour le mois, l'année ...
    

package formation.exercise;
import java.util.*;

public class DateDemo {
   
   public static void main(String[] args) {
        GregorianCalendar calendar = new GregorianCalendar();
        GregorianCalendar calendar2 = new GregorianCalendar();

        calendar2.set(Calendar.DAY_OF_MONTH, 8);

        System.out.println("Cal1 Année: " + calendar.get(Calendar.YEAR));
        System.out.println("Cal1 Mois: " + calendar.get(Calendar.MONTH));
        System.out.println("Cal1 Jour: " + calendar.get(Calendar.DAY_OF_MONTH));
       
        System.out.println("Cal2 Année: " + calendar2.get(Calendar.YEAR));
        System.out.println("Cal2 Mois: " + calendar2.get(Calendar.MONTH));
        System.out.println("Cal2 Jour: " + calendar2.get(Calendar.DAY_OF_MONTH));
       
        if (calendar.before(calendar2)) {
             System.out.println("Cal1 est supérieur à Cal2");
        }else {
             System.out.println("Cal1 est inférieur à Cal2");
       }//end if
       
        calendar2.add(Calendar.MONTH, 4);
        System.out.println("Cal2 Année: " + calendar2.get(Calendar.YEAR));
        System.out.println("Cal2 Mois: " + calendar2.get(Calendar.MONTH));
        System.out.println("Cal2 Jour: " + calendar2.get(Calendar.DAY_OF_MONTH));
       
        if (calendar.before(calendar2)) {
             System.out.println("Cal1 est supérieur à Cal2");
        }else {
             System.out.println("Cal1 est inférieur à Cal2");
       }//end if
    }//end Main
}//end Date Demo

    
    De la même façon que les numériques, les dates sont formatées de façon différentes
    selon les pays.
    La classe permettant de gérer ce formatage est  : DateFormat (package java.text)
    Cette classe est abstraite.
    
    Méthode de la classe DateFormat : 
    	- getDateInstance() : Retourne un formateur de date
    	- getDateInstance(int style) : Retourne un formateur de date selon le style : 
    		- DEFAULT : 14 nov 03 
    		- SHORT : 14/11/03 
    		- MEDIUM : 14 nov 03 
    		- LONG : 14 novembre 2003 
    		- FULL : jeudi, 14 novembre 2003 
    	- getDateInstance(int style,Locale locale) : Retourne un formateur de date pour 
    		le style et la langue passés en paramètre.
    	- getTimeInstance() : Retourne un formateur d'heures
    	- getTimeInstance(int style) : Retourne un formateur d'heures selon le style : 
    		- DEFAULT : 15:58:45 
    		- SHORT : 15:58 
    		- MEDIUM : 15:58:45 
    		- LONG : 15:58:45 GMT+02:00  
    		- FULL : 15.58:45 Uhr GMT+02:00 
    	- getTimeInstance(int style,Locale locale) : Retourne un formateur d'heures pour 
    		le style et la langue passés en paramètre.
    	- getDateTimeInstance() : Retourne un formateur de date/heure
    	- getDateTimeInstance(int dateStyle, inttimeStyle) : Retourne un formateur de 
    		date/heure selon le style : 
    		- DEFAULT : 14 nov 03 15:58:45
    		- SHORT : 14/11/03 15:58 
    		- MEDIUM : 14 nov 03 15:58:45
    		- LONG : 14 novembre 2003 15:58:45 GMT+02:00
    		- FULL : jeudi, 14 novembre 2003 15.58:45 Uhr GMT+02:00
    	- getDateTimeInstance(int dateStyle,int timeStyle, Locale locale) : Retourne un 
    		formateur de date/heure pour le style et la langue passés en paramètre.
    	- format(Date date) String : retourne une chaîne de caractères formatée.
    
    Il existe une seconde classe permettant de formater les dates selon ses 
    propres format : SimpleDateFormat
    Cette classe, non abstraite, hérite de la classe DateFormat. Elle peut donc
    servir à formater les dates de façon normale ou avec ses propres formats.
    
    Méthode de la classe SimpleDateFormat
    	- SimpleDateFormat(String format) Constructeur avec le format en paramètre
    	- SimpleDateFormat(String format, Locale locale) Constructeur avec le format 
    		et la langue en paramètre
    	- parse(String chaine) Date : Transforme une chaîne en date à condition que 
    		la chaîne respecte le format
    	- format(Date date) String : Transforme une date en chaîne formatée.

    	
    Exercice : 
    

package formation.exercise;
import java.util.*;
import java.text.*;

public class DateFormatDemo {

   static public void afficheDate(Date maDate, Locale currentLocale) {

      String dateResultat;
      DateFormat df;
      
      //Récupérer un formateur de date pour la langue courante
      
      //formater la date passée en paramètre

      //Affichage du résultat
      System.out.println(dateResultat + "   " + currentLocale.toString());
   }

   static public void afficheDate(int style, Locale currentLocale) {

      Date jour;
      String dateResultat;
      DateFormat df;

      //Récupérer un formateur de date pour la langue courante et le style
      
      //Récupération de la date et heure courante
      
      //formater la date

      //Affichage du résultat
      System.out.println(dateResultat + "   " + currentLocale.toString());
   }


   static public void afficheHeure(int style, Locale currentLocale) {

      Date jour = new Date();
      String heureResultat;
      DateFormat df;

      //Récupérer un formateur d'heure pour la langue courante et le style
      
      //Récupération de la date et heure courante
      
      //formater l'heure

      //Affichage du résultat
      System.out.println(heureResultat + "   " + currentLocale.toString());
   }

   static public String convertDateString(Date date, String format) {
		String result;
		//Instancier la classe SimpleDateFormat avec le format passé en paramètre
		
		//Transformer la date en chaîne
		
		return result;
   }

   static public Date convertStringDate(String chaine, String format) {
		Date date = null;
		try {
		  //Instancier la classe SimpleDateFormat avec le format passé en paramètre
		  
		  //Transformer la chaîne en date
		  
		} catch (ParseException e) {
		  System.out.println(e.getMessage());
		}finally {
		  return date;
		}
   }

   static public void main(String[] args) {
	  
     //Appel des méthodes pour affichages du résultat.
     //Création d'un tableau contenant différentes langues
      Locale[] locales = {
          new Locale("fr","FR"),
          new Locale("de","DE"),
          new Locale("en","US")
      };
     
      if(args.length==2){
        String maDate = args[0];
        String monFormat = args[1];
        for (int i = 0; i < locales.length; i++) {
           afficheDate(convertStringDate(maDate,monFormat),locales[i]);
        }//end for

		System.out.println("");
		
        for (int i = 0; i < locales.length; i++) {
          afficheDate(DateFormat.DEFAULT,locales[i]);
          afficheDate(DateFormat.SHORT,locales[i]);
          afficheDate(DateFormat.MEDIUM,locales[i]);
          afficheDate(DateFormat.LONG,locales[i]);
          afficheDate(DateFormat.FULL,locales[i]);
        }//end for

		System.out.println("");

        for (int i = 0; i < locales.length; i++) {
          afficheHeure(DateFormat.DEFAULT,locales[i]);
          afficheHeure(DateFormat.SHORT,locales[i]);
          afficheHeure(DateFormat.MEDIUM,locales[i]);
          afficheHeure(DateFormat.LONG,locales[i]);
          afficheHeure(DateFormat.FULL,locales[i]);
        }//end for
      }else{
      	System.out.println("Usage : Deux paramètres Date et format");
      }
   }
}

    
    corrigé
    

package formation.sintaxe;

import java.util.*;
import java.text.*;

public class DateFormatDemo {

/**
 * DateFormatDemo constructor comment.
 */
public DateFormatDemo() {
	super();
}
   static public void afficheDate(int style, Locale currentLocale) {

      Date jour;
      String dateResultat;
      DateFormat df;

      //Récupérer un formateur de date pour la langue courante et le style
      df = DateFormat.getDateInstance(style, currentLocale);
      //Récupération de la date et heure courante
      jour = new Date();
      //formater la date
      dateResultat = df.format(jour);
      //Affichage du résultat
      System.out.println(dateResultat + "   " + currentLocale.toString());
   }
   static public void afficheDate(Date maDate, Locale currentLocale) {

      String dateResultat;
      DateFormat df;

      //Récupérer un formateur de date pour la langue courante
      df = DateFormat.getDateInstance(DateFormat.DEFAULT, currentLocale);
      //formater la date passée en paramètre
      dateResultat = df.format(maDate);


      System.out.println(dateResultat + "   " + currentLocale.toString());
   }
   static public void afficheHeure(int style, Locale currentLocale) {

      Date jour = new Date();
      String heureResultat;
      DateFormat df;

      //Récupérer un formateur d'heure pour la langue courante et le style
      df = DateFormat.getTimeInstance(style, currentLocale);
      //Récupération de la date et heure courante
      jour = new Date();
      //formater l'heure
      heureResultat = df.format(jour);
      //Affichage du résultat
      System.out.println(heureResultat + "   " + currentLocale.toString());
   }
   static public String convertDateString(Date date, String format) {
		String result;
		//Instancier la classe SimpleDateFormat avec le format passé en paramètre
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		//Transformer la date en chaîne
		result = sdf.format(date);
		return result;
   }
   static public Date convertStringDate(String chaine, String format) {
		Date date = null;
		try {
		  //Instancier la classe SimpleDateFormat avec le format passé en paramètre
		  SimpleDateFormat sdf = new SimpleDateFormat(format);
		  //Transformer la chaîne en date
		  date = sdf.parse(chaine);
		} catch (ParseException e) {
		  System.out.println(e.getMessage());
		}finally {
		  return date;
		}
   }
   static public void main(String[] args) {

     //Appel des méthodes pour affichages du résultat.
     //Création d'un tableau contenant différentes langues
      Locale[] locales = {
          new Locale("fr","FR"),
          new Locale("de","DE"),
          new Locale("en","US")
      };
     
      if(args.length==2){
        String maDate = args[0];
        String monFormat = args[1];
        for (int i = 0; i < locales.length; i++) {
           afficheDate(convertStringDate(maDate,monFormat),locales[i]);
        }//end for

		System.out.println("");
	
        for (int i = 0; i < locales.length; i++) {
          afficheDate(DateFormat.DEFAULT,locales[i]);
          afficheDate(DateFormat.SHORT,locales[i]);
          afficheDate(DateFormat.MEDIUM,locales[i]);
          afficheDate(DateFormat.LONG,locales[i]);
          afficheDate(DateFormat.FULL,locales[i]);
        }//end for

		System.out.println("");

        for (int i = 0; i < locales.length; i++) {
          afficheHeure(DateFormat.DEFAULT,locales[i]);
          afficheHeure(DateFormat.SHORT,locales[i]);
          afficheHeure(DateFormat.MEDIUM,locales[i]);
          afficheHeure(DateFormat.LONG,locales[i]);
          afficheHeure(DateFormat.FULL,locales[i]);
        }//end for
      }else{
      	System.out.println("Usage : Deux paramètres Date et format");
      }
   }
}

Vector, Hashtable et Conversion d'objets: 
    
    Deux classes du package java.util sont particulièrement utiles.
    	- Vector : Permet de stocker un ensemble d'objets dans un tableau. L'accès à ces
    		objets se fait de façon séquentiel.
    	- Hashtable : permet de stocker un ensemble d'objets dans un tableau. L'accès à ces
    		objets se fait de façon directe. Dans une Hashtable, il faut stocker les objets
    		avec une paire clé - objets.
    		
    Exemple : 
    
    	java.util.Vector vec = new Vector();
    	//Ajout d'éléments
    	vec.addElement("Premier");
    	vec.addElement("Second");
    	vec.addElement("Troisième");
    	//retrouve le premier élément
    	vec.elementAt(0);
    	
    	java.util.Hashtable hash = new Hashatble();
    	//Alimentation de la Hashtable
    	hash.put("cle1","Premier");
    	hash.put("cle2","Second");
    	hash.put("cle3","Troisième");
    	//Retrouve l'élément identifié par la clé "cle1"
    	hash.get("cle1");
    	
    Méthode de l'objet Vector : 
    	- addElement(Object o) : Ajoute un objet dans le tableau
    	- removeElement(int pos) : Retire l'objet qui est à la position pos dans le tableau
    	- size() : Retourne la taille du tableau
    	- 
    	-
    	-
    	-
    	-

    Méthode de l'objet Hashtable : 
    	- put(Objetc cle, Object o) : Ajoute un objet dans le tableau
    	- get(Objetc cle) Objetc : Retourne l'objet correspondant à la clé
    	- size() : Retourne la taille du tableau
    	- keys() Enumeration : Retourne la liste des clés du tableau
    	- elements() Enumeration : Retourne la liste des éléments du tableau
    	-
    	-
    	-
	
	Classe Enumeration : cette classe permet de parcourir tous les éléments d'une 
	Hastable.
	Méthode : 
		- hasMoreElements() : Retourne un booléen permettant de savoir si la
			liste est finie
		- nextElement() : Retourne le prochain élément dans la liste

Conversion des objets :
	
	Les méthodes des deux classes Vector et Hashtable retournent des classes de type
	Object. Il est possible de stocker tous types de classes, mais il faut pouvoir
	retrouver ces classes.
	Rappel : Toutes les classe héritent de la classe Object.
	
	C'est pourquoi Java propose un mécanisme de conversion d'objets : cast
	
	Exemple :
	 
	java.util.Vector vec = new Vector();
    	//Ajout d'éléments
    	vec.addElement("Premier");
    	vec.addElement("Second");
    	
    	String chaine = (String)vec.elementAt(0);
    	System.out.println(chaine);
    	
	
	Syntaxe : 
		(<nom de la classe>)vec.elementAt(0);
		
	
Exercice : 

package formation.exercise;
import java.util.*;
import java.text.*;

public class Personne {
  private String nom;
  private String prenom;
  private String metier;
  
  public Personne(){
  }
  
  public Personne(String nvNom, String nvPrenom, String nvMetier){
	setNom(nvNom);
	setPrenom(nvPrenom);
	setMetier(nvMetier);
  }
  
  public String getMetier(){
  	return metier;
  }

  public void setMetier(String nvMetier){
  	metier = nvMetier;
  }
  
  public String getNom(){
  	return nom;
  }

  public void setNom(String nvNom){
  	nom = nvNom;
  }
  
  public String getPrenom(){
  	return prenom;
  }

  public void setPrenom(String nvPrenom){
  	prenom = nvPrenom;
  }

}

public class OrganisePersonne{
  
  private Hashtable effectif;
  
  public OrganisePersonne(){
  	effectif = new Hashtable();
  }
  
  public void alimenteEffectif(Vector vec){
    try{
	//Retrouve la longueur du tableau
	int vecLen = vec.size();
	//Parcours du tableau
	for(int i = 0;i<vecLen;i++){
	  //Conversion d'un élément en une classe Vector
	  Vector v = (Vector)vec.elementAt(i);
	  //Conversion d'un élément en une classe String
	  String nom = (String)v.elementAt(0);
	  String prenom = (String)v.elementAt(1);
	  String metier = (String)v.elementAt(2);
	  //Instanciation de la classe personne
	  Personne personne = new Personne(nom, prenom, metier);
	  //Stockage de la classe personne dans l'attribut effectif
	  effectif.put(nom,personne);
	}
    }catch(Exception e){
	e.printStackTrace();
    }
  }  
	
  public int totalEffectif(){
	return effectif.size();
  }
	
  public afficheEffectif(){
    try{
	//Utilisation d'un objet Enumeration pour lister l'effectif
	Enumeration lk = effectif.keys();
	//Parcours des éléments de la liste
	while(lk.hasMoreElements){
	  //Récupération de la valeur de la clé
	  String cle = (String)lk.nextElement();
	  //Récupération de l'objet correspondant à la clé
	  Personne p = (Personne)effectif.get(cle);
	  //Affichage du contenu de la classe Personne
	  StringBuffer strb = new StringBuffer();
	  strb.append("Identité : ");
	  strb.append(p.getNom());
	  strb.append(" ");
	  strb.append(p.getPrenom());
	  strb.append(" ");
	  strb.append(p.getMetier());
	  System.out.println(strb.toString());
	}
    }catch(Exception e){
	System.out.println(e.getMessage);
    }
  }

}

public class convertDemo{

  public static void main(String[] args){
    if(args.length>0&&(args.length%3)==0){
      //Sauvegarde des paramètres dans un vector
      Vector vec = new Vector();
      for(int i=0;i<args.length;i+=3){ 
        Vector v = new Vector(); 
        v.addElement(args[i]); 
        v.addElement(args[i+1]); 
        v.addElement(args[i+2]); 
        vec.addElement(v); 
      }//end for 
      
      OrganisePersonne op = new OrganisePersonne();
      op.alimenteEffectif(vec);
      System.out.println("Nombre de personnes : " + op.totalEffectif());
      System.out.println(op.afficheEffectif());
      
    }else{ 
      System.out.println(Paramètres incorrects); 
    } 
  } 
} 

Appel du programme : 

java convertDemo Pierre Aubance oenologue Jacques Petrus viticulteur Patrick Leffe Brasseur