7. Les packages de bases

Niveau :

Elémentaire

Le JDK se compose de nombreuses classes regroupées selon leurs fonctionnalités en packages. La première version du JDK était composée de 8 packages qui constituent encore aujourd'hui les packages de bases des différentes versions du JDK.

Ce chapitre contient plusieurs sections :

• Les packages selon la version du JDK
• Le package java.lang
• La présentation rapide du package awt java
• La présentation rapide du package java.io
• Le package java.util
• La présentation rapide du package java.net
• La présentation rapide du package java.applet

7.1. Les packages selon la version du JDK

Selon sa version, le JDK contient un certain nombre de packages, chacun étant constitué 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 enrichies avec de nouveaux packages :

7.2. Le package java.lang

Ce package de base contient les classes fondamentales telles que Object, Class, Math, System, String, StringBuffer, Thread, les wrappers etc ... Certaines de ces classes sont détaillées dans les sections suivantes.

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

Certaines classes sont détaillées dans des chapitres dédiés : 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» et la classe Thread est détaillée dans le chapitre «Le multitâche».

Ce package est tellement fondamental qu'il est implicitement importé dans tous les fichiers sources par le compilateur.

7.2.1. La classe Object

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

7.2.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

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

7.2.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.

7.2.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.

7.2.1.4. La méthode finalize()

A l'inverse de nombreux langages orientés objet tels 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-miettes 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.

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

Attention : selon l'implémentation du garbage collector dans la machine virtuelle, il n'est pas possible de prévoir le moment ou un objet sera traité par le garbage collector. De plus, l'appel du finaliseur n'est pas garanti : par exemple, si la machine virtuelle est brusquement arrêtée par l'utilisateur, le ramasse-miettes ne libérera pas la mémoire des objets en cours d'utilisation et les finaliseurs de ces objets ne seront pas appelés.

L'utilisation des finalizer n'est jamais été préconisée et il est même fortement déconseillée.

En Java 9, la méthode finalize() est dépréciée.

7.2.1.5. La méthode clone()

La section «Le clonage d'un objet» du chapitre «Les techniques de développement spécifiques à Java» détaille la mise en oeuvre de la méthode clone().

7.2.2. Les classes de manipulations de chaînes de caractères

Plusieurs classes sont proposées pour utiliser ou manipuler des chaînes de caractères notamment java.lang.String, java.util.StringBuffer et java.util.StringBuilder.

Le chapitre «Les chaînes de caractères» détaille la mise en oeuvre de ces classes.

7.2.3. Les wrappers

Les objet de type wrappers (enveloppes) représentent des objets qui encapsulent une donnée de type primitif et fournissent un ensemble de méthodes permettant notamment de faire des 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 (dépréciés à partir de Java 9)
• des surcharges de fabrique valueOf() pour obtenir une instance
• une méthode pour fournir la valeur primitive représentée par l'objet
• une implémentation de la 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.

int valeur = Integer.valueOf("999").intValue();

Jusqu'à Java 5 et l'introduction de l'autoboxing, ces classes ne sont pas interchangeables avec les types primitifs d'origine car il s'agit d'objets.

Float objetPi = new Float("3.1415");
System.out.println(5 * objetPi); // erreur à la compilation

Pour obtenir la valeur contenue dans l'objet, il faut utiliser la méthode xxxValue() où xxx est le nom du type standard.

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); // pour les valeurs de type float
Double.isInfinite(double); // idem pour les valeurs de type double

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.

System.out.println(10/0);

Exception in thread "main" java.lang.ArithmeticException: / by zero
at test9.main(test9.java:6)

7.2.4. La classe System

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

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

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

System.out.println("bonjour");

La classe System possède trois méthodes qui permettent de rediriger ces flux : setIn(InputStream), setOut(PrintStream) et setErr(PrintStream).

le mode de fonctionnement bien connu dans le langage C a été repris pour être ajouté dans l'API Java avec la méthode printf().

