Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :


Chapitre 5 : La bibliothèque de classes java

13/10/2002

Par Jean-Michel Doudoux (autres articles)
 


5. La bibliothèque de classes java
5.1. Présentation du package java.lang
5.1.1. La classe Object
5.1.1.1. La méthode getClass()
5.1.1.2. La méthode toString()
5.1.1.3. La méthode equals()
5.1.1.4. La méthode finalize()
5.1.1.5. La méthode clone()
5.1.2. La classe String
5.1.3. La classe StringBuffer
5.1.4. Les wrappers
5.1.5. La classe System
5.1.5.1. L'utilisation des flux d'entrée/sortie standard
5.1.5.2. Les variables d'environnement et les propriétés du système
5.1.6. La classe Runtime
5.2. Présentation rapide du package awt java
5.2.1. Le package java.image
5.2.2. Le package java.awt.perr
5.3. Présentation rapide du package java.io
5.4. Le package java.util
5.4.1. La classe StringTokenizer
5.4.2. La classe Random
5.4.3. Les classes Date et Calendar
5.4.4. La classe Vector
5.4.5. La classe Hashtable
5.4.6. L'interface Enumeration
5.4.7. Les expressions régulières
5.4.7.1. Les motifs
5.4.7.2. La classe Pattern
5.4.7.3. La classe Matcher
5.5. Présentation rapide du package java.net
5.6. Présentation rapide du package java.applet


5. La bibliothèque de classes java


Dans la version 1.0, le JDK contient 8 packages chacun étant constitués par un ensemble de classes qui couvrent un même domaine et apportent de nombreuses fonctionnalités. Les différentes versions du JDK sont constamment enrichis de packetages :

Packages JDK JDK 1.0 JDK 1.1 JDK 1.2 JDK 1.3 JDK 1.4 Role
java.applet X X X X X développement des applets
java.awt X X X X X toolkit pour interfaces graphiques
java.awt.color     X X X gérer et utiliser les couleurs
java.awt.datatransfer   X X X X échanger des données via le presse-papier
java.awt.dnd     X X X gérer le cliquer/glisser
java.awt.event   X X X X gérer les évenements utilisateurs
java.awt.font     X X X utiliser les fontes
java.awt.geom     X X X dessiner des formes géométiques
java.awt.im       X X  
java.awt.im.spi       X X  
java.awt.image   X X X X afficher des images
java.awt.image.renderable     X X X modifier le rendu des images
java.awt.print     X X X réaliser des impressions
java.beans   X X X X développer des composants réutilisables
java.beans.beancontext     X X X  
java.io X X X X X gérer les flux
java.lang X X X X X classes de base du langage
java.lang.ref     X X X  
java.lang.reflect   X X X X utiliser la réflexion (introspection)
java.math   X X X X utiliser des opérations mathématiques
java.net X X X X X utiliser les fonctionnalités réseaux
java.nio         X  
java.nio.channels         X  
java.nio.channels.spi         X  
java.nio.charset         X  
java.nio.charset.spi         X  
java.rmi   X X X X développement d'objets distribués
java.rmi.activation     X X X  
java.rmi.dgc   X X X X  
java.rmi.registry   X X X X  
java.rmi.server   X X X X gérer les objets serveurs de RMI
java.security   X X X X gérer la signature et la certification
java.security.acl   X X X X  
java.security.cert   X X X X  
java.security.interfaces   X X X X  
java.security.spec     X X X  
java.sql   X X X X JDBC pour l'accès aux bases de données
java.text   X X X X formatter des objets en texte
java.util X X X X X utilitaires divers
java.util.jar     X X X gérer les fichiers jar
java.util.logging         X utiliser les logs
java.util.prefs         X gérer les préférences
java.util.regex         X utiliser les expressions régulières
java.util.zip   X X X X gérer les fichiers zip
javax.accessibility     X X X  
javax.crypto         X utiliser le cryptage des données
javax.crypto.interfaces         X  
javax.crypto.spec         X  
javax.imageio         X  
javax.imageio.event         X  
javax.imageio.metadata         X  
javax.imageio.plugins.jpeg         X  
javax.imageio.spi         X  
javax.imageio.stream         X  
javax.naming       X X  
javax.naming.directory       X X  
javax.naming.event       X X  
javax.naming.ldap       X X  
javax.naming.spi       X X  
javax.net         X  
javax.net.ssl         X utiliser une connexion reseau securisé avec SSL
javax.print         X  
javax.print.attribute         X  
javax.print.attribute.standard         X  
javax.print.event         X  
javax.rmi       X X  
javax.rmi.CORBA       X X  
javax.security.auth         X API JAAS pour l'authentification et l'autorisation
javax.security.auth.callback         X  
javax.security.auth.kerberos         X  
javax.security.auth.login         X  
javax.security.auth.spi         X  
javax.security.auth.x500         X  
javax.security.cert         X  
javax.sound.midi       X X  
javax.sound.midi.spi       X X  
javax.sound.sampled       X X  
javax.sound.sampled.spi       X X  
javax.sql         X  
javax.swing     X X X Swing pour développer des interfaces graphiques
javax.swing.border     X X X gérer les bordures des composants Swing
javax.swing.colorchooser     X X X composant pour sélectionner une couleur
javax.swing.event     X X X gérer des évenements utilisateur des composants Swing
javax.swing.filechooser     X X X composant pour sélectionner un fichier
javax.swing.plaf     X X X gérer l'aspect des composants Swing
javax.swing.plaf.basic     X X X  
javax.swing.plaf.metal     X X X gérer l'aspect metal des composants Swing
javax.swing.plaf.multi     X X X  
javax.swing.table     X X X  
javax.swing.text     X X X  
javax.swing.text.html     X X X  
javax.swing.text.html.parser     X X X  
javax.swing.text.rtf     X X X  
javax.swing.tree     X X X gérer un composant JTree
javax.swing.undo     X X X gérer les annulations d'opérations d'édition
javax.transaction       X X  
javax.transaction.xa         X  
javax.xml.parser         X API JAXP pout utiliser XML
javax.xml.transform         X transformer un document XML avec XSLT
javax.xml.transform.dom         X  
javax.xml.transform.sax         X  
javax.xml.transform.stream         X  
org.ietf.jgss         X  
org.omg.CORBA     X X X  
org.omg.CORBA_2_3       X X  
org.omg.CORBA_2_3.portable       X X  
org.omg.CORBA.DynAnyPackage     X X X  
org.omg.CORBA.ORBPackage     X X X  
org.omg.CORBA.portable     X X X  
org.omg.CORBA.TypeCodePackage     X X X  
org.omg.CosNaming     X X X  
org.omg.CosNaming.NamingContextExtPackage     X X X  
org.omg.CosNaming.NamingContextPackage         X  
org.omg.Dynamic         X  
org.omg.DynamicAny         X  
org.omg.DynamicAny.DynAnyFactoryPackage         X  
org.omg.DynamicAny.DynAnyPackage         X  
org.omg.IOP         X  
org.omg.IOP.CodecFactoryPackage         X  
org.omg.IOP.CodecPackage         X  
org.omg.Messaging         X  
org.omg.PortableInterceptor         X  
org.omg.PortableInterceptor.ORBInitInfoPackage         X  
org.omg.PortableServer         X  
org.omg.PortableServer.CurrentPackage         X  
org.omg.PortableServer.POAPackage         X  
org.omg.PortableServer.ServantLocatorPackage         X  
org.omg.PortableServer.portable         X  
org.omg.SendingContext       X X  
org.omg.stub.java.rmi       X X  
org.w3c.dom         X utiliser DOM pour un document XML
org.xml.sax         X utiliser SAX pour un document XML
org.xml.sax.ext         X  
org.xml.sax.helpers         X  
Ce chapitre contient les sections suivantes :


