Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :

 

Développons en Java   2.10  
Copyright (C) 1999-2016 Jean-Michel DOUDOUX    (date de publication : 19/03/2016)

[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]

 

5. Les packages de bases

 

chapitre   5

 

Niveau : niveau 2 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 :

 

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

Packages
JDK
1.0
JDK
1.1
JDK
1.2
JDK
1.3
JDK
1.4
JDK
1.5
JDK
6.0
JDK
7.0
JDK
8.0
java.applet
Développement des applets
X
X
X
X
X
X
X
X
X
java.awt
Toolkit pour interfaces graphiques
X
X
X
X
X
X
X
X
X
java.awt.color
Gérer et utiliser les couleurs
   
X
X
X
X
X
X
X
java.awt.datatransfer
Echanger des données par le presse-papier
 
X
X
X
X
X
X
X
X
java.awt.dnd
Gérer le cliquer/glisser
   
X
X
X
X
X
X
X
java.awt.event
Gérer les événements utilisateurs
 
X
X
X
X
X
X
X
X
java.awt.font
Utiliser les fontes
   
X
X
X
X
X
X
X
java.awt.geom
dessiner des formes géométriques
   
X
X
X
X
X
X
X
java.awt.im      
X
X
X
X
X
X
java.awt.im.spi      
X
X
X
X
X
X
java.awt.image
Afficher des images
 
X
X
X
X
X
X
X
X
java.awt.image.renderable 
Modifier le rendu des images
   
X
X
X
X
X
X
X
java.awt.print
Réaliser des impressions
   
X
X
X
X
X
X
X
java.beans
Développer des composants réutilisables
 
X
X
X
X
X
X
X
X
java.beans.beancontext    
X
X
X
X
X
X
X
java.io
Gérer les flux
X
X
X
X
X
X
X
X
X
java.lang
Classes de base du langage
X
X
X
X
X
X
X
X
X
java.lang.annotation          
X
X
X
X
java.lang.instrument          
X
X
X
X
java.lang.invoke              
X
X
java.lang.management          
X
X
X
X
java.lang.ref    
X
X
X
X
X
X
X
java.lang.reflect
Utiliser la réflexion (introspection)
 
X
X
X
X
X
X
X
X
java.math
Utiliser des opérations mathématiques
 
X
X
X
X
X
X
X
X
java.net
Utiliser les fonctionnalités réseaux
X
X
X
X
X
X
X
X
X
java.nio        
X
X
X
X
X
java.nio.channels        
X
X
X
X
X
java.nio.channels.spi        
X
X
X
X
X
java.nio.charset        
X
X
X
X
X
java.nio.charset.spi        
X
X
X
X
X
java.nio.file              
X
X
java.nio.file.attribute              
X
X
java.nio.file.spi              
X
X
java.rmi
Développement d'objets distribués
 
X
X
X
X
X
X
X
X
java.rmi.activation     
X
X
X
X
X
X
X
java.rmi.dgc  
X
X
X
X
X
X
X
X
java.rmi.registry  
X
X
X
X
X
X
X
X
java.rmi.server
Gérer les objets serveurs de RMI
 
X
X
X
X
X
X
X
X
java.security
Gérer les signatures et les certifications
 
X
X
X
X
X
X
X
X
java.security.acl  
X
X
X
X
X
X
X
X
java.security.cert  
X
X
X
X
X
X
X
X
java.security.interfaces  
X
X
X
X
X
X
X
X
java.security.spec    
X
X
X
X
X
X
X
java.sql
API JDBC pour l'accès aux bases de données
 
X
X
X
X
X
X
X
X
java.text
Formater des objets en texte
 
X
X
X
X
X
X
X
X
java.text.spi            
X
X
X
java.time                
X
java.time.chrono                
X
java.time.format                
X
java.time.temporal                
X
java.time.zone                
X
java.util
Utilitaires divers
X
X
X
X
X
X
X
X
X
java.util.concurrent          
X
X
X
X
java.util.concurrent.atomic          
X
X
X
X
java.util.cocurrent.locks          
X
X
X
X
java.util.function                
X
java.util.jar
Gérer les fichiers jar
   
X
X
X
X
X
X
X
java.util.logging
Utiliser des logs
       