public class TestPrintf {
  public static void main(String[] args) {
    System.out.printf("%4d",32);
  }
}

La méthode printf() propose :

• un nombre d'arguments variable
• des formats standard pour les types primitifs, String et Date
• des justifications possibles avec certains formats
• l'utilisation de la localisation pour les données numériques et de type date

import java.util.*;

public class TestPrintf2 {

  public static void main(String[] args) {
    System.out.printf("%d \n"	                  ,13);
    System.out.printf("%4d \n"	                  ,13);
    System.out.printf("%04d \n"	                  ,13);
    System.out.printf("%f \n"	                  ,3.14116);
    System.out.printf("%.2f \n"	                  ,3.14116);
    System.out.printf("%s \n"	                  ,"Test");
    System.out.printf("%10s \n"	                  ,"Test");
    System.out.printf("%-10s \n"	          ,"Test");
    System.out.printf("%tD \n"                    , new Date());
    System.out.printf("%tF \n"                    , new Date());
    System.out.printf("%1$te %1$tb %1$ty \n"       , new Date());
    System.out.printf("%1$tA %1$te %1$tB %1$tY \n", new Date());
    System.out.printf("%1$tr \n"                  , new Date());
  }
}

C:\tiger>java TestPrintf2 
13 
13 
0013 
3,141160 
3,14 
Test 
Test 
Test 
08/23/04 
2004-08-23 
23 août 04 
lundi 23 août 2004 
03:56:25 PM 

Une exception est levée lors de l'exécution si un des formats utilisés est inconnu.

C:\tiger>java TestPrintf2 
13 1300133,1411603,14Test TestTest 08/23/04Exception in thread "main" 
java.util.UnknownFormatConversionException: Conversion = 'tf' 
at java.util.Formatter$FormatSpecifier.checkDateTime(Unknown Source) 
at java.util.Formatter$FormatSpecifier.<init>(Unknown Source) 
at java.util.Formatter.parse(Unknown Source) 
at java.util.Formatter.format(Unknown Source) 
at java.io.PrintStream.format(Unknown Source) 
at java.io.PrintStream.printf(Unknown Source) 
at TestPrintf2.main(TestPrintf2.java:15)

7.2.4.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 très portable. Son utilisation lève une exception :

java.lang.Error: getenv no longer  supported, use properties and -D instead: windir
      at  java.lang.System.getenv(System.java:691)
      at  fr.jmdoudoux.dej.TestPropertyEnv.main(TestPropertyEnv.java:6)
Exception  in thread "main"

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 constitué de propriétés standard fournies par l'environnement Java et par des propriétés ajoutées par l'utilisateur. Jusqu'au JDK 1.4, il est nécessaire d'utiliser ces propriétés de la JVM.

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

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.class.version          ="
      +System.getProperty("java.class.version"));
    System.out.println("java.class.path             ="
      +System.getProperty("java.class.path"));
    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.

Pour définir ses propres propriétés, il faut utiliser l'option -D de l'interpréteur Java sur la ligne de commandes.

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.

package fr.jmdoudoux.dej;

public class TestPropertyEnv {

  public static void main(String[] args) {
    System.out.println("env.windir ="+System.getProperty("env.windir"));
  }
}

C:\java>java -Denv.windir=%windir% -cp . fr.jmdoudoux.dej.TestPropertyEnv
env.windir =C:\WINDOWS

Java 5 propose de nouveau une implémentation pour la méthode System.getenv() possédant deux surcharges :

• Une sans paramètre qui renvoie une collection des variables système
• Une avec un paramètre de type String qui contient le nom de la variable à obtenir

package fr.jmdoudoux.dej;

public class TestPropertyEnv {

  public static void main(String[] args) {
    System.out.println(System.getenv("windir"));
  }
}

La surcharge sans argument permet d'obtenir une collection de type Map contenant les variables d'environnement système.