5.1. Présentation du package java.lang


Ce package de base contient les classes fondamentales tel que Object, Class, Math, System, String, StringBuffer, Thread, les wrapper etc ...

La classe Math est détaillée dans le chapitre "les fonctions mathématiques".

La classe Class est détaillée dans le chapitre "la gestion dynamique des objets et l'introspection".

La classe Thread est détaillée dans le chapitre "le multitâche".

Il contient également plusieurs classes qui permettent de demander des actions au système d'exploitation sur laquelle la machine virtuelle tourne, par exemple ClassLoader, Runtime, SecurityManager.

Ce package est implicitement importé dans tous les fichiers sources par le compilateur.


5.1.1. La classe Object


C'est la super classe de toutes les classes Java : toutes ces méthodes sont donc héritées par toutes les classes.


5.1.1.1. La méthode getClass()


La méthode getClass() renvoie un objet de la classe Class qui représente la classe de l'objet.

Le code suivant permet de connaitre le nom de la classe de l'objet

Exemple :
String nomClasse = monObject.getClass().getName();

5.1.1.2. La méthode toString()


La méthode toString() de la classe Object renvoie le nom de la classe , suivi du séparateur @, lui même suivi par la valeur de hachage de l'objet


5.1.1.3. La méthode equals()


La méthode equals() implémente une comparaison par défaut. Sa définition dans Object compare les références : donc obj1.equals(obj2) ne renverra true que si obj1 et obj2 désignent le même objet. Dans une sous classe de Object, pour laquelle on a besoin de pouvoir dire que deux objets distincts peuvent être égaux, il faut redéfinir la méthode equals héritée de Object.


5.1.1.4. La méthode finalize()


A l'inverse de nombreux langage orienté objet tel que le C++ ou Delphi, le programmeur Java n'a pas à se préoccuper de la destruction des objets qu'il instancie. Ceux-ci sont détruits et leur emplacement mémoire est récupéré par le ramasse miette de la machine virtuelle dès qu'il n'y a plus de référence sur l'objet.