X
X
X
X
X
java.util.prefs
Gérer des préférences
       
X
X
X
X
X
java.util.regex
Utiliser les expressions régulières
       
X
X
X
X
X
java.util.spi            
X
X
X
java.util.stream                
X
java.util.zip
Gérer les fichiers zip
 
X
X
X
X
X
X
X
X
javax.accessibility    
X
X
X
X
X
X
X
javax.activation            
X
X
X
javax.activity          
X
X
X
X
javax.annotation            
X
X
X
javax.annotation.processing            
X
X
X
javax.crypto
Utiliser le cryptage des données
       
X
X
X
X
X
javax.crypto.interfaces        
X
X
X
X
X
javax.crypto.spec        
X
X
X
X
X
javax.imageio        
X
X
X
X
X
javax.imageio.event        
X
X
X
X
X
javax.imageio.metadata        
X
X
X
X
X
javax.imageio.plugins.bmp          
X
X
X
X
javax.imageio.plugins.jpeg        
X
X
X
X
X
javax.imageio.spi        
X
X
X
X
X
javax.imageio.stream        
X
X
X
X
X
javax.jws            
X
X
X
javax.jws.soap            
X
X
X
javax.lang.model            
X
X
X
javax.lang.model.element            
X
X
X
javax.lang.model.type            
X
X
X
javax.lang.model.util            
X
X
X
javax.management          
X
X
X
X
javax.management.loading          
X
X
X
X
javax.management.modelmbean          
X
X
X
X
javax.management.monitor          
X
X
X
X
javax.management.openmbean          
X
X
X
X
javax.management.relation          
X
X
X
X
javax.management.remote          
X
X
X
X
javax.management.remote.rmi          
X
X
X
X
javax.management.timer          
X
X
X
X
javax.naming      
X
X
X
X
X
X
javax.naming.directory      
X
X
X
X
X
X
javax.naming.event      
X
X
X
X
X
X
javax.naming.ldap      
X
X
X
X
X
X
javax.naming.spi      
X
X
X
X
X
X
javax.net        
X
X
X
X
X
javax.net.ssl
Utiliser une connexion réseau sécurisée avec SSL
       
X
X
X
X
X
javax.print        
X
X
X
X
X
javax.print.attribute        
X
X
X
X
X
javax.print.attribute.standard        
X
X
X
X
X
javax.print.event        
X
X
X
X
X
javax.rmi      
X
X
X
X
X
X
javax.rmi.CORBA      
X
X
X
X
X
X
javax.rmi.ssl          
X
X
X
X
javax.script            
X
X
X
javax.security.auth
API JAAS pour l'authentification et l'autorisation
       
X
X
X
X
X
javax.security.auth.callback        
X
X
X
X
X
javax.security.auth.kerberos        
X
X
X
X
X
javax.security.auth.login        
X
X
X
X
X
javax.security.auth.spi        
X
X
X
X
X
javax.security.auth.x500        
X
X
X
X
X
javax.security.cert        
X
X
X
X
X
javax.security.sasl          
X
X
X
X
javax.sound.midi      
X
X
X
X
X
X
javax.sound.midi.spi      
X
X
X
X
X
X
javax.sound.sampled      
X
X
X
X
X
X
javax.sound.sampled.spi      
X
X
X
X
X
X
javax.sql        
X
X
X
X
X
javax.sql.rowset          
X
X
X
X
javax.sql.rowset.serial          
X
X
X
X
javax.sql.rowset.spi          
X
X
X
X
javax.swing
Swing pour développer des interfaces graphiques
   
X
X
X
X
X
X
X
javax.swing.border
Gérer les bordures des composants Swing
   
X
X
X
X
X
X
X
javax.swing.colorchooser
Composant pour sélectionner une couleur
   
X
X
X
X
X
X
X
javax.swing.event 
Gérer des événements utilisateur des composants Swing
   
X
X
X
X
X
X
X
javax.swing.filechooser 
Composant pour sélectionner un fichier
   
X
X
X
X
X
X
X
javax.swing.plaf
Gérer l'aspect des composants Swing
   
X
X
X
X
X
X
X
javax.swing.plaf.basic    
X
X
X
X
X
X
X
javax.swing.plaf.metal
Gérer l'aspect metal des composants Swing
   
X
X
X
X
X
X
X
javax.swing.plaf.multi    
X
X
X
X
X
X
X
javax.swing.plaf.nimbus              
X
X
javax.swing.plaf.synth          
X
X
X
X
javax.swing.table     
X
X
X
X
X
X
X
javax.swing.text    
X
X
X
X
X
X
X
javax.swing.text.html    
X
X
X
X
X
X
X
javax.swing.text.html.parser    
X
X
X
X
X
X
X
javax.swing.text.rtf    
X
X
X
X
X
X
X
javax.swing.tree
Un composant de type arbre
   
X
X
X
X
X
X
X
javax.swing.undo
Gérer les annulations d'opérations d'édition
   
X
X
X
X
X
X
X
javax.tools            
X
X
X
javax.transaction      
X
X
X
X
X
X
javax.transaction.xa        
X
X
X
X
X
javax.xml          
X
X
X
X
javax.xml.bind
           
X
X
X
javax.xml.bind.annotation            
X
X
X
javax.xml.bind.annotation.adapters            
X
X
X
javax.xml.bind.attachment            
X
X
X
javax.xml.bind.helpers            
X
X
X
javax.xml.bind.util            
X
X
X
javax.xml.crypto            
X
X
X
javax.xml.crypto.dom            
X
X
X
javax.xml.crypto.dsig            
X
X
X
javax.xml.crypto.dsig.dom            
X
X
X
javax.xml.crypto.dsig.keyinfo            
X
X
X
javax.xml.crypto.dsig.spec            
X
X
X
javax.xml.datatype          
X
X
X
X
javax.xml.namespace          
X
X
X
X
javax.xml.parsers
API JAXP pour utiliser XML
       
X
X
X
X
X
javax.xml.soap            
X
X
X
javax.xml.stream            
X
X
X
javax.xml.stream.events            
X
X
X
javax.xml.stream.util            
X
X
X
javax.xml.transform
transformer un document XML avec XSLT
       
X
X
X
X
X
javax.xml.transform.dom        
X
X
X
X
X
javax.xml.transform.sax        
X
X
X
X
X
javax.xml.transform.stax            
X
X
X
javax.xml.transform.stream        
X
X
X
X
X
javax.xml.validation          
X
X
X
X
javax.xml.ws            
X
X
X
javax.xml.ws.handler
           
X
X
X
javax.xml.ws.handler.soap            
X
X
X
javax.xml.ws.http            
X
X
X
javax.xml.ws.soap            
X
X
X
javax.xml.ws.spi            
X
X
X
javax.xml.ws.spi.http            
X
X
X
javax.xml.ws.wsaddressing            
X
X
X
javax.xml.xpath          
X
X
X
X
org.ietf.jgss        
X
X
X
X
X
org.omg.CORBA    
X
X
X
X
X
X
X
org.omg.CORBA_2_3      
X
X
X
X
X
X
org.omg.CORBA_2_3.portable      
X
X
X
X
X
X
org.omg.CORBA.DynAnyPackage    
X
X
X
X
X
X
X
org.omg.CORBA.ORBPackage    
X
X
X
X
X
X
X
org.omg.CORBA.portable    
X
X
X
X
X
X
X
org.omg.CORBA.TypeCodePackage    
X
X
X
X
X
X
X
org.omg.CosNaming    
X
X
X
X
X
X
X
org.omg.CosNaming.NamingContextExtPackage    
X
X
X
X
X
X
X
org.omg.CosNaming.NamingContextPackage        
X
X
X
X
X
org.omg.Dynamic        
X
X
X
X
X
org.omg.DynamicAny        
X
X
X
X
X
org.omg.DynamicAny.DynAnyFactoryPackage        
X
X
X
X
X
org.omg.DynamicAny.DynAnyPackage        
X
X
X
X
X
org.omg.IOP        
X
X
X
X
X
org.omg.IOP.CodecFactoryPackage        
X
X
X
X
X
org.omg.IOP.CodecPackage        
X
X
X
X
X
org.omg.Messaging        
X
X
X
X
X
org.omg.PortableInterceptor        
X
X
X
X
X
org.omg.PortableInterceptor.ORBInitInfoPackage        
X
X
X
X
X
org.omg.PortableServer        
X
X
X
X
X
org.omg.PortableServer.CurrentPackage        
X
X
X
X
X
org.omg.PortableServer.POAManagerPackage        
X
X
X
X
X
org.omg.PortableServer.POAPackage        
X
X
X
X
X
org.omg.PortableServer.ServantLocatorPackage        
X
X
X
X
X
org.omg.PortableServer.portable        
X
X
X
X
X
org.omg.SendingContext      
X
X
X
X
X
X
org.omg.stub.java.rmi      
X
X
X
X
X
X
org.w3c.dom
Utiliser DOM pour un document XML
       