package fr.jmdoudoux.dej;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestPropertyEnv {

  public static void main(String[] args) {
    Map map = System.getenv();
    Set cles = map.keySet();
    Iterator iterator = cles.iterator();
    while (iterator.hasNext()) {
      String cle = (String) iterator.next();
      System.out.println(cle+" : "+map.get(cle));
    }  
  }
} 

7.2.5. Les classes Runtime et Process

La classe Runtime permet d'interagir avec le système dans lequel l'application s'exécute : obtenir des informations sur le système, arrêter de la machine virtuelle, exécuter 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() de la classe RunTime.

Les méthodes totalMemory() et freeMemory() permettent d'obtenir respectivement la quantité totale de la mémoire et la quantité de mémoire libre.

package fr.jmdoudoux.dej;

public class TestRuntime1 {

    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        System.out.println("Mémoire totale = " + runtime.totalMemory());
        System.out.println("Memoire libre = " + runtime.freeMemory());
    }
}

La méthode exec() permet d'exécuter des processus sur le système d'exploitation où s'exé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é.

Il existe plusieurs surcharges de cette méthode pouvant toutes, entre autres, lever une exception de type SecurityException, IOException, NullPointerException  :

La commande  à exécuter peut être fournie sous la forme d'une chaîne de caractères ou sous la forme d'un tableau dont le premier élément est la commande et les éléments suivants sont ses arguments. Deux des surcharges acceptent un objet de type File qui encapsule le répertoire dans lequel la commande va être exécutée.

Important : la commande exec() n'est pas un interpréteur de commandes. Il n'est par exemple pas possible de préciser dans la commande une redirection vers un fichier. Ainsi pour exécuter une commande de l'interpréteur DOS sous Windows, il est nécessaire de préciser l'interpréteur de commandes à utiliser (command.com sous Windows 95 ou cmd.exe sous Windows 2000 et XP).

Remarque : avec l'interpréteur de commandes cmd.exe, il est nécessaire d'utiliser l'option /c qui permet de demander de quitter l'interpréteur à la fin de l'exécution de la commande.

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

La classe abstraite Process encapsule un processus : son implémentation est fournie par la JVM puisqu'elle est dépendante du système.

Les méthodes getOutputStream(), getInputStream() et getErrorStream() permettent d'avoir un accès respectivement au flux de sortie, d'entrée et d'erreur du processus.

La méthode waitFor() permet d'attendre la fin du processus.

La méthode exitValue() permet d'obtenir le code de retour du processus. Elle lève une exception de type IllegalThreadStateException si le processus n'est pas terminé.

La méthode destroy() permet de détruire le processus.