La machine virtuelle garantit que toutes les ressources Java sont correctement libérées mais, quand un objet encapsule une ressource indépendante de Java (comme un fichier par exemple), il peut être préférable de s'assurer que la ressource sera libérée quand l'objet sera détruit. Pour cela, la classe Object définit la méthode protected finalize, qui est appelée quand le ramasse miettes doit récupérer l'emplacement de l'objet ou quand la machine virtuelle termine son exécution

Exemple :
import java.io.*; public class AccesFichier { private FileWriter fichier; public AccesFichier(String s) { try { fichier = new FileWriter(s); } catch (IOException e) { System.out.println("Impossible d'ouvrir le fichier <"); } } protected void finalize() throws Throwable { super.finalize(); // obligatoire : appel finalize heritee System.out.println("Appel de la méthode finalize"); termine(); } public static void main(String[] args) { AccesFichier af = new AccesFichier("c:\test"); System.exit(0); } public void termine() { if (fichier != null) { try { fichier.close(); } catch (IOException e) { System.out.println("Impossible de fermer le fichier"); } fichier = null; } } }

5.1.1.5. La méthode clone()


Si x désigne un objet obj1, l'exécution de x.clone() renvoie un second objet obj2, qui est une copie de obj1 : si obj1 est ensuite modifié, obj2 n'est pas affecté par ce changement.

Par défaut, la méthode clone(), héritée de Object fait une copie variable par variable : elle offre donc un comportement acceptable pour de très nombreuses sous classe de Object. Cependant comme le processus de duplication peut être délicat à gérer pour certaines classes (par exemple des objets de la classe Container), l'héritage de clone ne suffit pas pour qu'une classe supporte le clonage.

Pour permettre le clonage d'une classe, il faut implémenter dans la classe l'interface Cloneable.

La première chose que fait la méthode clone() de la classe Object, quand elle est appelée, est de tester si la classe implémente Cloneable. Si ce n'est pas le cas, elle lève l'exception CloneNotSupportedException.


5.1.2. La classe String


Une chaine de caractères est contenue dans un objet de la classe String

On peut initialiser une variable String sans appeler explicitement un contructeur : le compilateur se charge de créer un objet.

Exemple : deux déclarations de chaines identiques.
String uneChaine = «bonjour»; String uneChaine = new String(«bonjour»);
Les objets de cette classe ont la particularité d'être constants. Chaque traitement qui vise à transformer un objet de la classe est implémenté par une méthode qui laisse l'objet d'origine inchangé et renvoie un nouvel objet String contenant les modifications.

Exemple :
private String uneChaine; void miseEnMajuscule(String chaine) { uneChaine = chaine.toUpperCase() }
Il est ainsi possible d'enchainer plusieurs méthodes :

Exemple :
uneChaine = chaine.toUpperCase().trim();
L'opérateur + permet la concatenation de chaines de caractères.

La comparaison de deux chaine doit se faire via la méthode equals() qui compare les objets eux même et non l'opérateur == qui compare les réferences de ces objets :

Exemple :
String nom1 = new String("Bonjour"); String nom2 = new String("Bonjour"); System.out.println(nom1 == nom2); // affiche false System.out.println( nom1.equals(nom2)); // affiche true
Cependant dans un soucis d'efficacité, le compilateur ne duplique pas 2 constantes chaines de caractères : il optimise l'espace mémoire utilisé en utilisant le même objet.
Cependant, l'appel explicite du constructeur ordonne au compilateur de créer un nouvel objet

Exemple :
String nom1 = «Bonjour»; String nom2 = «Bonjour»; String nom3 = new String(«Bonjour»); System.out.println(nom1 == nom2); // affiche true System.out.println(nom1 == nom3); // affiche false
La classe String possède de nombreuses méthodes dont voici les principales :

Méthodes la classe String Rôle
charAt(int) renvoie le nieme caractère de la chaine
compareTo(String) compare la chaine avec l'argument
concat(String) ajoute l'argument à la chaine et renvoie la nouvelle chaine
endsWith(String) vérifie si la chaine se termine par l'argument
equalsIgnoreCase(String) compare la chaine sans tenir compte de la casse
indexOf(String) renvoie la position de début à laquelle l'argument est contenu dans la chaine
lastIndexOf(String) renvoie la dernière position à laquelle l'argument est contenu dans la chaine
lenght() renvoie la longueur de la chaine
replace(char,char) renvoie la chaine dont les occurences d'un caractère ont remplacées
startsWidth(String int) Vérifie si la chaine commence par la sous chaine
substring(int,int) renvoie une partie de la chaine
toLowCase() renvoie la chaine en minuscule
toUpperCase() renvoie la chaine en majuscule
trim() enlève les caractères non significatifs de la chaine

5.1.3. La classe StringBuffer


Les objets de cette classe contiennent des chaines de caractères variables, ce qui permet de les agrandir ou de les réduire. Cette objet peut être utilisé pour construire ou modifier une chaine de caractères chaque fois que l'utilisation de la classe String nécessiterait de nombreuses instanciations d'objets temporaires.

Par exemple, si str est un objet de type String, le compilateur utilisera la classe StringBuffer pour traiter la concaténation de « abcde »+str+« z » en générant le code suivant : new StringBuffer().append(« abcde ».append(str).append(« z »).toString();

Ce traitement aurait pu être réalisé avec trois appels à la méthode concat() de la classe String mais chacun des appels aurait instancié un objet StringBuffer pour réaliser la concaténation, ce qui est couteux en temps exécution

La classe StringBuffer dispose de nombreuses méthodes qui permettent de modifier le contenu de la chaine de caractère

Exemple ( code java 1.1 ) : une méthode uniquement pédagogique
public class MettreMaj { static final String lMaj = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; static final String lMin = "abcdefghijklmnopqrstuvwxyz"; public static void main(java.lang.String[] args) { System.out.println(MetMaj("chaine avec MAJ et des min")); } public static String MetMaj(String s) { StringBuffer sb = new StringBuffer(s); for ( int i = 0; i < sb.length(); i++) { int index = lMin.indexOf(sb.charAt(i)); if (index >=0 ) sb.setCharAt(i,lMaj.charAt(index)); } return sb.toString(); } }
Resultat :
CHAINE AVEC MAJ ET DES MIN

5.1.4. Les wrappers


Les objet de type wrappers (enveloppeurs) représentent des objets qui encapsulent une données de type primitif et qui fournissent un ensemble de méthodes qui permettent notamment de faire de conversions.

Ces classes offrent toutes les services suivants :

  • un constructeur qui permet une instanciation à partir du type primitif et un constructeur qui permet une instanciation à partir d'un objet String
  • une méthode pour fournir la valeur primitive représentée par l'objet
  • une méthode equals() pour la comparaison.

Les méthodes de conversion opèrent sur des instances, mais il est possible d'utiliser des méthodes statiques.

Exemple :
int valeur = Integer.valueOf("999").intValue();
Ces classes ne sont pas interchangeable avec les types primitif d'origine car il s'agit d'objet

Exemple :
Float objetpi = new Float(«3.1415»); System.out.println(5*objetpi); // erreur à la compil
Pour obtenir la valeur contenue dans l'objet, il faut utiliser la méthode typeValue() ou type est le nom du type standard

Exemple :
Integer Entier = new Integer(«10»); int entier = Entier.intValue();
Les classes Integer, Long, Float et Double définissent toutes les constantes MAX_VALUE et MIN_VALUE qui représentent leurs valeurs minimales et maximales.

Lorsque l'on effectue certaines opérations mathématiques sur des nombres à virgules flottantes (float ou double), le résultat peut prendre l'une des valeurs suivantes :

  • NEGATIVE_INFINITY : infini négatif causé par la division d'un nombre négatif par 0.0
  • POSITIVE_INFINITY : infini positif causé par la division d'un nombre positif par 0.0
  • NaN: n'est pas un nombre (Not a Number) causé par la division de 0.0 par 0.0

Il existe des méthodes pour tester le résultat :

Float.isNaN(float); //idem avec double Double.isInfinite(double); // idem avec float
Exemple :
float res = 5.0f / 0.0f; if (Float.isInfinite(res)) { ... };
La constante Float.NaN n'est ni égale à un nombre dont la valeur est NaN ni à elle même. Float.NaN == Float.NaN retourne False

Lors de la division par zéro d'un nombre entier, une exception est levée.

Exemple :
System.out.println(10/0); Exception in thread "main" java.lang.ArithmeticException: / by zero at test9.main(test9.java:6)

5.1.5. La classe System


Cette classe possède de nombreuses fonctionnalités pour utiliser des services du système d'exploitation.


5.1.5.1. L'utilisation des flux d'entrée/sortie standard


La classe System défini trois variables statiques qui permettent d'utiliser les flux d'entrée/sortie standards du système d'exploitation.

Variable Type Rôle
in PrintStream Entrée standard du système. Par défaut, c'est le clavier.
out InputStream Sortie standard du système. Par défaut, c'est le moniteur.
err PrintStream Sortie standard des erreurs du système. Par défaut, c'est le moniteur.
Exemple :
System.out.println("bonjour");
La classe système possède trois méthodes qui permettent de rediriger ces flux.


5.1.5.2. Les variables d'environnement et les propriétés du système


JDK 1.0 propose la méthode statique getEnv() qui renvoie la valeur de la propriété système dont le nom est fourni en paramètre.

Depuis le JDK 1.1, cette méthode est deprecated car elle n'est pas multi-système. Elle est remplacée par un autre mécanisme qui n'interroge pas directement le système mais qui recherche les valeurs dans un ensemble de propriétés. Cet ensemble est consituté de propriétés standard fournies par l'environnement java et par des propriétés ajoutés par l'utilisateur.

Voici une liste non exhaustive des propriétés fournies par l'environnement java :

Nom de la propriété Rôle
java.version Version du JRE
java.vendor Auteur du JRE
java.vendor.url URL de l'auteur
java.home Répertoire d'installation de java
java.vm.version Version de l'implémentation la JVM
java.vm.vendor Auteur de l'implémentation de la JVM
java.vm.name Nom de l'implémentation de la JVM
java.specification.version Version des spécifications de la JVM
java.specification.vendor Auteur des spécifications de la JVM
java.specification.name Nom des spécifications de la JVM
java.ext.dirs Chemin du ou des répertoires d'extension
os.name Nom du système d'exploitation
os.arch Architecture du système d'exploitation
os.version Version du système d'exploitation
file.separator Séparateur de fichiers (exemple : "/" sous Unix, "\" sous Windows)
path.separator Séparateur de chemin (exemple : ":" sous Unix, ";" sous Windows)
line.separator Séparateur de ligne
user.name Nom du user courant
user.home Répertoire d'accueil du user courant
user.dir Répertoire courant au moment de l'initialisation de la propriété
Pour définir ces propres propriétés, il faut utiliser l'option -D de l'interpreteur java en utilisant la ligne de commande.

La méthode statique getProperty() permet d'obtenir la valeur de la propriété dont le nom est fourni en paramètre. Une version surchargée de cette méthode permet de préciser un second paramètre qui contiendra la valeur par défaut, si la propriété n'est pas définie.

Exemple :
public class TestProperty { public static void main(String[] args) { System.out.println("java.version ="+System.getProperty("java.version")); System.out.println("java.vendor ="+System.getProperty("java.vendor")); System.out.println("java.vendor.url ="+System.getProperty("java.vendor.url")); System.out.println("java.home ="+System.getProperty("java.home")); System.out.println("java.vm.specification.version =" +System.getProperty("java.vm.specification.version")); System.out.println("java.vm.specification.vendor =" +System.getProperty("java.vm.specification.vendor")); System.out.println("java.vm.specification.name =" +System.getProperty("java.vm.specification.name")); System.out.println("java.vm.version ="+System.getProperty("java.vm.version")); System.out.println("java.vm.vendor ="+System.getProperty("java.vm.vendor")); System.out.println("java.vm.name ="+System.getProperty("java.vm.name")); System.out.println("java.specification.version =" +System.getProperty("java.specification.version")); System.out.println("java.specification.vendor =" +System.getProperty("java.specification.vendor")); System.out.println("java.specification.name =" +System.getProperty("java.specification.name")); System.out.println("java. +System.getProperty("java.)); System.out.println("java. +System.getProperty("java.)); System.out.println("java.ext.dirs ="+System.getProperty("java.ext.dirs")); System.out.println("os.name ="+System.getProperty("os.name")); System.out.println("os.arch ="+System.getProperty("os.arch")); System.out.println("os.version ="+System.getProperty("os.version")); System.out.println("file.separator ="+System.getProperty("file.separator")); System.out.println("path.separator ="+System.getProperty("path.separator")); System.out.println("line.separator ="+System.getProperty("line.separator")); System.out.println("user.name ="+System.getProperty("user.name")); System.out.println("user.home ="+System.getProperty("user.home")); System.out.println("user.dir ="+System.getProperty("user.dir")); } }
Par défaut, l'accès aux propriétés système est restreint par le SecurityManager pour les applets.


5.1.6. La classe Runtime


La classe Runtime permet d'intéragir avec le système dans lequel l'application s'éxécute : obtenir des informations sur le système, arrêt de la machine virtuelle, éxecution d'un programme externe

Cette classe ne peut pas être instanciée mais il est possible d'obtenir une instance en appelant la méthode statique getRuntime().

La méthode exec() permet d'éxécuter des commandes du système d'exploitation ou s'éxécute la JVM. Elle lance la commande de manière asynchrone et renvoie un objet de type Process pour obtenir des informations sur le processus lancé.

L'inconvénient d'utiliser cette méthode est que la commande executée est dépendante du système d'exploitation.

La suite de cette section sera développée dans une version future de ce document


5.2. Présentation rapide du package awt java


AWT est une collection de classes pour la réalisation d'applications graphique ou GUI (Graphic User Interface)

Les composants qui sont utilisés par les classes définies dans ce package sont des composants dit "lourds" : ils dépendent entièrement du système d'explotation. D'ailleurs leur nombre est limité car ils sont communs à plusieurs systèmes d'exploitation pour assurer la portabilité. Cependant, la représentation d'une interface graphique avec awt sur plusieurs systèmes peut ne pas être identique.

La chapitre "Création d'interface graphique avec AWT" détaille l'utilisation de ce package


5.2.1. Le package java.image


Ce package permet la gestion des images


5.2.2. Le package java.awt.perr


Ce package contient des classes qui réalise l'interface avec le système d'exploitation.


5.3. Présentation rapide du package java.io


Ce package définit un ensemble de classes pour la gestion des flux d'entrées-sorties

Le chapitre les flux détaille l'utilisation de ce package


5.4. Le package java.util


Ce package contient un ensemble de classes utilitaires : la gestion des dates (Date et Calendar), la génération de nombres aléatoires (Random), la gestion des collections ordonnées ou non tel que la tablea de hachage (HashTable), le vecteur (Vector), la pile (Stack) ..., la gestion des propriétés (Properties), des classes dédiées à l'internationalisation (ResourceBundle, PropertyResourceBundle, ListResourceBundle) etc ...

Certaines de ces classes sont présentées plus en détail dans les sections suivantes.


5.4.1. La classe StringTokenizer


Cette classe permet de découper une chaine de caractères (objet de type String) en fonction de séparateurs. Le constructeur de la classe accepte 2 paramètres : la chaine à décomposer et une chaine contenant les séparateurs

Exemple (code java 1.1) :
import java.util.*; class test9 { public static void main(String args[]) { StringTokenizer st = new StringTokenizer("chaine1,chaine2,chaine3,chaine4",","); while (st.hasMoreTokens()) { System.out.println((st.nextToken()).toString()); } } } C:\java>java test9 chaine1 chaine2 chaine3 chaine4
La méthode hasMoreTokens() fournit un contrôle d'itération sur la collection en renvoyant un booleen indiquant si il reste encore des éléments.

La méthode getNextTokens() renvoie le prochain élément sous la forme d'un objet String


5.4.2. La classe Random


La classe Random permet de générer des nombres pseudo-aléatoires. Après l'appel au constructeur, il suffit d'appeler la méthode correspondant au type désiré : nextInt(), nextLong(), nextFloat() ou nextDouble()

Méthodes valeur de retour
nextInt entre Integer.MIN_VALUE et Interger.MAX_VALUE
nextLong entre long.MIN_VALUE et long.MAX_VALUE
nextFloat ou nextDouble entre 0.0 et 1.0
Exemple (code java 1.1) :
import java.util.*; class test9 { public static void main (String args[]) { Random r = new Random(); int a = r.nextInt() %10; //entier entre -9 et 9 System.out.println("a = "+a); } }

5.4.3. Les classes Date et Calendar


En java 1.0, la classe Date permet de manipuler les dates.

Exemple (code java 1.0) :
import java.util.*; ... Date maintenant = new Date(); if (maintenant.getDay() == 1) System.out.println(" lundi ");
Le constructeur d'un objet Date l'initialise avec la date et l'heure courante du système.

Exemple (code java 1.0) :
import java.util.*; import java.text.*; public class TestHeure { public static void main(java.lang.String[] args) { Date date = new Date(); System.out.println(DateFormat.getTimeInstance().format(date)); } }
Résultat :
22:05:21
La méthode getTime() permet de calculer le nombre de millisecondes écoulées entre la date qui est encapsulée dans l'objet qui reçoit le message getTime et le premier janvier 1970 à minuit GMT.

En java 1.1, de nombreuses méthodes et constructeurs de la classe Date sont deprecated, notamment celles qui permettent de manipuler les éléments qui composent la date et leur formattage : il faut utiliser la classe Calendar.

Exemple (code java 1.0) :
import java.util.*; public class TestCalendar { public static void main(java.lang.String[] args) { Calendar c = Calendar.getInstance(); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) System.out.println(" nous sommes lundi "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.TUESDAY) System.out.println(" nous sommes mardi "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.WEDNESDAY) System.out.println(" nous sommes mercredi "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.THURSDAY) System.out.println(" nous sommes jeudi "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY) System.out.println(" nous sommes vendrei "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) System.out.println(" nous sommes samedi "); if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) System.out.println(" nous sommes dimanche "); } }
Résultat :
nous sommes lundi

5.4.4. La classe Vector


Un objet de la classe Vector peut être considéré comme une tableau évolué qui peut contenir un nombre indéterminé d'objets.

Les méthodes principales sont les suivantes :

Méthode Rôle
void addElement(Object) ajouter un objet dans le vecteur
boolean contains(Object) retourne true si l'objet est dans le vecteur
Object elementAt(int) retourne l'objet à l'index indiqué
Enumeration elements() retourne une enumeration contenant tous les éléments du vecteur
Object firstElement() retourne le premier élément du vecteur (celui dont l'index est égal à zéro)
int indexOf(Object) renvoie le rang de l'élément ou -1
void insertElementAt(Object, int) insérer un objet à l'index indiqué
boolean isEmpty() retourne un booléen si le vecteur est vide
Objet lastElement() retourne le dernier élément du vecteur
void removeAllElements() vider le vecteur
void removeElement(Object) supprime l'objet du vecteur
void removeElementAt(int) supprime l'objet à l'index indiqué
void setElementAt(object, int) remplacer l'élément à l'index par l'objet
int size() nombre d'objet du vecteur
On peut stocker des objets de classes différentes dans un vecteur mais les éléments stockés doivent obligatoirement être des objets (pour le type primitif il faut utiliser les wrappers tel que Integer ou Float mais pas int ou float).

Exemple (code java 1.1) :
Vector v = new Vector(); v.addElement(new Integer(10)); v.addElement(new Float(3.1416)); v.insertElementAt("chaine ",1); System.out.println(" le vecteur contient "+v.size()+ " elements "); String retrouve = (String) v.elementAt(1); System.out.println(" le 1er element = "+retrouve); C:\$user\java>java test9 le vecteur contient 3 elements le 1er element = chaine
Exemple (code java 1.1) : le parcours d'un vecteur
Vector v = new Vector(); ... for (int i = 0; i < v.size() ; i ++) { System.out.println(v.elementAt(i)); }
Pour un parcours en utilisant l'interface Enumeration, voir le chapitre correspondant.


5.4.5. La classe Hashtable


Les informations d'une Hastable sont stockées sous la forme clé - données. Cet objet peut être considéré comme un dictionnaire.

Exemple (code java 1.1) :
Hashtable dico = new Hashtable(); dico.put(«livre1», « titre du livre 1 »); dico.put(«livre2», «titre du livre 2 »);
Il est possible d'utiliser n'importe quel objet comme clé et comme donnée

Exemple (code java 1.1) :
dico.put(«jour», new Date()); dico.put(new Integer(1),«premier»); dico.put(new Integer(2),«deuxième»);
Pour lire dans la table, on utilise get(object) en donnant la clé en paramètre.

Exemple (code java 1.1) :
System.out.println(« nous sommes le » +dico.get(«jour»));
La méthode remove(Object) permet de supprimer une entrée du dictionnaire correspondant à la clé passée en paramètre.

La méthode size() permet de connaitre le nombre d'association du dictionnaire.


5.4.6. L'interface Enumeration


L'interface Enumeration est utilisée pour permettre le parcours séquentiel de collections.

Enumeration est une interface qui définit 2 méthodes :

Méthodes Rôle
boolean hasMoreElements() retourne true si l'énumeration contient encore un ou plusieurs elements
Object nextElement() retourne l'objet suivant de l'énumération.
Elle leve une Exception NoSuchElementException si la fin de la collection est atteinte.
Exemple (code java 1.1) : contenu d'un vecteur et liste des clés d'une Hastable
import java.util.*; class test9 { public static void main (String args[]) { Hashtable h = new Hashtable(); Vector v = new Vector(); v.add("chaine 1"); v.add("chaine 2"); v.add("chaine 3"); h.put("jour", new Date()); h.put(new Integer(1),"premier"); h.put(new Integer(2),"deuxième"); System.out.println("Contenu du vector"); for (Enumeration e = v.elements() ; e.hasMoreElements() ; ) { System.out.println(e.nextElement()); } System.out.println("\nContenu de la hashtable"); for (Enumeration e = h.keys() ; e.hasMoreElements() ; ) { System.out.println(e.nextElement()); } } } C:\$user\java>java test9 Contenu du vector chaine 1 chaine 2 chaine 3 Contenu de la hashtable jour 2 1

5.4.7. Les expressions régulières


Le JDK 1.4 propose une api en standard pour utiliser les expressions régulières. Les expressions régulières permettent de comparer une chaine de caractères àun motif pour vérifier qu'il y a concordance.

La package java.util.regexp contient deux classes et une exception pour gérer les expressions régulières :

Classe Rôle
Matcher comparer une chaine de caractère avec un motif
Pattern encapsule une version compilée d'un motif
PatternSyntaxException exception levée lorsque le motif contient une erreur de syntaxe

5.4.7.1. Les motifs


Les expressions régulières utilisent un motif. Ce motif est une chaine de caractères qui contient des caractères et des métacaractères. Les métacaractères ont une signification particulière et sont interprétés.

Il est possible de déspécialiser un métacaractère (lui enlever sa signification particulière à en le faisant précédé d'un caractère backslash. Ainsi pour utiliser le caractère backslash, il faut le doubler.

Les métacaractères reconnus par l'api sont :

métacaractères rôle
()  
[] définir un ensemble de caractères
{} définir une répétition du motif précédent
\ déspécialisation du caractère qui suit
^ debut de la ligne
$ fin de la ligne
| le motif precedent ou le motif suivant
? motif precédent répété zero ou une fois
* motif precédent répété zero ou plusieurs fois
+ motif precédent répété une ou plusieurs fois
. un caractère quelconque
Certains caractères spéciaux ont une notation particulière :

Notation Rôle
\t tabulation
\n nouvelle ligne (lign feed)
\\ backslash
Il est possible de définir des ensembles de caractères à l'aide des caractères [ et ]. Il suffit d'indiquer les caractères de l'ensemble entre ces deux caractères

Exemple : toutes les voyelles
[aeiouy]
Il est possible d'utiliser une plage de caractères consécutifs en séparant le caractère de début de la plage et le caractère de fin de la plage avec un caractère -

Exemple : toutes les lettres minuscules
[a-z]
L'ensemble peut être l'union de plusieurs plages.

Exemple : toutes les lettres
[a-zA-Z]
Par défaut l'ensemble [] désigne tous les caractères. Il est possible de définir un ensemble de la forme tous sauf ceux précisés en utilisant le caractère ^ suivi des caractères à enlever de l'ensemble

Exemple : tous les caractères sauf les lettres
[^a-zA-Z]
Il existe plusieurs ensembles de caractères prédéfinis :

Notation Contenu de l'ensemble
\d un chiffre
\D tout sauf un chiffre
\w une lettre ou un underscore
\W tout sauf une lettre ou un underscore
\s un séparateur (espace, tabulation, retour chariot, ...)
\S tout sauf un séparateur
Plusieurs métacaractères permettent de préciser un critère de répétition d'un motif

métacaractères rôle
{n} répétition du motif précédent n fois
{n,m} répétition du motif précédent entre n et m fois
{n,} répétition du motif précédent
? motif precédent répété zero ou une fois
* motif precédent répété zero ou plusieurs fois
+ motif precédent répété une ou plusieurs fois
Exemple : la chaine AAAAA
A{5}

5.4.7.2. La classe Pattern


Cette classe encapsule une representation compilée d'un motif d'une expression régulière.

La classe Pattern ne possède pas de constructeur public mais propose une méthode statique compile().

Exemple :
private static Pattern motif = null; ... motif = Pattern.compile("liste[0-9]");
Une version surchargée de la méthode compile() permet de préciser certaines options dont la plus interressante permet de rendre insensible à la casse les traitements en utilisant le flag CASE_INSENSITIVE.

Exemple :
private static Pattern motif = null; ... motif = Pattern.compile("liste[0-9]",Pattern.CASE_INSENSITIVE);
Cette méthode compile() renvoie une instance de la classe Pattern si le motif est syntaxiquement correcte sinon elle lève une exception de type PatternSyntaxException.

La méthode matches(String, String) permet de rapidement et facilement utiliser les expressions régulières avec un seul appel de méthode en fournissant le motif est la chaine à traiter.

Exemple :
if (Pattern.matches("liste[0-9]","liste2")) { System.out.println("liste2 ok"); } else { System.out.println("liste2 ko"); }

5.4.7.3. La classe Matcher


La classe Matcher est utilisée pour effectuer la comparaison entre une chaine de caractères et un motif encapsulé dans un objet de type Pattern.

Cette classe ne possède aucun constructeur public. Pour obtenir une instance de cette classe, il faut utiliser la méthode matcher() d'une instance d'un objet Pattern en lui fournissant la chaine à traiter en paramètre.

Exemple :
motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("liste1");
La méthodes matches() tente de comparer toute la chaine avec le motif et renvoie le résultat de cette comparaison.

Exemple :
motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("liste1"); if (matcher.matches()) { System.out.println("liste1 ok"); } else { System.out.println("liste1 ko"); } matcher = motif.matcher("liste10"); if (matcher.matches()) { System.out.println("liste10 ok"); } else { System.out.println("liste10 ko"); }
Résultat :
liste1 ok liste10 ko
La méthode lookingAt() tente de recherche le motif dans la chaine à traiter

Résultat :
motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("liste1"); if (matcher.lookingAt()) { System.out.println("liste1 ok"); } else { System.out.println("liste1 ko"); } matcher = motif.matcher("liste10"); if (matcher.lookingAt()) { System.out.println("liste10 ok"); } else { System.out.println("liste10 ko"); }
Résultat :
liste1 ok liste10 ok
La méthode find() permet d'obtenir des informations sur chaque occurrence ou le motif est trouvé dans la chaine à traiter.

Exemple :
matcher = motif.matcher("zzliste1zz"); if (matcher.find()) { System.out.println("zzliste1zz ok"); } else { System.out.println("zzliste1zz ko"); }
Résultat :
zzliste1zz ok
Il est possible d'appeler successivement cette méthode pour obtenir chacune des occurrences.

Exemple :
int i = 0; motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("liste1liste2liste3"); while (matcher.find()) { i++; } System.out.println("nb occurences = " + i);
Les méthodes start() et end() permettent de connaitre la position de début et de fin dans la chaine dans l'occurrence en cours de traitement.

Exemple :
int i = 0; motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("liste1liste2liste3"); while (matcher.find()) { i++; } System.out.println("nb occurences = " + i);
Résultat :
pos debut : 0 pos fin : 6 pos debut : 6 pos fin : 12 pos debut : 12 pos fin : 18 nb occurences = 3
La classe Matcher propose aussi les méthodes replaceFirst() et replaceAll() pour facilement remplacer la première ou toutes les occurrences du motif trouvées par une chaine de caractères

Exemple : remplacement de la première occurence
motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("zz liste1 zz liste2 zz"); System.out.println(matcher.replaceFirst("chaine"));
Résultat :
zz chaine zz liste2 zz
Exemple : remplacement de toutes les occurences
motif = Pattern.compile("liste[0-9]"); matcher = motif.matcher("zz liste1 zz liste2 zz"); System.out.println(matcher.replaceAll("chaine"));
Résultat :
zz chaine zz chaine zz

5.5. Présentation rapide du package java.net


Ce package contient un ensemble de classes pour permettre une interaction avec le réseau

Le chapitre l'interaction avec le réseau détaille l'utilisation de ce package


5.6. Présentation rapide du package java.applet


Ce package contient des classes à importer obligatoirement pour développer des applets

Le développement des applets est détaillé dans le chapitre les applets



Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -