Retour au menuLe package java.util est un package "fourre-tout" qui contient des classes utiles pour la résolution de certains problèmes.
Le constructeur de cette classe peut prendre les formes Date( ), Date(long
date), Date(int year, int month, int date), Date(int year, int month, int date,
int hrs, int min), Date(int year, int month, int date, int hrs, int min, int
sec) et Date(String s). Dans ce dernier cas, la chaîne est de la forme
"day, date month year hrs:min:sec GMT" dans laquelle day est le nom
du jour sous la forme Mon, Tue, Wed, Thu, Fri, Sat ou Sun. Dans les versions
1.0.x, les dates démarrent le 1 janvier 1970.
La version Date( ) correspond
à la date courante. Dans la version Date(long date), date correspond au nombre
de millisecondes écoulées entre le 1-01-1970 minuit et la date à définir. Les
méthodes les plus utiles sont getTime( ) qui retourne un long correspond
au nombre de millisecondes écoulées entre le 1-01-1970 et la date utilisée, getDate(
) qui retourne un int correspondant à la date du jour, getDay( ) qui retourne
le jour, getMonth( ), getYear( ), getHours( ), getMinutes( ).
Les méthodes
set correspondantes permettent de fixer les mêmes paramètres d'une date donnée.
Une
originalité : les mois vont de 0 (janvier) à 11 (décembre).
L'exemple
ci-dessous met en oeuvre un certain nombre de ce méthodes. On demande à l'utilisateur
d'entrer sa date de naissance et on retourne son age.
import java.applet.*;
import java.awt.*;
import java.util.*;
//importation du package
public class date10 extends Applet
{ int jour=15,mois=8,annee=70;
//valeurs initiales
Font font = new Font("Helvetica",0,12);
Label lb1,lb2,lb3;
TextField tf1=new TextField(""+jour,2);
TextField tf2=new TextField(""+(mois-1),2);
TextField tf3=new TextField(""+annee,2);
Date D = new Date();
//date actuelle du client
String s;
public void init()
{ setBackground(Color.lightGray);
setFont(font);
lb1=new
Label("Jour",2);
add(lb1); add(tf1);
lb2=new
Label("Mois",2);
add(lb2); add(tf2);
lb3=new
Label("Année",2);
add(lb3); add(tf3);}
public boolean action(Event
evt, Object arg)
{ if
(evt.target==tf1) {
s=tf1.getText(); jour=Integer.parseInt(s);}
else
if (evt.target==tf2) {
s=tf2.getText(); mois=Integer.parseInt(s)-1;}//0
à 11 !!!
else
if (evt.target==tf3){
s=tf3.getText(); annee=Integer.parseInt(s);}
else
return super.action(evt,arg);
repaint(); return
true;}
public void paint(Graphics
g)
{ g.drawString("Nous
sommes le : "+D,20,50);
g.drawString("Entrer
votre date de naissance :",20,70);
Date
Dnai = new Date(annee,mois,jour);
g.drawString("né(e)
le : "+Dnai.toString(),20,90);
Date
Dage = new Date((long)(D.getTime()-Dnai.getTime()));
s
= "Vous avez "+(Dage.getYear()-70)+" ans, "; //origine
1970
s
= s+Dage.getMonth()+" mois et ";
s
= s+(Dage.getDate()-1)+" jours.";
g.drawString(s,20,110);
g.drawString(""+D.getTime()+"
ms écoulées depuis le 01/01/1970 minuit",20,130);
}
Valider chaque saisie.
Cette classe permet de découper une chaîne de caractères
en fonction de séparateurs (virgule, espace ...). Les utilisateurs des anciens
BASIC retrouvent avec cette classe l'équivalent des instructions DATA.
Le
constructeur StringTokenizer(String s, String sep) comporte deux paramètres
: la chaîne s à découper et sep qui est une chaîne
contenant les séparateurs à utiliser pour le découpage en éléments.
La méthode
hasMoreTokens( ) retourne true tant que la chaîne s contient
des éléments à découper. La méthode nextToken( ) retourne une chaîne
qui contient l'élément en question. On utilise en général (comme dans l'exemple
ci-dessous) une boucle while pour décomposer la chaîne s en ses différents éléments.
import
java.applet.*;
import java.awt.*;
import java.util.*; //importer
le package
public
class version extends Applet
{ String s="10,15,24,36,,78;47,26
38,45,9";//chaîne
à découper
int
Tab[] = new int[10]; //tableau
des valeurs
public
void paint(Graphics g)
{ int i=0;
StringTokenizer st
=new StringTokenizer(s,"; ,");//3
séparateurs
; , et blanc
while
(st.hasMoreTokens()){ //boucle
de lecture
Tab[i]=Integer.parseInt(st.nextToken());
//éléments du tableau
g.drawString(""+Tab[i],20,20+15*i);
i++;}}
}
Remarques
a) dans l'exemple ci-dessus, il serait bien plus simple
de procéder directement à l'affectation du tableau au moyen de l'instruction
:
Tab[] = {10,15,24,36,78,47,26,38,45,9};
b) noter que la seconde virgule
entre 36 et 78 sera ignorée.
Cette classe permet de générer des nombres pseudo-aléatoires de façon plus
complète que la méthode Math.random( ) de java.lang qui à chaque appel renvoie
un double compris entre 0.0d et 1.0d .
Après appel du constructeur Random
rnd = new Random( ); , il suffit d'utiliser la méthode qui correspond
au type de nombre aléatoire que l'on désire obtenir.
rnd.nextInt( )
retourne un entier int compris entre Integer.MIN_VALUE (-2147488348) et Integer.MAX_VALUE
(2147488347).
rnd.nextLong( ) retourne un entier long compris entre
Long.MIN_VALUE et Long.MAX_VALUE.
rnd.nextDouble( ) et rnd.nextFloat(
) retournent un double ou un float compris entre 0 et 1.
rnd.nextGaussian(
) retourne un double avec une distribution gaussienne de moyenne 0.0
et de déviation 1.0.
Enfin la méthode setSeed(long seed) permet de
fixer la valeur de la "graine" utilisée par le générateur pseudo-aléatoire.
En fixant la valeur de la graine, on obtient toujours la même séquence de valeurs
pseudo-aléatoires lors d'exécutions successives du programme.
La classe Vector permet de créer et de manipuler des tableaux d'objets
dynamiques. La dimension du tableau peut en effet varier automatiquement
quand on y insère de nouveaux éléments. Pour des raisons d'efficacité,
il est conseillé d'accroître sa taille avant l'ajout d'un nombre important d'éléments
afin de limiter les réallocations mémoire au minimum. Il n'y a pas de restrictions
sur la nature des objets (on peut même mélanger des objets différents dans un Vector).
Les
constructeurs sont Vector( ) qui crée un tableau vide de dimension nulle,
Vector(int nb) qui crée un tableau vide de dimension nb et Vector(int
nb, int inc) qui crée un tableau vide de dimension nb et dont la taille
augmente de inc à chaque fois que la taille maximum est atteinte.
Il n'est pas possible de stocker de nombres dans un vecteur mais il est possible
de stocker des instances des classes Integer, Double ... car ce sont des objets.
Les principales méthodes de cette classe sont :
addElement(Object obj)
ajoute un élément à la fin de la liste.
capacity(int nb) retourne la taille
actuelle.
contains(Object obj) retourne un booléen indiquant la présence
ou l'absence de l'objet obj dans le Vector.
elementAt(int index) retourne
l'élément situé à la place index.
indexOf(Object obj) donne l'index
de l'objet obj.
insertElementAt(Object obj, int index) insert l'objet obj à
la place index. Les éléments suivants l'index sont décalés vers le bas.
setElementAt(Object
obj, int index) modifie l'objet à la place index.
removeElementAt(int index)
supprime l'objet situé à index. Les éléments suivants l'index sont décalés vers
le haut.
setSize(int nb) fixe la taille actuelle.
De la classe Vector dérive la classe Stack qui implémente une pile d'objets. La méthode push( ) place un objet sur le haut de la pile, pop( ) supprime l'objet situé sur le haut de la pile et la méthode peek( ) retourne l'objet situé sur le haut de la pile sans l'enlever.
Cette classe implémente une structure qui à chaque donnée associe une
clé. C'est un tableau d'objets qui stocke ceux-ci avec des
indices non numériques.
Les
constructeurs sont Hashtable( ) qui crée une table vide de dimension nulle,
Hashtable(int nb) qui crée une table vide de dimension nb et Hashtable(int
nb, float inc) qui crée une table vide de dimension nb et dont la taille
augmente quand le nombre d'éléments de la table dépasse le produit nb*inc. (inc
doit être compris entre 0.0f et 1.0f).
Les principales méthodes de cette classe sont :
put(Object key, Object
data) ajoute un élément et sa clé à la table.
get(Object key)
retourne l'élément de la table dont la clé est key.
remove(Object key) supprime
l'élément de la table dont la clé est key.
Retour au menu