package fr.jmdoudoux.dej;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class TestRuntime2 {
  public static void main(String[] args) {
    try {
      Process proc = 
        Runtime.getRuntime().exec("cmd.exe /c set");
      BufferedReader in = 
        new BufferedReader(new InputStreamReader(proc.getInputStream()));
      String str;
      while ((str = in.readLine()) != null) {
        System.out.println(str);
      }
      in.close();
      proc.waitFor();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Le code ci-dessus est fourni à titre d'exemple mais il n'est pas la solution idéale même s'il fonctionne. Il est préférable de traiter les flux dans un thread dédié.

package fr.jmdoudoux.dej;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class TestRuntime3 {

  public TestRuntime3() {
    try {

      Runtime runtime = Runtime.getRuntime();
      Process proc = runtime.exec("cmd.exe /c set");

      TestRuntime3.AfficheFlux afficheFlux = 
        new AfficheFlux(proc.getInputStream());

      afficheFlux.start();

      int exitVal = proc.waitFor();
      System.out.println("exitVal = " + exitVal);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    new TestRuntime3();
  }

  private class AfficheFlux extends Thread {
    InputStream is;

    AfficheFlux(InputStream is) {
      this.is = is;
    }

    public void run() {
      try {
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        String line = null;
        while ((line = br.readLine()) != null)
          System.out.println(line);
      } catch (IOException ioe) {
        ioe.printStackTrace();
      }
    }
  }
}

Sous Windows, il est possible d'utiliser un fichier dont l'extension est associée à une application.

Process proc = Runtime.getRuntime().exec("cmd.exe /c \"c:\\test.doc\"");

7.3. La présentation rapide du package awt java

AWT est une collection de classes pour la réalisation d'applications graphiques 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'exploitation. 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.

AWT se compose de plusieurs packages dont les principaux sont:

• java.awt : c'est le package de base de la bibliothèque AWT
• java.awt.images : ce package permet la gestion des images
• java.awt.event : ce package permet la gestion des événements utilisateurs
• java.awt.font : ce package permet d'utiliser les polices de caractères
• java.axt.dnd : ce package permet l'utilisation du cliquer/glisser

Le chapitre «La création d'interfaces graphiques avec AWT» détaille l'utilisation de ce package.

7.4. La 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'entrée/sortie» détaille l'utilisation de ce package.

7.5. 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 telles que la table 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.

7.5.1. 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()

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

7.5.2. Les classes Date et Calendar

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

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.

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

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 à 0 heure 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 formatage : il faut utiliser la classe Calendar.

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 vendredi ");
    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 ");
  }
}

 nous sommes lundi 

La mise en oeuvre détaillée de ces classes est proposée dans le chapitre «L'utilisation des dates»

7.5.3. La classe SimpleDateFormat

La classe SimpleDateFormat est la seule implémentation de la classe DateFormat fournie en standard.

Elle utilise une syntaxe particulière pour spécifier le format de la date à utiliser pour le formatage ou le parsing. Ce format est fourni par le constructeur ou en invoquant la méthode applyPattern().

final SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
final String dateStr = sdf.format(new Date());
System.out.println(dateStr);
try {
  final Date date = sdf.parse(dateStr); 
  System.out.println(date);
}
catch (final ParseException pe) {
  pe.printStackTrace();
} 

La méthode parse() peut lever une exception de type ParseException si l'extraction de la date selon le format et la date fournis échoue.

La mise en oeuvre détaillée de cette classe est incluse dans le chapitre «L'utilisation des dates»

7.5.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 :

On peut stocker des objets de classes différentes dans un vecteur mais les éléments stockés doivent obligatoirement être des objets (Avant Java 5, pour les types primitifs, il faut utiliser les wrappers tels que Integer ou Float respectivement pour des données de type int ou float).

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

   Vector v = new Vector();
   ... 

   for (int i = 0; i < v.size() ; i ++) {
      System.out.println(v.elementAt(i));
   }

Il est aussi possible de parcourir l'ensemble des éléments en utilisant une instance de l'interface Enumeration.

Remarque : A partir de Java 1.2, il est préférable d'utiliser une classe de «Les collections».

7.5.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.

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.

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.

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'associations du dictionnaire.

Remarque : A partir de Java 1.2, il est préférable d'utiliser une classe de «Les collections».

7.5.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 :

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

7.5.7. La manipulation d'archives zip

Depuis sa version 1.1, le JDK propose des classes permettant la manipulation d'archives au format zip. Ce format de compression est utilisé par Java lui-même notamment pour les fichiers de packaging (jar, war, ear ...).

Ces classes sont regroupées dans le package java.util.zip. Elles permettent de manipuler les archives aux formats zip et Gzip et d'utiliser des sommes de contrôles selon les algorithmes Adler-32 et CRC-32.

La classe ZipFile encapsule une archive au format zip : elle permet de manipuler les entrées qui composent l'archive.

Elle possède trois constructeurs :

   try {
    ZipFile test = new ZipFile(new File("C:/test.zip"));
   }  catch (ZipException e) {
    e.printStackTrace();
   }  catch (IOException e) {
    e.printStackTrace();
   }

Cette classe possède plusieurs méthodes dont les principales sont  :

La classe ZipEntry encapsule une entrée dans l'archive zip. Une entrée correspond à un fichier avec des informations le concernant dans l'archive.

Cette classe possède plusieurs méthodes dont les principales sont  :

  public static void listerZip(String nomFichier) {
    ZipFile zipFile;
    try {
      zipFile = new ZipFile(nomFichier);
      Enumeration entries = zipFile.entries();
      while (entries.hasMoreElements()) {
        ZipEntry entry = (ZipEntry) entries.nextElement();
        String name = entry.getName();
        System.out.println(name);
      }
      zipFile.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

La classe ZipOutputStream est un flux qui permet l'écriture de données dans l'archive.

Cette classe possède plusieurs méthodes dont les principales sont  :

  public static void compresser(String nomArchive, String nomFichier) {
    try {
      ZipOutputStream zip = new ZipOutputStream(
          new FileOutputStream(nomArchive));
      zip.setMethod(ZipOutputStream.DEFLATED);
      zip.setLevel(Deflater.BEST_COMPRESSION);

      // lecture du fichier

      File fichier = new File(nomFichier);
      FileInputStream fis = new FileInputStream(fichier);
      byte[] bytes = new byte[fis.available()];
      fis.read(bytes);

      // ajout d'une nouvelle entrée dans l'archive contenant le fichier

      ZipEntry entry = new ZipEntry(nomFichier);
      entry.setTime(fichier.lastModified());
      zip.putNextEntry(entry);
      zip.write(bytes);

      // fermeture des flux

      zip.closeEntry();
      fis.close();
      zip.close();
    } catch (FileNotFoundException fnfe) {
      fnfe.printStackTrace();
    } catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }

La classe ZipInputStream est un flux qui permet la lecture de données dans l'archive.

Cette classe possède plusieurs méthodes dont les principales sont  :

  public static void decompresser(String nomArchive, String chemin) {
    try {

      ZipFile zipFile = new ZipFile(nomArchive);
      Enumeration entries = zipFile.entries();
      ZipEntry entry = null;
      File fichier = null;
      File sousRep = null;

      while (entries.hasMoreElements()) {
        entry = (ZipEntry) entries.nextElement();

        if (!entry.isDirectory()) {
          System.out.println("Extraction du fichier " + entry.getName());
          fichier = new File(chemin + File.separatorChar + entry.getName());
          sousRep = fichier.getParentFile();

          if (sousRep != null) {
            if (!sousRep.exists()) {
              sousRep.mkdirs();
            }
          }

          int i = 0;
          byte[] bytes = new byte[1024];
          BufferedOutputStream out = new BufferedOutputStream(
              new FileOutputStream(fichier));
          BufferedInputStream in = new BufferedInputStream(zipFile
              .getInputStream(entry));
          while ((i = in.read(bytes)) != -1)
            out.write(
                bytes,
                0,
                i);

          in.close();
          out.flush();
          out.close();
        }
      }
      zipFile.close();
    } catch (FileNotFoundException fnfe) {
      fnfe.printStackTrace();
    } catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }

7.5.8. 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 chaîne de caractères à un motif pour vérifier s'il y a concordance.

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

7.5.8.1. Les motifs

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

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

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

Certains caractères spéciaux ont une notation particulière :

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 crochets.

[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 -.

[a-z]

L'ensemble peut être l'union de plusieurs plages.

[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

[^a-zA-Z]

Il existe plusieurs ensembles de caractères prédéfinis :

Plusieurs méta caractères permettent de préciser un critère de répétition d'un motif

A{5}

7.5.8.2. La classe Pattern

Cette classe encapsule une représentation 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().

      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 intéressante permet de rendre insensible à la casse les traitements en utilisant le flag CASE_INSENSITIVE.

      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 correct 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 et la chaîne à traiter.

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

7.5.8.3. La classe Matcher

La classe Matcher est utilisée pour effectuer la comparaison entre une chaîne 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 chaîne à traiter en paramètre.

      motif = Pattern.compile("liste[0-9]");
      matcher = motif.matcher("liste1");

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

liste1 ok
liste10 ko

La méthode lookingAt() tente de rechercher le motif dans la chaîne à traiter.

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

 liste1 ok
 liste10 ok

La méthode find() permet d'obtenir des informations sur chaque occurrence où le motif est trouvé dans la chaîne à traiter.

      matcher = motif.matcher("zzliste1zz");
      if (matcher.find()) {
            System.out.println("zzliste1zz ok");
      } else {
           System.out.println("zzliste1zz ko");
      }

zzliste1zz ok

Il est possible d'appeler successivement cette méthode pour obtenir chacune des occurrences.

        int i = 0;
        motif = Pattern.compile("liste[0-9]");
        matcher = motif.matcher("liste1liste2liste3");
        while (matcher.find()) {
              i++;
        }
        System.out.println("nb occurrences = " + i);

Les méthodes start() et end() permettent de connaitre respectivement la position de début et de fin de la chaîne dans l'occurrence en cours de traitement.

        int i = 0;
        motif = Pattern.compile("liste[0-9]");
        matcher = motif.matcher("liste1liste2liste3");
        while (matcher.find()) {
            System.out.print("pos debut : "+matcher.start());
            System.out.println(" pos fin : "+matcher.end());
            i++;
        }
        System.out.println("nb occurrences = " + i);

  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é par une chaîne de caractères.

        motif = Pattern.compile("liste[0-9]");
        matcher = motif.matcher("zz liste1 zz liste2 zz");
        System.out.println(matcher.replaceFirst("chaine"));

zz chaine zz liste2 zz

      motif = Pattern.compile("liste[0-9]");
      matcher = motif.matcher("zz liste1 zz liste2 zz");
      System.out.println(matcher.replaceAll("chaine"));

zz chaine zz chaine zz

7.5.9. La classe Formatter

La méthode printf() utilise la classe Formatter pour réaliser le formatage des données fournies selon leurs valeurs et le format donné en paramètre.

Cette classe peut aussi être utilisée pour formater des données pour des fichiers ou dans une servlet par exemple.

La méthode format() attend en paramètre une chaîne de caractères qui précise le format des données à formater.

import java.util.*;

public class TestFormatter {

  public static void main(String[] args) {
    Formatter formatter = new Formatter();
    formatter.format("%04d \n",13);
    String resultat = formatter.toString();
    System.out.println("chaine = " + resultat);
 
  }
	
}

C:\tiger>java TestFormatter
chaine = 0013

7.5.10. La classe Scanner

Cette classe facilite la lecture dans un flux. Elle est particulièrement utile pour réaliser une lecture de données à partir du clavier dans une application de type console.

La méthode next() bloque l'exécution jusqu'à la lecture de données et les renvoie sous la forme d'une chaîne de caractères.

import java.util.*;

public class TestScanner {

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String chaine = scanner.next();
    scanner.close();
  }
}

Cette classe possède plusieurs méthodes nextXXX() où XXX représente un type primitif. Ces méthodes bloquent l'exécution jusqu'à la lecture de données et tente de les convertir dans le type XXX

import java.util.*;

public class TestScanner {

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int entier = scanner.nextInt();
    scanner.close();
  }
}

Une exception de type InputMismatchException est levée si les données lues dans le flux ne sont pas du type requis.

C:\tiger>java TestScanner
texte
Exception in thread "main" java.util.InputMismatchException
        at java.util.Scanner.throwFor(Unknown Source)
        at java.util.Scanner.next(Unknown Source)
        at java.util.Scanner.nextInt(Unknown Source)
        at java.util.Scanner.nextInt(Unknown Source)
        at TestScanner.main(TestScanner.java:8)

La classe Scanner peut être utilisée avec n'importe quel flux.

7.6. La présentation rapide du package java.net

Ce package contient un ensemble de classes pour permettre une interaction avec le réseau notamment de recevoir et d'envoyer des données.

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

7.7. La présentation rapide du package java.applet

Ce package contient les classes nécessaires au développement des applets. Une applet est une petite application téléchargée par le réseau et exécutée sous de fortes contraintes de sécurité dans une page Web par le navigateur.

Le développement des applets est détaillé dans le chapitre «Les applets en java»