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 :
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 :
Java |
||||||||||||
Packages | 1.0 |
1.1 |
1.2 |
1.3 |
1.4 |
1.5 |
6.0 |
7.0 |
8.0 |
9 |
10 |
11 |
java.applet Développement des applets |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
java.awt Toolkit pour interfaces graphiques |
X |
X |
X |
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 |
X |
X |
X |
||
java.awt.datatransfer Echanger des données par le presse-papier |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.awt.desktop | X |
X |
X |
|||||||||
java.awt.dnd Gérer le cliquer/glisser |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.awt.event Gérer les événements utilisateurs |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.awt.font Utiliser les fontes |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.awt.geom dessiner des formes géométriques |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.awt.im | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
java.awt.im.spi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
java.awt.image Afficher des images |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.awt.image.renderable Modifier le rendu des images |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.awt.print Réaliser des impressions |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.beans Développer des composants réutilisables |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.beans.beancontext | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.io Gérer les flux |
X |
X |
X |
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 |
X |
X |
X |
java.lang.annotation | X |
X |
X |
X |
X |
X |
X |
|||||
java.lang.instrument | X |
X |
X |
X |
X |
X |
X |
|||||
java.lang.invoke | X |
X |
X |
X |
X |
|||||||
java.lang.management | X |
X |
X |
X |
X |
X |
X |
|||||
java.lang.module | X |
X |
X |
|||||||||
java.lang.ref | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.lang.reflect Utiliser la réflexion (introspection) |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.math Utiliser des opérations mathématiques |
X |
X |
X |
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 |
X |
X |
X |
java.net.http | X |
|||||||||||
java.net.spi | X |
X |
X |
|||||||||
java.nio | X |
X |
X |
X |
X |
X |
X |
X |
||||
java.nio.channels | X |
X |
X |
X |
X |
X |
X |
X |
||||
java.nio.channels.spi | X |
X |
X |
X |
X |
X |
X |
X |
||||
java.nio.charset | X |
X |
X |
X |
X |
X |
X |
X |
||||
java.nio.charset.spi | X |
X |
X |
X |
X |
X |
X |
X |
||||
java.nio.file | X |
X |
X |
X |
X |
|||||||
java.nio.file.attribute | X |
X |
X |
X |
X |
|||||||
java.nio.file.spi | X |
X |
X |
X |
X |
|||||||
java.rmi Développement d'objets distribués |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.rmi.activation | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.rmi.dgc | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.rmi.registry | X |
X |
X |
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 |
X |
X |
X |
|
java.security Gérer les signatures et les certifications |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.security.acl | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.security.cert | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.security.interfaces | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.security.spec | X |
X |
X |
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 |
X |
X |
X |
|
java.text Formater des objets en texte |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
java.text.spi | X |
X |
X |
X |
X |
X |
||||||
java.time | X |
X |
X |
X |
||||||||
java.time.chrono | X |
X |
X |
X |
||||||||
java.time.format | X |
X |
X |
X |
||||||||
java.time.temporal | X |
X |
X |
X |
||||||||
java.time.zone | X |
X |
X |
X |
||||||||
java.util Utilitaires divers |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
java.util.concurrent | X |
X |
X |
X |
X |
X |
X |
|||||
java.util.concurrent.atomic | X |
X |
X |
X |
X |
X |
X |
|||||
java.util.cocurrent.locks | X |
X |
X |
X |
X |
X |
X |
|||||
java.util.function | X |
X |
X |
X |
||||||||
java.util.jar Gérer les fichiers jar |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
java.util.logging Utiliser des logs |
X |
X |
X |
X |
X |
X |
X |
X |
||||
java.util.prefs Gérer des préférences |
X |
X |
X |
X |
X |
X |
X |
X |
||||
java.util.regex Utiliser les expressions régulières |
X |
X |
X |
X |
X |
X |
X |
X |
||||
java.util.spi | X |
X |
X |
X |
X |
X |
||||||
java.util.stream | X |
X |
X |
X |
||||||||
java.util.zip Gérer les fichiers zip |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
|
javax.accessibility | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.activation | X |
X |
X |
X |
X |
|||||||
javax.activity | X |
X |
X |
X |
X |
X |
||||||
javax.annotation | X |
X |
X |
X |
X |
X |
||||||
javax.annotation.processing | X |
X |
X |
X |
X |
X |
||||||
javax.crypto Utiliser le cryptage des données |
X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.crypto.interfaces | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.crypto.spec | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio.event | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio.metadata | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio.plugins.bmp | X |
X |
X |
X |
X |
X |
X |
|||||
javax.imageio.plugins.jpeg | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio.plugins.tiff | X |
X |
||||||||||
javax.imageio.spi | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.imageio.stream | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.jnlp | X |
|||||||||||
javax.jws | X |
X |
X |
X |
X |
|||||||
javax.jws.soap | X |
X |
X |
X |
X |
|||||||
javax.lang.model | X |
X |
X |
X |
X |
X |
||||||
javax.lang.model.element | X |
X |
X |
X |
X |
X |
||||||
javax.lang.model.type | X |
X |
X |
X |
X |
X |
||||||
javax.lang.model.util | X |
X |
X |
X |
X |
X |
||||||
javax.management | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.loading | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.modelmbean | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.monitor | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.openmbean | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.relation | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.remote | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.remote.rmi | X |
X |
X |
X |
X |
X |
X |
|||||
javax.management.timer | X |
X |
X |
X |
X |
X |
X |
|||||
javax.naming | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.naming.directory | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.naming.event | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.naming.ldap | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.naming.spi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.net | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.net.ssl Utiliser une connexion réseau sécurisée avec SSL |
X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.print | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.print.attribute | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.print.attribute.standard | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.print.event | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.rmi | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.rmi.CORBA | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.rmi.ssl | X |
X |
X |
X |
X |
X |
X |
|||||
javax.script | X |
X |
X |
X |
X |
X |
||||||
javax.security.auth API JAAS pour l'authentification et l'autorisation |
X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.auth.callback | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.auth.kerberos | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.auth.login | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.auth.spi | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.auth.x500 | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.cert | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.security.sasl | X |
X |
X |
X |
X |
X |
X |
|||||
javax.smartcardio | X |
X |
X |
|||||||||
javax.sound.midi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.sound.midi.spi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.sound.sampled | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.sound.sampled.spi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
javax.sql | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.sql.rowset | X |
X |
X |
X |
X |
X |
X |
|||||
javax.sql.rowset.serial | X |
X |
X |
X |
X |
X |
X |
|||||
javax.sql.rowset.spi | X |
X |
X |
X |
X |
X |
X |
|||||
javax.swing Swing pour développer des interfaces graphiques |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.border Gérer les bordures des composants Swing |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.colorchooser Composant pour sélectionner une couleur |
X |
X |
X |
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 |
X |
X |
X |
||
javax.swing.filechooser Composant pour sélectionner un fichier |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.plaf Gérer l'aspect des composants Swing |
X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.plaf.basic | X |
X |
X |
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 |
X |
X |
X |
||
javax.swing.plaf.multi | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.plaf.nimbus | X |
X |
X |
X |
X |
|||||||
javax.swing.plaf.synth | X |
X |
X |
X |
X |
X |
X |
|||||
javax.swing.table | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.text | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.text.phpl | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.text.phpl.parser | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.text.rtf | X |
X |
X |
X |
X |
X |
X |
X |
X |
X |
||
javax.swing.tree Un composant de type arbre |
X |
X |
X |
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 |
X |
X |
X |
||
javax.tools | X |
X |
X |
X |
X |
X |
||||||
javax.transaction | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.transaction.xa | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml | X |
X |
X |
X |
X |
X |
X |
|||||
javax.xml.bind |
X |
X |
X |
X |
X |
|||||||
javax.xml.bind.annotation | X |
X |
X |
X |
X |
|||||||
javax.xml.bind.annotation.adapters | X |
X |
X |
X |
X |
|||||||
javax.xml.bind.attachment | X |
X |
X |
X |
X |
|||||||
javax.xml.bind.helpers | X |
X |
X |
X |
X |
|||||||
javax.xml.bind.util | X |
X |
X |
X |
X |
|||||||
javax.xml.catalog | X |
X |
X |
|||||||||
javax.xml.crypto | X |
X |
X |
X |
X |
X |
||||||
javax.xml.crypto.dom | X |
X |
X |
X |
X |
X |
||||||
javax.xml.crypto.dsig | X |
X |
X |
X |
X |
X |
||||||
javax.xml.crypto.dsig.dom | X |
X |
X |
X |
X |
X |
||||||
javax.xml.crypto.dsig.keyinfo | X |
X |
X |
X |
X |
X |
||||||
javax.xml.crypto.dsig.spec | X |
X |
X |
X |
X |
X |
||||||
javax.xml.datatype | X |
X |
X |
X |
X |
X |
X |
|||||
javax.xml.namespace | X |
X |
X |
X |
X |
X |
X |
|||||
javax.xml.parsers API JAXP pour utiliser XML |
X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml.soap | X |
X |
X |
X |
X |
|||||||
javax.xml.stream | X |
X |
X |
X |
X |
X |
||||||
javax.xml.stream.events | X |
X |
X |
X |
X |
X |
||||||
javax.xml.stream.util | X |
X |
X |
X |
X |
X |
||||||
javax.xml.transform transformer un document XML avec XSLT |
X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml.transform.dom | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml.transform.sax | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml.transform.stax | X |
X |
X |
X |
X |
X |
||||||
javax.xml.transform.stream | X |
X |
X |
X |
X |
X |
X |
X |
||||
javax.xml.validation | X |
X |
X |
X |
X |
X |
X |
|||||
javax.xml.ws | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.handler |
X |
X |
X |
X |
X |
|||||||
javax.xml.ws.handler.soap | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.http | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.soap | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.spi | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.spi.http | X |
X |
X |
X |
X |
|||||||
javax.xml.ws.wsaddressing | X |
X |
X |
X |
X |
|||||||
javax.xml.xpath | X |
X |
X |
X |
X |
X |
X |
|||||
org.ietf.jgss | X |
X |
X |
X |
X |
X |
X |
X |
||||
org.omg.CORBA | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CORBA_2_3 | X |
X |
X |
X |
X |
X |
X |
X |
||||
org.omg.CORBA_2_3.portable | X |
X |
X |
X |
X |
X |
X |
X |
||||
org.omg.CORBA.DynAnyPackage | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CORBA.ORBPackage | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CORBA.portable | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CORBA.TypeCodePackage | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CosNaming | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CosNaming.NamingContextExtPackage | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.omg.CosNaming.NamingContextPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.Dynamic | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.DynamicAny | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.DynamicAny.DynAnyFactoryPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.DynamicAny.DynAnyPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.IOP | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.IOP.CodecFactoryPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.IOP.CodecPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.Messaging | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableInterceptor | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableInterceptor.ORBInitInfoPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer.CurrentPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer.POAManagerPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer.POAPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer.ServantLocatorPackage | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.PortableServer.portable | X |
X |
X |
X |
X |
X |
X |
|||||
org.omg.SendingContext | X |
X |
X |
X |
X |
X |
X |
X |
||||
org.omg.stub.java.rmi | X |
X |
X |
X |
X |
X |
X |
X |
X |
|||
org.w3c.dom Utiliser DOM pour un document XML |
X |
X |
X |
X |
X |
X |
X |
X |
||||
org.w3c.dom.bootstrap | X |
X |
X |
X |
X |
X |
X |
|||||
org.w3c.dom.css | X |
X |
X |
|||||||||
org.w3c.dom.events | X |
X |
X |
X |
X |
X |
X |
|||||
org.w3c.dom.phpl | X |
X |
X |
|||||||||
org.w3c.dom.ls | X |
X |
X |
X |
X |
X |
X |
|||||
org.w3c.dom.ranges | X |
X |
X |
|||||||||
org.w3c.dom.stylesheets | X |
X |
X |
|||||||||
org.w3c.dom.traversal | X |
X |
X |
|||||||||
org.w3c.dom.views | X |
X |
X |
X |
||||||||
org.w3c.dom.xpath | X |
X |
X |
|||||||||
org.xml.sax Utiliser SAX pour un document XML |
X |
X |
X |
X |
X |
X |
X |
X |
||||
org.xml.sax.ext | X |
X |
X |
X |
X |
X |
X |
X |
||||
org.xml.sax.helpers | X |
X |
X |
X |
X |
X |
X |
X |
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.
C'est la super classe de toutes les classes Java : toutes ses méthodes sont donc héritées par toutes les classes.
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();
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.
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.
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;
}
}
}
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().
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
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
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)
Cette classe possède de nombreuses fonctionnalités pour utiliser des services du système d'exploitation.
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).
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)
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));
}
}
}
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\"");
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.
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.
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.
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
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);
}
}
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.
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»
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»
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.
Remarque : A partir de Java 1.2, il est préférable d'utiliser une classe de «Les collections». |
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.
Remarque : A partir de Java 1.2, il est préférable d'utiliser une classe de «Les collections». |
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
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();
}
}
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 |
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}
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");
}
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
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
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.
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.
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»