X
X
X
X
X
org.w3c.dom.bootstrap          
X
X
X
X
org.w3c.dom.events          
X
X
X
X
org.w3c.dom.ls          
X
X
X
X
org.w3c.dom.views                
X
org.xml.sax
Utiliser SAX pour un document XML
       
X
X
X
X
X
org.xml.sax.ext        
X
X
X
X
X
org.xml.sax.helpers        
X
X
X
X
X

 

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

 

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

 

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

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

 

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

 

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

 

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

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

 

5.2.2. La classe String

Une chaîne de caractères est contenue dans un objet de la classe java.lang.String.

On peut initialiser une variable String sans appeler explicitement un constructeur : 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'enchaîner plusieurs méthodes :

Exemple :
uneChaine = chaine.toUpperCase().trim();

L'opérateur + permet la concaténation de chaînes de caractères.

La comparaison de deux chaînes doit se faire en utilisant la méthode equals() qui compare les objets eux-mêmes et non l'opérateur == qui compare les références 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 souci d'efficacité, le compilateur ne duplique pas 2 constantes chaines de caractères : il optimise l'espace mémoire consommé 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 nième caractère de la chaîne
compareTo(String) compare la chaîne avec l'argument
concat(String) ajoute l'argument à la chaîne et renvoie la nouvelle chaîne
endsWith(String) vérifie si la chaîne se termine par l'argument
equalsIgnoreCase(String) compare la chaîne sans tenir compte de la casse
indexOf(String) renvoie la première position de l'argument dans la chaîne ou null
lastIndexOf(String) renvoie la dernière position de l'argument dans la chaîne ou null
length() renvoie la longueur de la chaîne
replace(char,char) renvoie la chaîne en remplaçant les occurrences du caractère fourni
startsWith(String int) vérifie si la chaîne commence par la sous chaîne
substring(int,int) renvoie une partie de la chaine
toLowerCase() renvoie la chaîne en minuscule
toUpperCase() renvoie la chaîne en majuscule
trim() enlève les caractères non significatifs de la chaîne

La méthode isEmtpy()  ajoutée dans Java SE 6 facilite le test d'une chaîne de caractères vide.

Cette méthode utilise les données de l'instance de l'objet, il est donc nécessaire de vérifier que cette instance n'est pas null pour éviter la levée d'une exception de type NullPointerException.

Exemple :
package com.jmdoudoux.test.java6;

public class TestEmptyString {
    
  public static void main(String args[]) {
        
    String chaine = null;
    try {
      if (chaine.isEmpty()){
        System.out.println("la chaine est vide");
      }
    } catch (Exception e) {
      System.out.println("la chaine est null");
    }
        
    chaine = "test";
    if (chaine.isEmpty()){
      System.out.println("la chaine est vide");
    } else  {
      System.out.println("la chaine n'est pas vide");
    }
        
    chaine = "";
    if (chaine.isEmpty()){
      System.out.println("la chaine est vide");
    } else  {
      System.out.println("la chaine n'est pas vide");
    }   
  }    
}
Résultat :
la chaine est null
la chaine n'est pas vide
la chaine est vide

 

5.2.3. La classe StringBuffer

Les objets de cette classe contiennent des chaînes de caractères variables, ce qui permet de les agrandir ou de les réduire. Cet objet peut être utilisé pour construire ou modifier une chaîne 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 coûteux en temps d'exécution

La classe StringBuffer dispose de nombreuses méthodes qui permettent de modifier le contenu de la chaîne de caractères.

Exemple ( code Java 1.1 ) :
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();
  }
}

 

Résultat :
CHAINE AVEC MAJ ET DES MIN

 

5.2.4. Les wrappers

Les objet de type wrappers (enveloppeurs) 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 :

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 interchangeables avec les types primitifs d'origine car il s'agit d'objets.

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() où 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 :

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

Float.isNaN(float); // pour les float
Double.isInfinite(double); // idem pour les double

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.2.5. La classe System

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

 

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

Variable Type Rôle
in InputStream Entrée standard du système. Par défaut, c'est le clavier
out PrintStream 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 System possède trois méthodes qui permettent de rediriger ces flux : setIn(InputStream), setOut(PrintStream) et setErr(PrintStream).

a partir de Java 5 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().

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

La méthode printf() propose :

Exemple (java 1.5):
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());
  }
}
Résultat :
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.

Exemple (java 1.5):
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)

 

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

Exemple :
java.lang.Error: getenv no longer  supported, use properties and -D instead: windir
      at  java.lang.System.getenv(System.java:691)
      at  com.jmd.test.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 :

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 de 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 lignes
user.name Nom de l'utilisateur courant
user.home Répertoire d'accueil du user courant
user.dir Répertoire courant au moment de l'initialisation de la propriété

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

Exemple : obtenir une variable système (java 1.1, 1.2, 1.3 et 1.4)
package com.jmd.test;

public class TestPropertyEnv {

  public static void main(String[] args) {
    System.out.println("env.windir ="+System.getProperty("env.windir"));
  }
}
Exemple : Execution
C:\tests>java -Denv.windir=%windir% -cp . com.jmd.test.TestPropertyEnv
env.windir =C:\WINDOWS

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

Exemple (Java 5):
package com.jmd.tests;

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.

Exemple (Java 5) :
package com.jmd.tests;

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

 

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

Exemple :
package com.jmd.tests;

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  :

Méthode

Remarque

Process exec(String command)

 

Process exec(String[] cmdarray)

 

Process exec(String[] cmdarray, String[] envp)

 

Process exec(String[] cmdarray, String[] envp, File dir)

(depuis Java 1.3)

Process exec(String cmd, String[] envp)

 

Process exec(String command, String[] envp, File dir)

(depuis Java 1.3)


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.

Exemple :
package com.jmd.tests;

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

Exemple :
package com.jmd.tests;

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.

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

 

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

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

 

5.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étaille l'utilisation de ce package.

 

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

 

5.5.1. La classe StringTokenizer

Cette classe permet de découper une chaîne de caractères (objet de type String) en fonction de séparateurs. Le constructeur de la classe accepte 2 paramètres : la chaîne à décomposer et une chaîne 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 booléen indiquant s'il reste encore des éléments.

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

 

5.5.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.5.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 à 0 heure GMT.

a partir de Java 1.1
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.

Exemple ( code Java 1.1 ) :
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 ");
  }
}
Résultat :
 nous sommes lundi 

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

 

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

Exemple :
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»

 

5.5.5. 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 énumeration 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'objets 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 (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).

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

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

 

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

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

 

5.5.7. 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'énumération contient encore un ou plusieurs éléments
Object nextElement() retourne l'objet suivant de l'énumération
Elle lève 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.5.8. La manipulation d'archives zip

a partir de Java 1.1 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 :

Constructeur

Rôle

ZipFile(File)

ouvre l'archive correspondant au fichier fourni en paramètre

ZipFile(File, int)

ouvre l'archive correspondant au fichier fourni en paramètre selon le mode précisé : OPEN_READ ou OPEN_READ | OPEN_DELETE

ZipFile(string)

ouvre l'archive dont le nom de fichier est fourni en paramètre


Exemple :
   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  :

Méthode

Rôle

Enumeration entries()

Obtenir une énumération des entrées de l'archive sous la forme d'objets de type ZipEntry

close()

Fermer l'archive

ZipEntry getEntry(String)

Renvoie l'entrée dont le nom est précisé en paramètre

InputStream getInputStream(ZipEntry)

Renvoie un flux de lecture pour l'entrée précisée


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  :

Méthode

Rôle

getName()

Renvoie le nom de l'entrée (nom du fichier avec sa sous-arborescence dans l'archive)

getTime() / setTime()

Renvoie ou modifie la date de modification de l'entrée

getComment() / setComment()

Renvoie ou modifie le commentaire associé à l'entrée

getSize() / setSize()

Renvoie ou modifie la taille de l'entrée non compressée

getCompressedSize() / setCompressedSize()

Renvoie ou modifie la taille de l'entrée compressée

getCrc() / setCrc()

Renvoie ou modifie la somme de contrôle permettant de vérifier l'intégrité de l'entrée

getMethod() / setMethod()

Renvoie ou modifie la méthode utilisée pour la compression

isDirectory()

Renvoie un booléen précisant si l'entrée est un répertoire


Exemple : afficher le contenu d'une archive
  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  :

Méthode

Rôle

setMethod()

Modifier la méthode de compression utilisée par défaut. Les valeurs possibles sont STORED (aucune compression) ou DEFLATED (avec compression)

setLevel()

Modifier le taux de compression : les valeurs entières possibles vont de 0 à 9 où 9 correspond au taux de compression le plus élevé. Des constantes sont définies dans la classe Deflater : Deflater.BEST_COMPRESSION, Deflater.DEFAULT_COMPRESSION, Deflater.BEST_SPEED, Deflater.NO_COMPRESSION

putNextEntry(ZipEntry)

Permet de se positionner dans l'archive pour ajouter l'entrée fournie en paramètre

write(byte[] b, int off, int len)

Permet d'écrire un tableau d'octets dans l'entrée courante

closeEntry()

Fermer l'entrée courante et se positionne pour ajouter l'entrée suivante

close()

Fermer le flux


Exemple : compresser un fichier dans une archive
  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  :

Méthode

Rôle

getNextEntry()

Permet de se positionner sur l'entrée suivante dans l'archive

read(byte[] b, int off, int len)

permet de lire un tableau d'octets dans l'entrée courante

close()

permet de fermer le flux

 

Exemple :
  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();
    }
  }

 

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

Classe

Rôle

Matcher

comparer une chaîne de caractères 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.5.9.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 :

méta caractères

rôle

() créer des groupes
[]

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

^

début de la ligne

$

fin de la ligne

|

le motif précédent ou le motif suivant

?

motif précédent répété zéro ou une fois

*

motif précédent répété zéro ou plusieurs fois

+

motif précé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 (ligne 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 crochets.

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

tous sauf un chiffre

\w

une lettre ou un underscore

\W

tous sauf une lettre ou un underscore

\s

un séparateur (espace, tabulation, retour chariot, ...)

\S

tous sauf un séparateur


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

méta caractè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 précédent répété zéro ou une fois

*

motif précédent repété zéro ou plusieurs fois

+

motif précédent répété une ou plusieurs fois


Exemple : la chaîne AAAAA
A{5}

 

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

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 intéressante 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 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.

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

 

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

Exemple :
      motif = Pattern.compile("liste[0-9]");
      matcher = motif.matcher("liste1");
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 rechercher le motif dans la chaîne à traiter.

Exemple :
            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 où le motif est trouvé dans la chaîne à 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 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.

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

Exemple : remplacement de la première occurrence
        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 occurrences
      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.10. La classe Formatter

a partir de Java 5 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.

Exemple (java 1.5) :
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);
 
  }
	
}
Résultat :
C:\tiger>java TestFormatter
chaine = 0013

 

5.5.11. La classe Scanner

A partir de Java 5 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.

Exemple (java 1.5) :
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

Exemple (java 1.5) :
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.

Exemple (java 1.5) :
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.

 

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

 

5.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»

 

 


[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]

72 commentaires Donner une note à l'article (5)

 

Copyright (C) 1999-2016 Jean-Michel DOUDOUX. Vous pouvez copier, redistribuer et/ou modifier ce document selon les termes de la Licence de Documentation Libre GNU, Version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation; les Sections Invariantes étant constitués du chapitre Préambule, aucun Texte de Première de Couverture, et aucun Texte de Quatrième de Couverture. Une copie de la licence est incluse dans la section GNU FreeDocumentation Licence. La version la plus récente de cette licence est disponible à l'adresse : GNU Free Documentation Licence.

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