Vous êtes sur la page 1sur 157

FAQ Java

Date de publication : 12/10/2006

Dernière mise à jour : 07/06/2009

Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette faq ne garantit en aucun cas que les informations
qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est
humaine. Cette faq ne prétend pas non plus être complète. Si vous trouvez une erreur,
ou que vous souhaitez nous aider en devenant rédacteur, lisez Comment participer à
cette faq ?.

Sur ce, nous vous souhaitons une bonne lecture.

L'équipe Java
Ont contribué à cette FAQ :

bazinou - bobuse - iubito - Clément Cunin - Johann Heymes -


Ronan Le Gallo - Christophe Ludet - Jean-Baptiste Bugeaud
- Grégory Danelon - Sébastien Meric - Romain Guy - Pierre-
Yves Varoux - Ioan Calapodescu - bahamouth - duj - braim
- bulbo - Ricky81 - L'équipe Java - Debernad - jcarre -
Seigne David - cyberzoide - xavlours - christopheJ - willowII
- Nourdine Falola - laffreuxthomas - adiGuba - aDamas -
mavina - Baptiste Wicht - NiCo5130 - elitost - jeje99 - afrikha
- Morpheus2144 - vasilov - le y@m's - romuluslepunk -
JMLLB - djo.mos - glob - osopardo - sironimo - divxdede -
natha - Pierre Chauvin - tchize - sinok - mlny84 - gifffftane -
FAQ Java

1. Informations générales (5) .........................................................................................................................................................4


2. Concepts fondamentaux (52) .....................................................................................................................................................7
2.1. Les mots-clés (17) .......................................................................................................................................................... 17
2.2. Les notions (17) ..............................................................................................................................................................30
3. Généralités (79) ....................................................................................................................................................................... 47
3.1. Gestion des nombres et chaînes de caractères (25) ....................................................................................................... 48
3.2. Gestion des dates (8) ...................................................................................................................................................... 65
3.3. Gestion des threads (6) ...................................................................................................................................................69
3.4. Structures de données -Tableaux et collections (18) ..................................................................................................... 72
3.5. La reflexivité (16) ...........................................................................................................................................................84
3.6. De C++ à Java (4) ..........................................................................................................................................................91
3.7. JNI (2) .............................................................................................................................................................................93
4. Fichiers, flux et réseaux (32) .................................................................................................................................................. 95
4.1. Flux et fichiers (21) ........................................................................................................................................................96
4.2. Sérialisation (4) .............................................................................................................................................................108
4.3. Réseaux (7) ................................................................................................................................................................... 110
5. Le développement (23) ..........................................................................................................................................................115
5.1. Installation et compilation (2) ...................................................................................................................................... 116
5.2. Exécution (6) ................................................................................................................................................................ 118
5.3. Les erreurs et exceptions (7) ........................................................................................................................................ 122
5.4. Les warnings (8) ........................................................................................................................................................... 125
6. Système (14) .......................................................................................................................................................................... 131
7. Astuces et divers (25) ............................................................................................................................................................139

-3-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Informations générales


Comment bien utiliser cette faq ?
Auteurs : L'équipe Java ,
Le but :
Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples et
complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).

L'organisation :
Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes. Lorsqu'une question
porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus facile.

Les réponses :
Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à télécharger
contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé de
localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers la
documentation en ligne de Sun ou vers un autre site en rapport.

Nouveautés et mises à jour :


Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté du titre de la question.
Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement les modifications
apportées.

J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.

lien : Comment participer à cette faq ?

Comment participer à cette faq ?


Auteurs : L'équipe Java ,
Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :

Rédacteur :
Bien évidemment, toute nouvelle question/réponse est la bienvenue.

Web designer :
Toute personne capable de faire une meilleur mise en page, une feuille de style ou de belles images...

Correcteur :

-4-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Malgré nos efforts des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les administrateurs
si vous en débusquez une... Idem pour les liens erronés.

lien : Quels sont les droits de reproduction de cette FAQ ?

Quels sont les droits de reproduction de cette FAQ ?


Auteurs : L'équipe Java ,
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le
reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.

Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :

- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la licence GNU FDL traduite
en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et
Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission
vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".

- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon
la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Où trouver d'autres sources d'information ?


Auteurs : L'équipe Java ,

Les cours et didacticiels de www.developpez.com

Les forums de la section Java de www.developpez.com

La FAQ Struts

La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.

Les didacticiels de Sun

La FAQ de JGuru, beaucoup plus complète que celle-ci ...

Remerciements
Auteurs : L'équipe Java ,
Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.

Aux rédacteurs :
Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.
Clément Cunin, Johann Heymes, Nicolas Cuny, Ronan Le Gallo, Christophe Ludet, Jean-Baptiste Bugeaud, Sebastien
Andreo, Grégory Danelon, Sébastien Meric, Romain Guy, Pierre-Yves Varoux, Ioan, bahamouth, duj, Braim, bulbo,
Ricky81, Debernad, jcarre, David Seigne, xavlours, christopheJ, willowII, Nourdine Falola, laffreuxthomas.

Aux correcteurs :
Remerciements également aux personnes qui ont relu les textes pour supprimer un maximum de fautes de français.

-5-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Nicolas Cuny, Jonathan Muller, Etienne Bar, Bestiol, Ukyuu.

Aux visiteurs :
Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques, nous ont aidé à la
perfectionner.

Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo et
ses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisation
de ce document.

-6-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Concepts fondamentaux


Qu'est-ce que Java ?
Auteurs : Clément Cunin ,
Java est un langage orienté objet développé par la société Sun. La syntaxe générale est très proche de celle du C, mais
Java n'est pas une surcouche du C et la syntaxe est beaucoup plus claire que celle du C++.

Les avantages :
Les avantages de Java son nombreux. Le byte-code, tout d'abord, qui assure à Java une portabilité complète vers de très
nombreux systèmes. L'importance de l'api de base qui offre tous les services de base, notamment pour la construction
des interfaces graphiques. La 3ème force de Java, c'est son adaptabilité dans de nombreux domaines, autant pour le
web que pour les systèmes embarqués.

Liste des Système disposant d'une implémentation de Java :


Windows 3.1/95/98/NT4/2000/ME/XP/CE, MacOS, Solaris, Linux, AIX, OS/2, IRIX, UnixWare, HP/UX, Digital Unix,
AmigaOS, BeOS, OpenVMS, FreeBSD, SunOS, RiscOS

Cette liste n'est pas exhaustive et est donnée à titre d'exemple.

Que sont le JRE, le JDK et le SDK ?


Auteurs : Clément Cunin ,
JRE :
Java Runtime Environement, c'est le kit destiné au client pour pouvoir exécuter un programme Java. Il se compose
essentiellement d'une machine virtuelle Java (JVM) capable d'exécuter le byte-code et les bibliothèques standard de
Java.

SDK :
Standard Development Kit, c'est le kit destiné au programmeur. Ce kit est composé d'un JRE, d'un compilateur et de
nombreux programmes utiles, des exemples de programmes Java, les sources de toutes les classes de l'api.

JDK :
Java Development Kit, c'est l'ancien nom du SDK. Le JDK a été renommé SDK depuis la version 1.2.2.

Comment installer le JDK ?


Auteurs : natha ,
Windows

Télécharger le JDK
Rendez-vous à cette page pour trouver les dernières versions disponibles.

Téléchargez celui intitulé "JDK 6 Update 5" (en date de cette FAQ). Il contient également le JRE de la même version
(donc inutile de télécharger le JDK ET le JRE). Ce téléchargement conviendra à toute utilisation standard de Java :
applet, application Desktop, application console.

Installer

-7-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Suivez les étapes d'installation. Je vous conseillerais sous Windows d'installer le JDK dans un répertoire C:\Java
\jdk_1.6.0_05 (1.6.0_05 pouvant changer selon la version). Idem pour le JRE dans C:\Java\jre_1.6.0_05 . Ceci par
commodité et d'éviter ainsi l'utilisation du classique "Program Files" pouvant être pénible à l'utilisation à cause de
l'espace.

Il va falloir ensuite positionner la variable d'environnement PATH afin de pouvoir exécuter les programmes du JDK
de n'importe où (javac, etc.) :

• Ouvrez les propriétés du "Poste de travail" ("clic-droit/propriétés" sur l'icône OU "Panneau de configuration/
Système").
• Allez dans l'onglet "Avancé" puis cliquez sur le bouton "Variables d'environnement".
• Créez une nouvelle variable utilisateur en cliquant sur le bouton "Nouveau".
• Donnez le nom "Path" et comme valeur le chemin vers le répertoire bin de votre installation du JDK (n'oubliez
pas le répertoire "bin").
• Validez ces modifications en cliquant sur le bouton "OK".
• Pour tester votre installation, lancez un terminal : Démarrer/Exécuter puis "cmd"
• Tapez "javac -version", vous devriez avoir ce genre de résultat : "javac 1.6.0_05".

Linux (via apt-get ou synaptic)

Pour télécharger, installer et configurer le JDK, il vous suffit d'installer les derniers paquets proposés dans les dépôts
de votre distribution.

Sous Ubuntu par exemple j'ai les paquets sun-java6-jdk, sun-java6-jre et sun-java6-source (sans oublier les dépendances
proposées automatiquement). Le 3e, sun-java6-source, permet d'installer le src.zip du JDK contenant les sources. Livré
séparément il permet d'avoir une autocomplétion détaillée dans les IDE modernes (à moins que vous ne connaissiez
l'API par coeur).

Et voilà ! Vous pouvez compiler du code Java !

lien : Que sont le JRE, le JDK et le SDK ?

Où puis-je trouver le jre/jdk pour Mac ?


Auteurs : bulbo ,
Contrairement aux autres plateformes, il n'est pas distribué par Sun mais par Apple. Il est possible de le télécharger
sur le site suivant:
http://www.apple.com/macosx/features/java
Remarque: La dernière version disponible au moment de l'écriture de cette question est la 5.0.

Il faut noter qu'il est aussi possible de télécharger le JDK 6 pour les développeurs ici.

Quelle sont les différences entre application, applet et servlet ?


Auteurs : Clément Cunin ,
Application :
Une application Java est un programme utilisant le langage de programmation Java et qui tourne généralement sur la
machine où se trouve au départ le code. Il a le même but qu'un programme C ou d'un autre langage.

Applet :

-8-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

L'applet est récupérée à distance à travers un navigateur Web et s'exécute sur celui-ci. En raison de ce téléchargement à
distance, les règles de sécurité concernant les applets sont très strictes ( pour éviter notamment les virus ). Par exemple,
une applet ( contrairement à une application ), ne permet pas forcément l'écriture sur le disque local ou l'impression.

Servlet :
Une servlet peut être considéré comme une applet coté serveur. Une servlet est destinée à ajouter des fonctionnalités
à un serveur web.

Où peut-on trouver les sources des classes de l'API de Sun ?


Auteurs : Clément Cunin ,
Où ?
Sun distribue le code source de toutes les classes de l'API avec le JDK (installation de composant optionnel !). Vous
pouvez donc retrouver les sources dans le fichier 'src.jar', dans le répertoire d'installation du JDK.

Pourquoi ?
Même si cette cette approche n'est pas à conseiller aux débutants, il peut parfois être très utile de consulter le code
source des classes l'API. Cela peut permettre, par exemple, d'estimer la complexité de certains algorithmes, ou de mieux
comprendre le fonctionnement d'un objet particulier (et ainsi le surcharger plus efficacement). En cherchant bien, on
peut également trouver des classes non documentées...

lien : Que sont le JRE, le JDK et le SDK ?

Qu'est-ce que Java Web Start ?


Auteurs : Ronan Le Gallo , Clément Cunin , Jean-Baptiste Bugeaud ,
JavaWebStart est l'implémentation de référence par Sun de la spécification JNLP (JavaNetworkLaunchingProtocol)
qui définit un mécanisme d'installation et de mise à jour supportant des fonctionnalités évoluées grâce à HTTP et XML.

L'idée de JWS est de "mimer" le comportement d'une applet pour une application Java. Un serveur héberge
l'application ; le client Web Start se connecte au serveur, télécharge l'application et l'exécute. Les règles de sécurité
sont semblables à celles des applets.

L'intérêt principal est la facilité de déploiement des applications. Lors d'une mise à jour, seul le serveur est à modifier,
les clients téléchargeront la nouvelle application au prochain démarrage. Ce système est très intéressant pour les grosses
entreprises qui ne peuvent pas se permettre d'aller mettre à jour une application sur les milliers de postes de leurs
collaborateurs.

Les avantages :
• Fonctionnement en mode déconnecté.
• Exécution externe au browser -> intégration facile & large support.
• Mise à jour incrémentale et modulaire des applications.
• Support d'un exécution sécurisée dans un environnement de type sandbox.
• Certains services avancés accessibles sans certificat (ouverture d'un flux fichier, sauvegarde d'un flux fichier,
mécanisme de persistance entre sessions, impression, téléchargement de ressources, ...).

-9-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• Migration facile depuis une application Java standard.

lien : http://www.up2go.net/

Comment connaître la version de la JVM installée ?


Auteurs : Clément Cunin ,
Depuis une console :

java -version

Depuis un programme :
Lors de l'exécution, la version de la JVM est accessible via les propriétés système (Comment accéder aux valeurs des
variables d'environnement ?).

String version = System.getProperty("java.vm.version");

Retourne le numéro de version complet de la JVM. Ce numéro peut comporter des informations spécifique. Par
exemple : "1.5.0_06-b05"

String version = System.getProperty("java.version");

Retourne le numéro de version exacte, y compris les éventuelles updates, mais sans informations spécifiques. Par
exemple : "1.5.0_06"

String version = System.getProperty("java.specification.version");

Retourne le numéro de version des spécifications, c'est à dire le numéro de version sans les versions de mises à jours.
Par exemple : "1.5"

Quelles sont les convention de nommage en Java ?


Auteurs : Clément Cunin ,
Les variables :
Les noms variables sont écrits en minuscules sauf la première lettre de chaque de mot à partir du deuxième. Il est
également recommandé de choisir un nom de variable court mais suffisamment explicite (garder à l'esprit qu'un autre
programmeur sera peut-être obligé de comprendre votre code plus tard).

public int maVariableEntiere;

Note : Une variable peut commencer par le caractère '_' ou '$', mais c'est fortement déconseillé par SUN.

Les constantes :
Afin de bien les différencier des variables ; les constantes sont écrites en majuscule, les mots sont séparés par le caractère
'_'.

public final static int MA_CONSTANTE

- 10 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Les méthodes :
Le nom des méthodes suit les mêmes règles de construction que les variables, mais le premier mot devrait toujours être
un verbe à l'infinitif, suivi éventuellement de mots pour qualifier l'action.

Les classes et interfaces :


Les noms de classes sont écrits en minuscule, chaque première lettre d'un mot est en majuscule.

public class MaClasse

Les paquets :
Les noms de paquet sont intégralement écrits en minuscule, sans caractère de séparation. Afin d'éviter au maximum
les risques de conflit de nommage, il est recommandé de placer son travail dans un paquet commençant par un nom de
domaine internet (com, edu, gov, mil, en, fr, etc ...) suivit du nom de l'organisation ou du projet.

com.developpez.javaorg.w3c.domorg.xml.sax

lien : JavaStyle - Les conventions de codage pour Java

Qu'est ce qu'un décompilateur ?


Auteurs : Ricky81 ,
Un décompilateur est un outil permettant de récupérer le code source d'une classe ou d'un ensemble de classes à
partir d'un byte code. Sans aller aussi loin, des outils proposent tout simplement l'analyse d'une classe en affichant ses
principales caractéristiques.
C'est le cas de javap, disponible dans le SDK.

E:\>javap java.lang.Object
Compiled from "Object.java"
public class java.lang.Object{
public native int hashCode();
static {};
public java.lang.Object();
protected void finalize();
throws java/lang/Throwable
public final native void notify();
public final native void notifyAll();
public final void wait();
throws java/lang/InterruptedException
public final native void wait(long);
throws java/lang/InterruptedException
public final void wait(long,int);
throws java/lang/InterruptedException
public final native java.lang.Class getClass();
protected native java.lang.Object clone();
throws java/lang/CloneNotSupportedException
public boolean equals(java.lang.Object);
public java.lang.String toString();
}

Pour plus d'informations sur la commande javap :

- 11 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

javap -help

lien : Qu'est qu'un obfuscateur ?

Qu'est qu'un obfuscateur ?


Auteurs : Clément Cunin ,
Qu'est que c'est, quel est le but ?
Pour assurer l'indépendance de la plate-forme, les programmes Java sont distribués sous forme de bytecode, cette forme
est très proche du code source original. Le bytecode est donc très facile à décompiler ce qui augmente le risque d'une
attaque par analyse du code source (reverse engineering). Cette attaque consiste à décompiler une application pour
comprendre ce qu'elle fait exactement (dans le cas de la cryptographie) ou pour comprendre comment elle le fait (dans
le cas d'espionnage industriel).
Pour se protéger de ce type d'attaque, on peut avoir recours à un "obfuscateur". Il s'agit d'un utilitaire qui transforme
le bytecode en un bytecode équivalent mais plus difficile à décompiler.

Comment ça marche ?
Plusieurs techniques permettent de rendre plus difficile la décompilation du bytecode. La première se base sur les
principes d'optimisation du code, en réordonnant les micro-instructions. D'autres techniques, plus radicales, changent
l'organisation de la mémoire, le nom des identifiants, ajoute du code parasite ou des "goto" : le bytecode est souvent
légèrement moins rapide mais surtout très difficile à comprendre.

Quel obfuscateur en Java ?


• RetroGuard : un des meilleurs obfuscateurs Open Source.

lien : Qu'est ce qu'un décompilateur ?

Qu'est-ce que le PATH ?


Auteurs : adiGuba ,
Le PATH n'est pas une notion propre à Java, mais se retrouve dans la plupart (voir la totalité) des systèmes
d'exploitations.
Il s'agit d'une variable d'environnement qui contient une liste de répertoires dans lesquels vont être recherchés les
fichiers exécutables.

Attention, sous Unix/Linux et assimilé, les chemins sont séparés par deux-points (':'), alors que sous Windows le
séparateur est un point-virgule (';').

Ainsi, afin de pouvoir utiliser les outils du JRE/JDK, il peut être nécessaire de modifier le PATH afin d'y ajouter le
répertoire bin du JRE/JDK.

On peut modifier le PATH de manière temporaire avec les commandes suivantes (depuis une console) :

Sous Unix/Linux :

export PATH=$PATH:/_chemin_du_jdk_/bin

Sous Windows :

- 12 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

set PATH=%PATH%;C:\_chemin_du_jdk_\bin

Il est également possible de définir le PATH de manière définitive :

Sous Unix/Linux, en effectuant la manipulation ci-dessus dans le fichier de configuration de l'utilisateur (~/.bashrc).
Sous Windows via l'onglet "Avancé" des propriétés du poste de travail.

Qu'est-ce que le CLASSPATH ?


Auteurs : adiGuba ,
Le CLASSPATH permet de spécifier à la machine virtuel Java les emplacements à partir desquels les resources
(bytecode et autres) devront être recherché.
A l'instar de la variable d'environnement PATH, le CLASSPATH se présente sous la forme d'une liste d'éléments, qui
peuvent correspondre à un répertoire ou à une archive (*.jar ou *.zip).

Lorsque la machine virtuelle a besoin de charger une resource ou une classe, elle le recherche dans les divers éléments
du CLASSPATH dans l'ordre de leur déclaration.

Chaque élément du CLASSPATH correspond à une racine, et les classes sont recherchées dans les sous-répertoires
correspondant au nom de leurs packages.

Par exemple, pour un CLASSPATH comportant les deux éléments suivants :

• Le répertoire /projet/classes
• L'archive /projet/lib/archive.jar

Lors du chargement de la classe com.monsite.MaClasse, la JVM recherchera d'abord le fichier /projet/classes/com/


monsite/Maclasse.class.
Si ce dernier n'existe pas, la JVM recherchera alors le fichier com/monsite/Maclasse.class à l'intérieur de l'archive /
projet/lib/archive.jar.

lien : Comment modifier le CLASSPATH ?

Comment modifier le CLASSPATH ?


Auteurs : adiGuba ,
Il y a différentes manières de définir le CLASSPATH.

Lorsqu'on compile ou qu'on lance un programme Java, deux solutions s'offre à nous :

1) En créant une variable d'environnement CLASSPATH.

Exemple Unix/Linux :

export CLASSPATH=./lib/archive.jar:./classes
java ma.classe.Principale

Exemple Windows :

- 13 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

set CLASSPATH=./lib/archive.jar;./classes
java ma.classe.Principale

2) En utilisant les options -classpath ou -cp de java/javac.

Exemple Unix/Linux :

java -classpath ./lib/archive.jar:./classes ma.classe.Principale

Exemple Windows :

java -classpath ./lib/archive.jar;./classes ma.classe.Principale

Si la variable d'environnement CLASSPATH existe, elle est ignoré et écrasé par l'usage de ces options.

Lorsqu'on exécute un jar exécutable avec l'option -jar de java, les deux solutions précédentes ne fonctionnent pas.
La seule et unique solution consiste à renseigner l'attribut Class-Path de son fichier Manifest. A noter toutefois que le
jar exécutable fera automatiquement partie du CLASSPATH.

Lorsqu'on exécute une application Java Web Start, les différents éléments du CLASSPATH sont défini dans le
descripteur *.jnlp via l'élément resources.

Remarque : la plupart des EDIs permettent de configurer simplement le CLASSPATH depuis leur interface graphique.

lien : Qu'est-ce que le CLASSPATH ?


lien : Qu'est-ce que Java Web Start ?
lien : Comment créer un jar exécutable ?

Qu'est-ce que le BOOTCLASSPATH ?


Auteurs : adiGuba ,
Le BOOTCLASSPATH fonctionne de la même manière que le CLASSPATH, si ce n'est qu'il est prioritaire sur ce
dernier : il est utilisé pour définir les classes standards de l'API. Il dépend donc fortement de la machine virtuelle et
ne devrait donc pas être modifié

Il est toutefois possible de le remplacer ou d'y ajouter des éléments à la fin ou en tête de liste avec les options non-
standard -Xbootclasspath, -Xbootclasspath/a et -Xbootclasspath/p de la JVM de Sun (reportez-vous à la documentation
pour les autres JVM).

Attention toutefois : le fait d'utiliser cette technique pour remplacer une classe du fichier rt.jar (qui comporte toutes
les classes standard de l'API) vient à l'encontre de la licence d'utilisation de la JVM de Sun.

Quelle est la taille maximum du code d'une méthode ?


Auteurs : afrikha ,
Bien que cela ne vienne pas à l'esprit, il existe une taille maximum pour le code d'une méthode sur certaines machines
et qui est de 65535 octets. Cela peut sembler énorme et suffisant, ce qui est vrai pour la grande majorité des cas mais

- 14 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

avec les editeurs graphiques qui générent du code cette limite peut étre dépassée assez aisément : vous obtientrez alors
une erreur du type code too large.

lien : Lien sur le sujet

Quels sont les différents modes d'invocation de méthode ?


Auteurs : adiGuba ,
Selon le types des méthodes, Java dispose de quatre mode d'invocation, défini par les instructions invokevirtual,
invokespecial, invokestatic et invokeinterface.

• invokestatic permet d'invoquer les méthodes statiques, qui par définition ne sont lié à aucune instance de classe.
La résolution de la méthode est donc effectué lors de la compilation.
• invokespecial permet d'invoquer les méthodes d'instances qui peuvent être résolues dès la compilation et qui ne
dépendent donc pas du type de l'instance, c'est à dire les méthodes privées (private), les appels de méthode de la
classe parente (dont l'appel est préfixé par super), ou encore pour les appels de constructeur (ainsi que this() ou
super()).
• invokeinterface permet d'invoquer une méthode sur une référence dont le type est une interface. Etant donné
qu'il ne s'agit pas d'un type concret, la résolution de la méthode est forcément effectué à l'exécution selon le type
réel de l'instance.
• Enfin, invokevirtual permet d'invoquer les méthodes d'instances virtuelles d'une classe. C'est à dire que la
résolution de la méthode à appeler est effectué lors de l'exécution selon le type réel de l'instance.

Dans tous les cas, la présence, le nombre et le type des paramètres et des valeurs de retour sont vérifié à la compilation.

Ainsi, les méthodes invoqués avec invokeinterface et invokevirtual nécessitent un traitement supplémentaire lors de
l'exécution afin de rechercher la bonne méthode selon le type exacte de la référence sur laquelle elles sont utilisées.
Toutefois les JVMs modernes peuvent optimiser ce type d'appel de méthodes en se basant sur l'état de l'application (en
particulier le nombre et le type des classes chargées).

A noter également l'existence de la JSR-292 pour Java SE 7, dont l'objectif est d'introduire l'instruction invokedynamic
afin de mieux supporter les langages de scripts. Cette instruction serait nettement moins contraignante car elle ne
vérifierait pas la présence de la signature de méthode dans la classe à la compilation mais seulement lors de l'exécution,
et devrait introduire un mécanisme de gestion d'erreur (une méthode par défaut à appeler si la méthode demandée
n'existe pas).

Il faut préciser que ces appels se font au niveau du bytecode et non au niveau Java.

lien : JSR 292

[Java 5.0] Comment spécifier qu'un paramètre doit implémenter plusieurs interfaces ?
Auteurs : adiGuba ,
Dans le langage, on ne peut spécifier qu'un type pour un paramètre. Ainsi, si une méthode doit utiliser des objets qui
implémentent deux interfaces, on ne peut en utiliser qu'un seul dans la définition de la méthode, ce qui oblige à un cast
potentiellement dangereux à l'exécution :

public void method(Serializable data) {


Comparable cData = (Comparable) data; // throw ClassCastException
// Traitement ici
}

- 15 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Ce type de code a le désavantage de provoquer une exception si le type passé en paramètre n'implémente pas la seconde
interface.

Avec les Generics de Java 5.0 il est possible de reporter ce problème à la compilation. En effet les Generics ne se limitent
pas seulement à paramétrer des classes, ils peuvent également s'appliquer aux méthodes, et ainsi permettent donc de
spécifier plusieurs contraintes grâce à la covariance :

public <T extends Serializable & Comparable<T>> void method(T data) {


// 'data' implémente les interfaces Serializable et Comparable
// Traitement ici
}

Dans cet exemple, la méthode est paramétrée par un type T qui implémente à la fois les interfaces Serializable et
Comparable<T>. Ainsi, si la méthode est utilisée avec un objet qui n'implémente pas ces deux interfaces, le compilateur
génèrera une erreur à la compilation.

- 16 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Concepts fondamentaux > Les mots-clés


Quels sont les différents mot-clés du langage Java ?
Auteurs : Baptiste Wicht ,
Un mot-clé est tout simplement un mot qui a été reservé pour une utilisation spéciale par le langage; vous ne pouvez
donc pas employer des mots-clés comme noms de variable, ou nom de classe.

Pour avoir une liste de tous les mots-clés du langage Java et de leurs significations, vous pouvez lire cet article.

Que signifient les mots-clés public, private et protected ?


Auteurs : Ioan Calapodescu ,
Ces trois mots clefs du langage java définissent la portée d'une variable, d'une méthode ou d'une classe. Il existe en fait
quatre modificateurs d'accessibilité. Le quatrième est le modificateur vide (rien, pas de modificateur). Il ne faut pas
confondre ce dernier avec public.

Voici les caractéristiques de ces modificateurs, du plus permissif au plus restrictif :

Mot-clé Portée Remarques


public Les variables, méthodes Il ne peut y avoir qu'une
ou classes publiques sont seule classe publique
accessibles par tout objet. par .java et celle-ci doit
obligatoirement porter le
nom du fichier .java
"rien" Les variables, méthodes Attention : les variables
ou classes définies sans sans modificateur ne sont
modificateur sont accessibles pas accessibles aux classes
par toute classe appartenant fille définies dans un autre
au même package. package.
protected Les variables, méthodes
ou classes définies comme
protégées ne sont accessibles
que par les classes filles et
classes du même package..
private Les variables, méthodes Il est fortement conseillé de
ou classes définies comme déclarer comme privés tous
privées ne sont accessibles les attributs d'une classe, et
que par la classe dans de créer des méthodes de type
laquelle elles sont définies. get/set pour y accéder.

Naturellement, toute méthode, variable ou classe est accessible dans la classe ou elle est définie.

Remarque : il y a deux cas particuliers où l'abscence de mot-clé de visibilité ne correspond pas à une visibilité "package-
only" :

• Tous les membres (attributs et méthodes) d'une interface ou d'une annotation sont obligatoirement public.

- 17 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• Tous les constructeurs d'une enum sont obligatoirement private.

Que signifie le mot-clé static ?


Auteurs : Ioan Calapodescu ,
Le mot-clé static est utilisable pour des variables, méthodes, classes internes ou blocs de code.

Devant une variable ou méthode :

Le mot clé static devant une variable (ou méthode) indique que celle-ci n'appartient pas à une instance particulière de
la classe. Les variables ou méthodes statiques appartiennent à la classe elle-même. On peux ainsi les utiliser sans avoir
une instance créée. De nombreuses classes ont des membres ou méthodes statiques. Par exemple la classe Math :

System.out.println(Math.PI);
//affiche la valeur de PI
System.out.println(Math.abs(-1));
//affiche la valeur absolue de -1

Voici quelques remarques :

• On peut aussi manipuler une variable ou méthode statique à partir d'une instance de la classe.
• Pour faire des variables statiques des constantes, il faut combiner le mot-clé static avec le mot-clé final.
• Les méthodes statiques, étant indépendantes de toute instance, n'ont pas accès aux variables ou méthodes non
statiques.

Devant un bloc de code :

Le mot-clé static devant un bloc de code indique que celui-ci ne sera exécuté qu'une fois. L'exécution se fait lors du
chargement de la classe par le ClassLoader. On peut utiliser ces blocs, par exemple, pour initialiser des variables
statiques complexes.

publioc class MaClasse{


public static Map uneVariableStatique = new HashMap();
static{
uneVariableStatique.put("une clef","une valeur");
uneVariableStatique.put("une autre clef","une autre valeur");
//etc .
}
}

Devant une classe interne :

Pour plus d'informations sur ce cas, reportez à la QR Quels sont les différents types de classes internes (nested classes) ?.

lien : Que signifie le mot-clé final ?

Que signifie le mot-clé final ?


Auteurs : Clément Cunin ,
Devant une méthode :

- 18 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

On indique que cette méthode ne pourra plus être redéfinie dans une classe fille. Ce qui entraîne une certaine
optimisation dans les appels à cette méthode.

Devant une classe :


On ne peut pas créer de classe dérivée de celle-ci. Par exemple il est impossible de dériver une classe à partir de la classe
String de la bibliothèque de base. La solution consisterait à "encapsuler" String dans une classe de notre conception.

Devant une variable membre ou une variable locale :


La variable ne peut plus être modifiée après son initialisation, et doit obligatoirement être initialisée une fois (et une
seule fois) :

Pour une variable membre, elle peut être initialisée :

private final int i = 5;

private final int i;


{
i = 5;
}

private final int i;

public Exemple() {
i = 5;
}

Si la classe possède plusieurs constructeurs, la variable doit être correctement initialisée quel que soit le constructeur
utilisé (sinon le compilateur provoquera une erreur).

Pour une variable membre static, elle peut être initialisée :

private static final int X = 5;

private static final int X;


static {
X = 5;
}

Pour une variable locale (ou pour un paramètre de la méthode), cela permet également de référencer l'instance dans
une classe anonyme.

Que signifient les mots-clés this et super ?


Auteurs : Ioan Calapodescu , tchize ,
Les mots-clés this et super désignent respectivement des références sur l'instance courante et sur la classe mère. Voici
un exemple qui devrais mettre en valeur cette définition plutôt succincte :

public MaClasse extends ClasseMere {


private String attribut;
/** On peut acceder aux constructeurs de la super-classe*/
public MaClasse(String uneValeur){
super(uneValeur);

- 19 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

//on appelle ici le constructeur de la classe mère


}
/** On peut aussi accéder aux constructeurs de la classe elle-même*/
public MaClasse(String uneValeur){
this("une valeur par défaut");
//on appelle ici le constructeur définis un peu plus haut
}
/** En général l'appel à this est superflu lors d'appels à une méthode*/
public void uneMethode(){}
public void doubleAppel(){
//les deux lignes suivantes sont équivalentes
this.uneMethode();
uneMethode();
}
/** L'appel à this peut être utile pour bien différencier
* les variables de classe des variables de méthodes
*/
public void uneMethode(String attribut){
this.attribut = attribut;
//ici, la variable de classe prend la valeur de la variable
//passée en paramètre de la méthode
}
/** On peut aussi faire appel aux méthodes de la super-classe*/
public void uneAutreMethode(){
//on peux faire quelque chose en plus avant
super.uneAutreMethode();
//mais aussi après
}
}

A noter que dans le cas d'une classe interne (non static), le mot clé this permet également de récupérer l'instance de
la classe englobante :

public class Englobante {


private Object attribut;

public final class Interne {


private Object attribut;

private switch() {
Englobante.this.attribut = this.attribut;
}
}
}

Englobante.this fait donc référence à l'instance de la classe englobante et this fait référence à la classe interne.

Ces deux mots-clés sont très liés au concept d'héritage. Pour plus d'informations, voir Qu'est-ce que l'héritage ?

lien : Qu'est-ce que l'héritage ?

Que signifie le mot-clé strictfp ?


Auteurs : Romain Guy , Clément Cunin ,
Ce mot clé, qui est une abréviation de Strict floating point, s'applique en tant que modificateur d'accès. Ou plus
simplement, on l'utilise de la même manière que les mot-clés public ou synchronized. Avec quelques restrictions : strictfp
s'applique en tant que modificateurs de classes, d'interfaces ou de méthodes d'une classe et en aucun cas au constructeur
ou aux méthodes d'une interface. L'entité affectée est alors dite "FP-strict".

- 20 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Les effets :
Comme son nom l'indique, strictfp agit sur les opérations en virgule flottante. C'est à dire sur les types primitifs double
et float.

Java effectue les calculs en garantissant une priorité de la gauche vers la droite.

/** classe FP-strict */


public strictfp class FPDemo {
public static void main(String[] args) {
double d = 8e+307;
/** affiche 4 * d /2 donc 2 * d */
System.out.println(4 * d / 2);
/** affiche 2 * d */
System.out.println(2 * d);
}
}

Mathématiquement ces deux expressions sont identiques, mais interprétées dans un langage, il en va autrement. Java
impose un parenthésage : (4*d)/2, et dans notre cas (4*d) produit un dépassement de capacité, donc un résultat infini.
En revanche, la deuxième expression produit bien un résultat correct.

Notons que le mot-clé oblige l'implémentation de la JVM à évaluer l'expression tel que prévu dans la spécification du
langage. Ne pas faire usage de ce mot-clé ne garantit pas que la JVM réalisera ce calcul de la sorte. Une JVM peut en effet
avoir le droit, si la méthode n'est pas FP-strict, d'utiliser des types intermédiaires différents pour éviter de provoquer un
dépassement de capacité ou pour s'adapter à l'architecture de la machine. Dans ce cas les deux expressions pourraient,
en fonction de la JVM, produire des résultats différents.

Conclusion :
Le mot-clé strictfp permet de garantir les mêmes calculs quelle que soit la machine virtuelle sur laquelle l'opération
est effectuée.

Que signifie le mot-clé transient ?


Auteurs : Romain Guy ,
Le mot-clé transient est lié à la sérialisation des classes Java (voir : Qu'est-ce que la sérialisation ?). Il permet d'interdire
la sérialisation de certaines variables d'une classe.

// la classe que nous allons sérialiser


class Writeable implements java.io.Serializable {
// entier transient
public transient int var1 = 4;
// entier normal
public int var2 = 19;
}

Si nous sérialisons une instance de cette classe, la variable 'var1' ne sera pas sauvegardée, lors de la désérialisation
elle prendra la valeur 0, malgré la présence de la valeur par défaut 4. L'attribution d'une valeur par défaut se fait
lors de l'instanciation de l'objet ! Or, la méthode consistant à lire un objet depuis un fichier ne crée pas cette instance
explicitement. Donc demo n'est jamais initialisé avec sa valeur par défaut. De plus, comme cet attribut est transient, il
n'est pas écrit dans le fichier. Cela implique que demo ne reçoit aucune valeur et contient donc 0.

- 21 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Ce mot-clé trouve des applications dès lors qu'une donnée sensible ne doit en aucun cas apparaître dans un fichier. Un
mot de passe par exemple. Mais ce mot-clé peut également permettre de "remettre à zéro" certaines valeurs. Dans le
cas d'un jeu, on pourra ainsi ne pas sauvegarder le temps de jeu depuis le début de la partie.

lien : Qu'est-ce que la sérialisation ?

Que signifie le mot-clé volatile ?


Auteurs : Ioan Calapodescu ,
Le mot-clé volatile est utilisé sur les variables qui peuvent être modifiées de manière asynchrone. C'est à dire que
plusieurs threads peuvent y accéder simultanément. Ces accès peuvent être pour la lecture et/ou la modification du
contenu.

En indiquant que la variable est volatile, on oblige la JVM à rafraîchir son contenu à chaque fois qu'elle est utilisée. On
est ainsi certain que la valeur de la variable n'est pas une valeur mise en cache, mais bel et bien sa valeur exacte. Ainsi
chaque thread a accès à la valeur la plus récente de la variable.

Remarque : ce mot-clé est relativement peu utilisé et toutes les JVM ne le prennent pas en compte.

Et le goto en Java ?
Auteurs : Clément Cunin ,
goto
Bien que goto soit un mot réservé de Java, on ne le trouve pas dans le langage ; Java n'a pas de goto. Le mot-clé goto
est aussi ancien que les langages de programmation. En effet, goto a été le premier moyen de contrôle des programmes
dans les langages d'assemblage : « si la condition A est satisfaite, alors sauter ici, sinon sauter là ». Lorsqu'on lit le code
assembleur finalement généré par n'importe quel compilateur, on voit qu'il comporte beaucoup de sauts.

break & continue


Cependant, il existe quelque chose qui ressemble à un saut, lié aux mots-clés break et continue. Ce n'est pas vraiment
un saut, mais plutôt une manière de sortir d'une instruction d'itération.

while(true) {
// instructions

if( condition ) {
// quitte la boucle
break;
}
if( condition ) {
// retourne au début de la boucle
continue;
}
}

- 22 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pour plus d'informations sur break et continue, regardez le lien ci dessous.

lien : Comment utiliser les mots-clés break et continue ?

Comment utiliser les mots-clés break et continue ?


Auteurs : bulbo ,
Comme nous l'avons vu, il n'y a pas de goto en Java, mais il est possible d'associer un label à une instruction de boucle.
Ce label, utilisé en conjonction avec l'instruction break, permet de savoir à quel niveau le break sera effectif.

Un label est une chaîne suivie de ":" et qui se place devant l'instruction de boucle.

Voici un exemple :

Boucle1: while(true){
System.out.println("Boucle 1");

Boucle2: for(int ind=0; ind < 10; ind++) {


System.out.println("Boucle 2");

Boucle3: while(true){
System.out.println("Boucle 3");
break Boucle2;
}
}

break;
}

A votre avis, qu'affiche l'exécution de ce morceau de code ?

Remarque : le label peut aussi être utilisé en conjonction avec le mot clé continue. De la même manière, le label indique
à quel niveau de boucle le continue s'applique.

Pourquoi mon switch ne veut-il pas compiler ?


Auteurs : bulbo ,
L'instruction switch n'accepte que les types de base, c'est à dire:

• byte
• char
• short
• int
• long
• float
• double

Il n'est pas possible de faire un switch sur une String par exemple. Il faudra passer par une séquence de if .. else if:

if ("A".equals(maString))
{
// ...

- 23 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

}
else if ("B".equals(maString))
{
// ...
}

Il est possible aussi que le compilateur reporte cette erreur:


case expressions must be constant expressions
En effet l'instruction case n'accepte que des constantes.
Des constantes explicites comme dans ce cas:

case 1:
...
break;

Ou une variable déclarée comme constante à l'aide du mot-clé final.


Ainsi si vous obtenez une erreur avec le code suivant:

int a = 1;

switch (maVar)
{
case a:
...
}

Vous ne l'aurez plus avec celui-ci:

final int a = 1;

switch (maVar)
{
case a:
}

[Java 5.0] Comment fonctionne l'ellipse (nombre d'arguments variable) ?


Auteurs : adiGuba ,
L'ellipse permet de créer des méthodes (ou des constructeurs) avec un nombre d'arguments variable. On utilise pour
cela trois points (...) après le type des arguments, par exemple la méthode suivante accepte un nombre quelconque de
String :

Méthode avec un nombre d'argument variable :


public void method (String... args) {
//
}

A l'intérieur de la méthode, le paramètre args est un tableau contenant les différents paramètres passés à la méthode.
Ainsi, cette méthode peut s'utiliser de la manière suivante :

Exemple d'utilisation :

- 24 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Exemple d'utilisation :
// avec 1 paramètre :
method ("param1");

// avec plusieurs paramètres :


method ("param1", "param2", "param3");

// sans paramètres :
method ();

En réalité, il ne s'agit ni plus ni moins qu'une nouvelle manière de déclarer une méthode avec un tableau en paramètre.
En effet, pour le compilateur, cette déclaration correspond à la déclaration d'une méthode avec un tableau de String
en paramètre. Et lors de son utilisation, les différents paramètres de l'ellipse sont automatiquement stockés dans un
tableau. Ainsi, les exemples d'utilisations ci-dessus correspondent en réalité au code suivant :

// avec 1 paramètre :
method ( new String[]{"param1"} );

// avec plusieurs paramètres :


method ( new String[]{"param1", "param2", "param3"} );

// sans paramètres :
method ( new String[]{} );

On ne peut toutefois utiliser qu'un seul type d'argument variable par méthode, et il doit
obligatoirement être en dernière position dans la liste des paramètres.

lien : Présentation de Tiger : l'ellipse

[Java 5.0] Comment fonctionne la boucle for étendu ?


Auteurs : adiGuba ,
Le nouveau for de Java 5.0 permet de parcourir tous les éléments d'un élément 'itérable' sans se soucier de son
fonctionnement. Il se présente de la forme suivante :

La boucle for étendu :


for ( Type variable : Iterable ) {
// ...
}

• Type correspond au type de l'élément de la variable qui contiendra les différentes valeurs.
• variable est justement le nom de cette variable à l'intérieur de la boucle.
• Iterable est l'élément dont les valeurs seront parcourues. Ce doit obligatoirement être soit un tableau, soit une
classe implémentant l'interface Iterable.

L'interface Iterable décrit une unique méthode iterator() retournant un Iterator qui sera utilisé par la boucle for pour
parcourir les différents éléments. Les Collections de Java implémentent bien entendu cette interface. De plus, le type
de la variable doit correspondre au type paramétré de l'Iterator, ce qui permet de se passer de cast et d'utiliser un
code sécurisé :

Parcours d'une liste paramétrée


List<String> list = new ArrayList<String>();

- 25 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Parcours d'une liste paramétrée


list.add("chaine1");
list.add("chaine2");
list.add("chaine3");
list.add("chaine4");

// Affichage des éléments en MAJUSCULE :


for (String s : list) {
System.out.println(s.toUpperCase());
}

Si la boucle est utilisée avec un tableau, le type de la variable doit correspondre avec le type du tableau. Si elle est utilisée
avec un objet implémentant l'interface Iterable, le type de la variable doit correspondre au type paramétré d'Iterable
(par exemple,* List<String> implémente Iterable<String> et permet donc d'utiliser une String dans la boucle).

Et du fait de son fonctionnement, il est possible de l'utiliser avec n'importe quel type de classe du moment que cette
dernière implémente correctement l'interface Iterable<T> (T étant le type à utiliser dans la boucle for...

lien : Présentation de Tiger : la nouvelle boucle for


lien : java.lang.Iterable

[Java 5.0] Comment parcourir un tableau à 2 dimensions avec un for étendu ?


Auteurs : bulbo ,
Le code suivant parcourt un tableau à 2 dimensions d'entiers et les affiche.

int tab[][] = { {1, 2, 3}, {7, 8, 9} };

for(int ligne[] : tab)


{
for(int element : ligne)
{
System.out.println("Item : " + element);
}
}

[Java 5.0] Qu'est-ce que l'import static ?


Auteurs : adiGuba ,
L'import static permet d'importer les éléments statiques d'une classe afin d'alléger l'écriture du code. Cela permet en
effet de ne pas préfixer les éléments statiques par le nom de la classe. Par exemple, les deux codes suivant sont identiques
mis à part que le second utilise un import static pour accéder aux méthodes de la classe Math :

Utilisation normale des méthodes statiques :


public Class Test {
public void calcul (int i) {
Math.round(Math.cos(i*(Math.PI/6)-Math.PI/2)*Math.E);
}
}

Utilisation d'un import static :


import static java.lang.Math.*;

- 26 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Utilisation d'un import static :


public Class Test {
public void calcul (int i) {
round(cos(i*(PI/6)-PI/2)*E);
}
}

Ce mécanisme est proche du mot-clef using namespace du C++. Toutefois, il est conseillé de limiter son utilisation afin
de faciliter la lecture du code et éviter des conflits potentiels. On peut pour cela importer seulement l'élément qui nous
intéresse, par exemple :

Importation de System.out seulement :


import static java.lang.System.out;

public Class Test {


public void print () {
out.println("Message d'information");
System.err.println("Message d'erreur");
}
}

Quelle est la différence entre "import" et "import static" ?


Auteurs : le y@m's ,
Le import et le import static n'ont pas la même fonction.
Le import se fait sur une classe (ou un ensemble de classes via le *) et permet d'éviter de spécifier le package de la classe
à chaque fois qu'on l'utilise (en partant du principe que l'on se trouve dans un paquage différent de celui contenant
la classe).
Le import static a un fonctionnement similaire mais pour les méthodes et les attributs statiques d'une classe ou d'une
interface et les membres d'une enum. En effet, il permet d'éviter de spécifier la classe de la méthode ou de l'attribut
statique à chaque fois qu'on l'utilise (en partant du principe que l'on se trouve dans une classe différente de celle
contenant la méthode ou l'attribut).

Illustration :

Soit les classes package_a.ClasseA et package_b.ClasseB.


Pour "utiliser" la classe ClasseA dans la classe ClasseB il faut normalement spécifier le package comme suit :

package package_b;

public class ClasseB {


private package_a.ClasseA a;

public CLasseB() {
a = new package_a.ClasseA();
}
}

Le import permet de supprimer cet inconvénient en indiquant à l'avance dans quel package se situe la classe ClasseA
et permet donc d'écrire

package package_b;

- 27 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

import package_a.ClasseA;

public class ClasseB {


private ClasseA a;

public CLasseB() {
a = new ClasseA();
}
}

On se retrouve avec la même écriture que si la classe ClasseA était dans le même package que la classe ClasseB.
Supposont maintenant que la classe ClasseA posséde la méthode statique suivante :

public static void staticMethod() {


// code
}

Pour l'appeler depuis la classe ClasseB il faut normalement écrire

ClasseA.staticMethod();

En faisant un import static de la méthode on se retrouve comme si la méthode statique faisait partie de la classe ClasseB
et nous permet d'écrire

import static package_a.ClasseA.staticMethod;

...

staticMethod();

Ces deux imports sont indépendants, si je ne fait que le import je pourrait écrire

ClasseA

mais je devrais écrire

ClasseA.staticMethod();

A l'inverse je pourrais très bien ne faire que l'import static et je me retrouverais à devoir écrire

package_a.ClasseA

mais à pouvoir écrire directement

staticMethod();

En résumé il est important de bien retenir que

• le import ne permet la simplification d'écriture que pour les classes

- 28 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• le import static ne permet la simplification d'écriture que pour les méthodes et les attributs statiques d'une
classe ou interface et les membres d'une enum
• le import et le import static sont indépendants

lien : [Java 5.0] Qu'est-ce que l'import static ?

Qu'est-ce que l'opérateur ternaire?


Auteurs : JMLLB ,
On le considère souvent comme une syntaxte réduite de l'instruction if traditionnelle.
Mais c'est avant tout un opérateur au sens où il produit une valeur.

(A) ? B : C

Si A alors le résultat est B sinon c'est C.


A noter que B est évalué seulement si A et que C est évalué seulement si non A.

Il fournit un moyen compact d'écrire une affectation conditionnée:

chaine=(nouvelleChaine!=null) ? nouvelleChaine : "";

à la place de:

if (nouvelleChaine!=null) {chaine=nouvelleChaine;} else {chaine="";}

NB: Utilisé abusivement il devient rapidement illisible.

- 29 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Concepts fondamentaux > Les notions


Qu'est-ce que l'héritage ?
Auteurs : Ioan Calapodescu ,
L'héritage est un des principaux concepts de la programmation orientée objet. L'héritage permet de définir une relation
de "filiation" entre classes. Ainsi une classe fille (ou sous-classe) étend une classe mère (ou super-classe). L'héritage
permet en général de spécialiser une classe.

Pour indiquer qu'une classe hérite d'une autre, il faut utiliser le mot-clé extends :

public class Fille extends Mere{


//ici le code spécifique de la classe fille
}

L'héritage implique plusieurs choses :

La fille hérite du type de la mère :

public class Couleur(){


String nom;
public Couleur(String nom){
this.nom = nom;
}
}
public class Rouge extends Couleur{
public Rouge(){
super("rouge");
}
}
public class AutreClasse(){
public void setCouleur(Couleur uneCouleur){
//etc.
}
public static void main(String[] args){
AutreClasse ac = new AutreClasse();
ac.setCouleur(new Couleur("vert"));
ac.setCouleur(new Rouge());
}
}

La fille hérite de plusieurs attributs, méthodes et constructeurs de la mère

L'accès à ces attributs ou méthodes se fait avec le mot clef super. Pour plus d'informations, voir Que signifient les mots-
clés this et super ?

Voici comment est définie l'accessibilité aux composantes de la super-classe, en fonction des modificateurs :

Mot-clé Accès
public Oui
"rien" Oui, seulement si la classe fille se trouve dans
le même package que la super-classe.
protected Oui, quel que soit le package de définition de
la classe fille.
private Non.

- 30 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Regardez les liens ci dessous qui pourront vous éclairer un peu plus sur cette notion.

lien : Que signifient les mots-clés this et super ?


lien : Comment faire pour hériter de plusieurs classes ?
lien : Qu'est ce qu'une interface ?

Qu'est ce qu'une classe abstraite ?


Auteurs : Sébastien Meric , Clément Cunin ,
Qu'est ce qu'une classe abstraite
Une classe abstraite est une classe incomplète. Elle regroupe un ensemble de variables et de méthodes mais certaines
de ses méthodes ne contiennent pas d'instructions, elles devront être définies dans une classe héritant de cette classe
abstraite.

A quoi ça sert ?
En général à définir les grandes lignes du comportement d'une classe d'objets sans forcer l'implémentation des détails
de l'algorithme. Prenons l'exemple d'une chaîne de montage automobile, laquelle sort un modèle de voiture particulier.
On peut choisir de faire une nouvelle chaîne de montage pour le modèle à pare-choc métalisé, une pour le modèle à pare-
choc en plastique, etc. Ou on peut décider de faire une chaîne de montage générique, de laquelle sortiront des véhicules
non finis, que l'on terminera sur d'autres petites chaînes.

Comment ça marche ?
Premièrement comme indiqué ci dessus, une "abstract class" est incomplète, elle est donc non instanciable et doit être
héritée. Certaines classes abstraites disposeront de méthodes abstraites (que les classes enfants devront implémenter).
Voici un exemple de déclaration :

/** La classe abstraite employée : */


public abstract class Employe {
// bla bla bla

/** définition d'une méthode abstraite


* on notera qu'il n'y a pas d'instruction et un point-virgule à la fin
*/
public abstract void licencier();
}

// Class Ouvrier
public class Ouvrier extends Employe {
// définition du code de licencier
public void licencier() {
// on definit le code
System.out.println("Dehors !");
}
}

// Class Patron
public class Patron extends Employe {
// définition du code de licencier
public void licencier() {
System.out.println("Veuillez comprendre que dans la conjoncture actuelle ... !");
}
}

- 31 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Toutes les personnes trouvant ce code ridicule sont priées de joindre un autre exemple avec leur mail de protestation :-)

lien : Qu'est ce qu'une interface ?

Qu'est-ce qu'une classe interne ?


Auteurs : jeje99 , L'équipe Java ,
Une classe interne est une classe déclarée à l'intérieur d'une autre classe. Elle possède les mêmes possibilités qu'une
autre classe, mais elle est toujours dépendante de sa classe conteneur et ne peut être utilisé que par la classe conteneur.

Exemple :

class Outer{
class Inner {
}
}

Une classe interne peut accéder de manière transparente aux membres de l'instance de la classe dont elle fait partie.
Comme par exemple dans ce code :

class Outer{
int i = 100;
class Inner {
int k = i ;
}
}

Une classe interne ne peut par contre pas comporter de contexte static.

On peut aussi déclarer une classe interne comme static, ce qui fait qu'elle ne sera plus liée à l'instance de la classe
conteneur et qu'elle pourra déclarer des contextes statiques. Mais elle ne pourra plus utiliser les variables d'instance
de la classe conteneur, mais seulement les variables de classe (statiques).

Quels sont les différents types de classes internes (nested classes) ?


Auteurs : adiGuba ,
Une classe interne est une classe qui est déclarée à l'intérieur d'une autre classe. Le principal avantage des classes
internes vient du fait qu'elles ont accès à tous les membres de leur classe conteneur quel que soit le niveau de visibilité.
Ainsi les membres private de la classe conteneur sont visibles par toutes ses classes internes.

Note : En réalité le compilateur génèrera implicitement une méthode d'accès synthétique de visibilitée package-only.

On distingue toutefois quatre grands types de classes internes :

• Les classes internes static ("static nested classes"), qui correspondent à de simples classes déclarées à l'intérieur
d'une autre classe.
• Les classes internes ("inner classes"), qui conserve un lien fort avec une instance de la classe conteneur.
• Les classes locales, déclarée dans une méthode, et qui ne sont valide qu'à l'intérieur de ce bloc.
• Les classes anonymes, déclaré en ligne dans le code.

- 32 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Les deux premiers types ("static nested classes" et "inner classes") étant déclarées au même niveau que les membres de
la classes, ils peuvent donc bénéficier des mêmes possibilitées de visibilités : public, protected, package-only("rien") ou
private. Une classe private ne peut être utilisée que par la classe conteneur tandis qu'une classe protected peut également
être utilisé par une classe fille ou une classe du même package.

Note : Les classes standards ne peuvent pas être déclarées protected ou private, puisque cela n'aurait aucun sens (une
classe ne peut hériter d'une autre classe que si cette dernière lui est visible).

Les classes internes static ("static nested classes") correspondent tout simplement à des classes standards déclarées à
l'intérieur d'une autre classes. Elles se distinguent par la présence du mot-clef static dans leurs définitions.

Par exemple :

public class TopLevelClass {


private String privateField;

public static class StaticNestedClassComparator implements Comparator<TopLevelClass> {


public int compare(TopLevelClass o1, TopLevelClass o2) {
// On accède directement aux champs privée :
return o1.privateField.compareTo(o2.privateField);
}
}
}

Ces méthodes peuvent être instancier directement en les préfixant du nom de la classe conteneur (à condition qu'elles
soit visible bien entendu) :

TopLevelClass.StaticNestedClassComparator instance = new


TopLevelClass.StaticNestedClassComparator();

Les classes internes ("inner classes") ne sont pas déclarées en static, et elles gagnent par la même occasion un lien étroit
avec une instance de la classe conteneur. En effet les classes internes ne peuvent être instancié qu'à partir une instance
de la classe parente, avec laquelle elle gardera une relation pendant toute son existence.

Il est ainsi possible d'accéder à l'instance courante via le mot-clef "NomDeLaClasseConteneur.this". Par exemple :

public class TopLevelClass {


private String privateField;

public class InnerClassRunnable implements Runnable {


public void run() {
// On peut accéder directement aux champs privées de l'instance lié :
System.out.println(TopLevelClass.this.privateField);
}
}

public InnerClassRunnable create() {


// On crée une instance de l'inner-class qui sera lié avec l'instance courante (this)
return new InnerClassRunnable();
}
}

En contrepartie, il est ainsi obligatoire d'instancier ce type de classe depuis une des méthodes d'instances de la classe
conteneur (par exemple create() ici), ou en utilisant une référence de l'instance de la classe parente :

TopLevelClass topLevelInstance = new TopLevelClass();


TopLevelClass.InnerClassRunnable innerInstance = topLevelInstance.new InnerClassRunnable();

- 33 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Mais ce type d'écriture est généralement déconseillé.

Note : Pour réaliser ce lien entre la classe interne et la classe conteneur, le compilateur rajoutera automatiquement un
paramètre du type de la classe conteneur à chacun des constructeurs de la classe interne, ainsi qu'un attribut d'instance
qui conservera cette valeur. Le code généré est donc sensiblement identique au code suivant :

public class InnerClassRunnable implements Runnable {


final TopLevelClass topLevelClass;

public InnerClassRunnable(TopLevelClass topLevelClass) {


this.topLevelClass = topLevelClass;
}

public void run() {


// On peut accéder directement aux champs privées de l'instance lié :
System.out.println(topLevelClass.privateField);
}
}

Note : Les interfaces, annotations ou enums déclarées à l'interieur d'une classe ne peuvent pas être liées avec une instance
de la classe parente, et sont donc implicitement déclarées static.

Les classes locales sont des classes déclarées au sein même d'une méthode ou d'un bloc de code. Elles ne peuvent donc
être utilisées qu'à l'intérieur de ce même bloc et seront complètement inexistantes de l'extérieur.

public static void main(final String[] args) throws Exception {

// Déclaration de la classe au sein d'une méthode :


class LocalClass {
public void sayHello() {
System.out.println("Hello World");
}
}

LocalClass c1 = new LocalClass();


LocalClass c2 = new LocalClass();

c1.sayHello();
c2.sayHello();
}

Les classes anonymes correspondent à une variante des classes locales, dans le sens où elles sont aussi déclarées à
l'intérieur d'un bloc de code. Elles permettent de définir une classe à "usage unique" en implémentant une seule
interface ou en héritant d'une classe directement, par exemple :

public static void main(final String[] args) throws Exception {

// Implémentation d'une interface :


Runnable task = new Runnable() {
public void run() {
System.out.println("Hello World");
}
};

// Héritage d'une classe :


Thread thread = new Thread() {
public void run() {
System.out.println("Hello World");
}
};

thread.start();

- 34 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

new Thread(task).start();
}

Note : Lorsqu'elles sont utilisées dans une méthode d'instance, les classes locales et les classes anonymes peuvent être
lié à l'instance courante (this) de la même manière que les classes internes non-static.

Note : Il faut noter également que mis à part pour les "classes internes static", les classes internes n'acceptent pas
d'attribut static, mis à part s'il s'agit de constantes.

lien : Qu'est-ce qu'une constante ?


lien : Qu'est-ce qu'un membre "synthetic" ?
lien : Que signifient les mots-clés public, private et protected ?

Qu'est ce qu'une interface ?


Auteurs : Sébastien Meric ,
Définiton :
Une interface représente un contrat passé entre plusieurs classes (polymorphisme). En général, l'interface porte un nom
de type adjectif, ce qui permet de préciser les aptitudes complémentaires d'une classe. Par exemple :
Runnable = capable d'être exécuté
Drawable = capable de s'afficher

Utilisation / but :
En général, l'interface, spécifie dans son contrat un ensemble de méthodes qui devront être implémentées par les classes
qui s'engagent à respecter le contrat. Néanmoins, ceci n'est pas nécessaire et certaines interfaces servent uniquement de
marqueur comme par exemple l'interface Serialisable qui permet simplement de préparer une classe à la sérialisation.
La notion d'interface permet ainsi
-> de découper de manière à la fois élégante et très puissante l'aptitude (contrat) de l'implémentation.
Par exemple l'interface Enumeration permet de parcourir une "liste" d'objets d'un bout à l'autre sans se préoccuper
de l'implémentation sous-jacente (un tableau, une hashtable, Collection, etc.). En effet il suffit de faire un

while (Enumeration e = ...; e.hasNextElement(); ) {


MonObjet o = (MonObjet)e.next();
// Faire qqc avec o
}

-> De bien séparer les activités, et d'améliorer ainsi la lecture du code. En effet, la seule lecture de la déclaration de
la classe nous permet de prendre connaissance de l'intégralité des activités de celle-ci. Par exemple une classe, disons
"Ensemble" qui implémente l'interface Sortable nous renseigne dès sa déclaration sur la notion d'aptitude au tri qui
lui a été attribuée.

En savoir plus :
Pour en savoir plus sur la notion d'interface, outre les tutoriels java, il est conseillé de chercher de l'information autour
des design patterns.

- 35 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pour mieux comprendre la notion de séparation des activités, il peut être intéressant de lire les documentations
concernant jakarta-avalon.

lien : Qu'est ce qu'une classe abstraite ?

Qu'est ce qu'une méthode 'deprecated' ?


Auteurs : Clément Cunin ,
Définition :
Deprecated signifie que la méthode existe toujours pour des soucis de compatibilité ascendante, mais qu'elle n'est plus
supportée et est amenée à disparaître dans l'avenir.

Pourquoi :
Il existe plusieurs raisons pour qu'une méthode soit marquée deprecated.
• Le plus généralement il s'agit d'un renommage de la méthode. Certaines méthodes sont héritées des toutes
premières versions de JAVA, les conventions de nommage n'étant pas toujours respectées, certaines méthodes ont
été renommées par la suite... (Les exemples sont très fréquents dans SWING)
• Quelques méthodes sont devenues obsolètes suite à une évolution de l'architecture de l'Api. (La gestion des dates
par exemple)
• Enfin, certaines méthodes se sont révélées dangereuses et ne doivent plus être utilisées. Les méthodes de la classe
java.lang.Thread peuvent conduire a un état incohérant des objets ou un arrêt de l'application (Pourquoi toutes
les méthodes de la classe Thread sont marquées "deprecated" ?)

Marquer ses propres méthodes deprecated :


Si vous créez une librairie ou du code destiné a être utilisé par quelqu'un d'autre, vous pourriez être amené à déconseiller
l'emploi d'une méthode. Dans ce cas, un simple tag javadoc suffit.

public class MaClass {


/** Une méthode dépréciée
* @deprecated
*/
public void maMethodeDepreciee() {

}
}

lien : Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?

Qu'est-ce que la sérialisation ?


Auteurs : Clément Cunin ,
Java, permet de sauvegarder l'état d'un objet à un instant donné dans un flux d'octets. On dirigera généralement ce
flux dans un fichier pour effectuer une sauvegarde. Le principal avantage de la sérialisation, c'est d'être complètement
intégré à l'api Java et donc de ne nécessiter presque aucun code supplémentaire.

Créer une classe sérialisable :


Il suffit simplement que la classe implémente l'interface java.io.Serializable".

public class Writeable implements java.io.Serializable

Note : toutes les variables de la classe doivent également être des objets sérialisables (ou des types primitifs).

- 36 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sérialisation d'un object.

try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("monFichier.sav"));
out.writeObject(monObject1);
out.writeObject(monObject2);
out.close();
} catch( IOException e ) {

Désérialisation d'un object.

try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream("monFichier.sav"));
MonObject1 monObject1 = (MonObject1)in.readObject();
MonObject2 monObject2 = (MonObject2)in.readObject();
in.close();
} catch( ClassNotFoundException e1 ) {

} catch( IOException e2 ) {

Note : Il est possible de ne pas sauvegarder certains attributs de la classe en utilisant le mot clé "transient". Plus d'info
Que signifie le mot-clé transient ?.

lien : Que signifie le mot-clé transient ?

Quelles sont les règles à respecter pour redéfinir/implémenter une méthode ?


Auteurs : adiGuba ,
Lorsqu'on redéfinit une méthode d'une classe parente, ou de lors de l'implémentation
d'une méthode d'une interface, on doit obligatoirement conserver la signature
exacte de la méthode d'origine : c'est le contrat que l'on doit respecter.
Toutefois, il n'est pas figé et il est donc possible de modifier certains
éléments. Pour cela, nous allons prendre la déclaration de la méthode suivante en exemple :

Signature de méthode :
protected Number getValue(int value) throws IOException;

Il est donc possible de modifier les éléments suivants :

1) La portée de la méthode :
Il est en effet possible de changer la portée de la méthode, à condition
de l'élargir. Ainsi une méthode protected peut devenir public
alors qu'une méthode sans modificateur (visibilité limitée au package) pourra devenir protected ou
public...
Cela est possible car le contrat de la méthode original est respecté (on se contente
d'étendre l'accès à la méthode). Par contre l'inverse reste interdit ! (Impossible de
passer une méthode public en protected ou private par exemple).
Ainsi, la méthode ci-dessous est tout à fait valable :

- 37 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Augmentation de la portée de la méthode :


public Number getValue(int index) throws IOException;

2) Les Exceptions retournées :


Il est possible de modifier la déclaration des exceptions renvoyées par
la méthode, tant que l'on respecte celle de la méthode parente. Il est
donc possible de :

• Supprimer l'exception : en effet, en ne renvoyant pas d'exception, on respecte le contrat original car le throw
signifie "la méthode peut renvoyer une exception", mais ce n'est pas une obligation.
• Spécialiser le type de l'exception : en indiquant par exemple une exception qui hérite de celle définit dans la
signature de la méthode parente.

Ainsi, les deux méthodes suivantes sont valables (puisque FileNotFoundException et


ZipException héritent de IOException) :

Suppression de l'exception :
protected Number getValue(int value);

Spécialisation de l'exception :
protected Number getValue(int value) throws FileNotFoundException, ZipException;

3) La covariance du type de retour (Java 5.0) :


La version 5.0 de Java apporte une nouvelle possibilité : on peut
désormais modifier le type de retour de la méthode. Toutefois, il faut
que le nouveau type hérite du type de retour d'origine afin de ne pas
rompre le contrat. Ainsi, notre méthode pourrait retourner un
Long (puisque Long hérite de Number) :

Changement du type de retour :


protected Long getValue(int value) throws IOException;

Au final, on peut obtenir des méthodes très différentes alors qu'elles


redéfinnissent bien la même méthode :

Quelques exemples :
public Double getValue(int value);

protected Long getValue(int value) throws FileNotFoundException, ZipException;

etc...

Attention, les changements de signature affecteront bien sûr les classes


filles...
De plus, il peut devenir difficile de voir qu'une méthode en redéfini
une autre avec tant de modifications. Dans ce cas il est fortement conseillé
d'utiliser l'annotation @Override de Java 5.0 (si possible)...

- 38 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Que signifient les mots-clés public, private et protected ?


lien : La covariance dans le JDK1.5 de Fabrice Sznajderman

C'est quoi la surcharge (ou encore overload)des méthodes ?


Auteurs : djo.mos ,
C'est le fait de déclarer plusieurs méthodes avec le même nom mais avec des paramètres et/ou type de retour différents.

Une méthode qui surcharge une autre doit obligatoirement :

• avoir le même nom de la méthode surchargée.


• être déclarée dans la même classe ou dans une classe fille.
• avoir une signature différente : paramètres différents en nombre, en types ou en ordre de ceux de la méthode
surchargée.

Exemple de surcharge
public class Salutation {
public void disBonjour(){
System.out.println("Bonjour inconnu !");
}

public void disBonjour(String nom){


System.out.println("Bonjour "+nom+" !");
}
}

Dans cet exemple, la méthode disBonjour est surchargée dans le sens où elle peut être appelée de deux façons différentes :

Salutation salutation = new Salutation();


salutation.disBonjour();
salutation.disBonjour("Développeur");

Sortie :

Bonjour inconnu !
Bonjour Développeur !

Comment cloner un objet ?


Auteurs : bulbo ,
Pour cloner un objet, il suffit d'appeler sa méthode clone(). Cet objet doit obligatoirement implémenter l'interface
Cloneable.
S'il n'implémente pas cette interface, il n'est pas possible de compiler le code en raison de la visibilité de la méthode
clone() définie dans la classe Object.
Attention:
Le clonage d'un objet n'opère que sur un niveau et non en profondeur.
Ainsi lors du clonage d'un Vector par exemple, seul le Vector est cloné; les objets contenus dans le Vector ne le sont pas,
simplement il est désormais possible d'ajouter ou d'enlever des éléments d'un des Vector sans influencer l'autre. Pour

- 39 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

effectuer un "deep" clone, c'est-à-dire cloner aussi les objets, il faut écrire une boucle qui clonera un à un les objets
contenus dans le Vector originel.

[Java 5.0] Qu'est-ce que les Generics (types paramétrés) ?


Auteurs : adiGuba ,
Les Generics permettent de s'abstraire du type réel des objets lors de la conception d'une classe ou d'une méthode tout
en conservant un code sécurisé. En effet, contrairement au polymorphisme tel qu'il était utilisé jusque là dans Java,
les Generics permettent de définir le type réel des objets lors de leurs utilisations, et permet ainsi de s'affranchir des
multiples cast peu pratiques et dangereux en cas de mauvaise utilisation. Ainsi, les Generics augmentent la sécurité en
reportant à la compilation des erreurs qui survenait à l'exécution...

Prenons pour exemple l'utilisation des collections de Java, avec une méthode qui permet de calculer la moyenne d'une
List de Float :

Calcul d'une moyenne à partir d'une liste


public float moyenne (List listNote) {
float moyenne = 0.f;
Iterator iterator = listNote.iterator();
while (iterator.hasNext()) {
Float note = (Float) iterator.next();
moyenne += note.floatValue();
}
return moyenne/listNote.size();
}

Cette méthode toute simple peut poser problème si on l'utilise mal. En effet, si un seul des éléments de la liste passée en
paramètre n'est pas du type Float, on se retrouve avec une ClassCastException. Si ce type de problème est facilement
décelable dans de petit programme, il en est tout autrement dans de gros projet, et en particulier si la liste en question
peut être remplie par différents modules...

En permettant de typer des objets, les generics reportent ces problèmes à la compilation. Ainsi la méthode devient :

Calcul d'un moyenne à partir d'une liste


public float moyenne (List<Float> listNote) {
float moyenne = 0.f;
Iterator<Float> iterator = listNote.iterator();
while (iterator.hasNext()) {
Float note = iterator.next();
moyenne += note.floatValue();
}
return moyenne/listNote.size();
}

Le cast a disparu car il a été remplacé par le typage de la liste et de son itérateur grâce au <Float> après le nom du type,
qui permet d'indiquer que la List et l'Iterator sont tous les deux paramétrés avec des Float. Ainsi la méthode moyenne()
ne risque plus de provoquer des ClassCastException puisque tous les éléments de la liste sont forcément des Float...

Enfin, il est à noter que l'utilisation cumulée des Generics, de l'auto-boxing et de la boucle for étendu simplifie
grandement la méthode :

public float moyenne (List<Float> listNote) {

- 40 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

float moyenne = 0.f;


for (float note : listNote) {
moyenne += note;
}
return moyenne/listNote.size();
}

Les Generics apportent de grands changements qu'il serait difficile de décrire dans une simple réponse... La présentation
de Tiger de Lionel Roux (lien ci-dessous) présente le concept plus en détail.

lien : Présentation de Tiger : Les Générics

[Java 5.0] Qu'est-ce que l'auto-boxing / auto-unboxing ?


Auteurs : adiGuba ,
L'auto-boxing gère la transformation des types primitifs (boolean, byte, char, short, int, long, float, double) vers la
classe 'wrapper' correspondante (Boolean, Byte, Character, Short, Integer, Long, Float, Double) et inversement pour
l'auto-unboxing...

Tout est transparent, il n'y a donc plus aucune conversion explicite. Ainsi, le code suivant est tout à fait correct :

Exemple (en commentaire le même code sans l'autoboxing):


Integer integer = 0;// Integer integer = new Integer(0);
int j = integer;// int j = integer.intValue();

Map map = new HashMap();


map.put ( 2.1, "Valeur" );// map.put (new Double(2.1), "Valeur");

List list = new ArrayList();


list.add (true);// list.add (new Boolean(true));

etc...

lien : Présentation de Tiger : L'autoboxing des types primitifs

[Java 5.0] Qu'est-ce qu'une annotation ?


Auteurs : adiGuba ,
Les annotations permettent de poser des 'marqueurs' sur divers éléments du langage. Elles peuvent ensuite être utilisées
par le compilateur ou d'autre outils de gestions des sources afin d'automatiser certaines tâches, voir directement pendant
l'exécution de l'application...

Dans le code source, les annotations se distinguent par la présence d'un arobase (@) devant leurs noms (à l'instar des
tags Javadoc), et elle se déclare avec le mot-clef @interface :

Déclaration d'une annotation simple :


public @interface SimpleAnnotation {
}

Déclaration d'une annotation avec des attributs :


public @interface AttributAnnotation {
String value();

- 41 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Déclaration d'une annotation avec des attributs :


int count();
}

Elle s'utilise en plaçant l'annotation devant l'élément à annoter, avec les valeurs des éventuels attributs entre
parenthèses, par exemple :

Une classe avec plein d'annotation :

@SimpleAnnotation
public class MaClasse {

@SimpleAnnotation
protected String name;

@SimpleAnnotation protected int value;

@AttributAnnotation(value="info", count=3);
public MaClasse () {
}

@SimpleAnnotation
@AttributAnnotation(value="m", count=1);
public void method () {
}

Java 5.0 a introduit trois annotations de base :

• @Deprecated qui permet d'indiquer qu'un élément est déprécié et ne devrait plus être utilisé.
• @Override devant une méthode permet d'indiquer qu'elle surcharge une méthode héritée de la classe parent.
• @SuppressWarnings permet d'ignorer certains warnings lors de la compilation (*).

(*) L'annotation @SuppressWarnings n'est gérée par le compilateur standard du JDK 5.0
qu'à partir de l'update 6 (Voir Bug 2125378).

Il existe également des méta-annotations conçues exclusivement pour être utilisées sur d'autres annotations :

• @Documented permet d'indiquer que l'annotation doit figurer dans le documentation générée par javadoc.
• @Inherited indique que l'annotation doit être héritée par les classes filles.
• @Retention spécifie de quelle manière l'annotation doit être conservée par le compilateur et la JVM.
• @Target permet de limiter les éléments du langage qui peuvent prendre cette annotation.

De plus, Java 5.0 a introduit un nouvel outil en ligne de commande permettant d'analyser le code à la recherche des
annotations avant la compilation : APT (Annotation Processing Tool).

lien : Tutoriel : Les Annotations de Java 5.0


lien : Guide : Annotation Processing Tool

[Java 5.0] Qu'est-ce qu'une enum (type énuméré) ?


Auteurs : adiGuba ,
Définition :
Une enum représente un type énuméré, c'est à dire un type qui n'accepte qu'un ensemble fini d'éléments. Introduit avec
Java 5.0, ce nouveau type permet donc de créer simplement des énumérations...

- 42 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Utilisation / but :
Dans sa forme la plus basique, une enum contient simplement la liste des valeurs possibles qu'elle peut prendre. Elle se
déclare comme une classe mis à part que l'on utilise le nouveau mot-clef enum, par exemple :

Une simple enum représentant les saisons :


public enum Season {
spring,summer, automn, winter;
}

Toutefois, une énumération reste une classe Java, elle accepte donc des champs,des méthodes et des constructeurs. Par
exemple, on pourrait compléter l'énumération avec le nom français de la saison :

Une enum avec un constructeur :


public enum Season {
spring("Printemps"),summer("Eté"), automn("Automne"), winter("Hiver");

protected String label;

/** Constructeur */
Season(String pLabel) {
this.label = pLabel;
}

public String getLabel() {


return this.label;
}
}

Les constructeurs des enum n'acceptent pas de modificateurs d'accessibilité (public, protected, etc.) car ils ne sont
utilisés que pour initialiser les différentes valeurs de l'énumération. Le code suivant est ainsi incorrect :

Season s = new Season ("Hiver");

De plus, chaque enum possède deux méthodes statiques implicites permettant d'accéder aux différentes valeurs :

• Season.values() retournera un tableau de Season avec toutes les valeurs possibles.


• Season.valueOf(String) retournera la Season dont le nom est passé en paramètre (par exemple,
Season.valueOf("spring") retournera Season.spring).

Les différentes valeurs de l'enum correspondent à des constantes statiques et publiques et peuvent donc être accédées
directement comme les champs public static (par exemple avec Season.winter).
Enfin, les enums peuvent directement être utilisées dans un switch :

Switch sur une enum :


public void method (Season season) {
switch (season) {
case spring:
System.out.println("Les arbres sont en fleurs !!!");
break;
case summer:
System.out.println("Il fait chaud !!!");
break;
case automn:
System.out.println("Les feuilles tombent...");
break;

- 43 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Switch sur une enum :


case winter:
System.out.println("Il neige !!!");
break;
}
}

Bien entendu, les enums de Java 5.0 sont type-safe, c'est à dire qu'une enum ne peut en aucun cas prendre une autre
valeur que celle définie dans sa déclaration, c'est pourquoi on ne peut ni construire de nouvelle instance, ni hériter
d'une enum...

lien : Présentation de Tiger : Les types énumérés type-safe

Qu'est-ce qu'une constante ?


Auteurs : adiGuba ,
Une constante est un attribut static final qui respecte certaines conditions :

• Il doit correspondre à un type primitif (boolean, byte, char, int, long, float ou double) ou au type spécial String.
• Sa valeur doit être directement affectée en ligne à la déclaration de l'attribut.
• Sa valeur doit pouvoir être évaluée par le compilateur, c'est à dire qu'elle ne doit pas comporter de code
dynamique (appel de méthode ou utilisation de variable) mais de simple opération sur des constantes.

A titre d'exemple, les attributs suivant sont des constantes :

public static final charCHAR = 'C';


public static final doubleRAYON = 15.0;
public static final doubleAIRE = Math.PI * RAYON * RAYON;

public static final StringHELLO = "Hello";


public static final StringHELLO_WORLD = HELLO + " World";

A l'inverse, les attributs suivants ne sont pas des constantes mais de simple attribut statique invariable :

public static final charCHAR = Character.valueOf('C');// Appel d'une méthode


public static final doubleRANDOM = Math.random();// Appel d'une méthode
public static final Object OBJECT = "Object";// Type incorrect (Object)

public static final StringHELLO = new String("Hello");// Utilisation d'un constructeur


public static final StringHELLO_WORLD = HELLO + " World"; // HELLO n'est pas une constante

public static final String VALUE;// Pas d'initialisation

static {
VALUE = "Value";
}

Les constantes sont traitées d'une manière particulière par le compilateur, et se rapprochent des "define" du C/C++.
En effet comme le compilateur peut évaluer leurs valeurs, il ne génère pas le code d'accès à l'attribut mais le remplacera
directement par sa valeur.

Prenons par exemple le code suivant :

System.out.println( Constante.HELLO + " World" );

- 44 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Si Constante.HELLO est une constante, le compilateur remplacera directement l'accès à l'attribut par sa valeur, ce qui
reviendrait à faire ceci :

System.out.println( "Hello" + " World" );

Et puisque le compilateur se charge d'évaluer les expressions ou sous-expressions ne contenant que des constantes, on
obtient directement le code suivant :

System.out.println( "Hello World" );

Il n'y a donc plus aucune concaténation à l'exécution.

Attention toutefois, car si le code source est modifié pour changer la valeur de la constante, cette modification ne sera
pas répercutée sur les autres classes si elles n'ont pas été recompilées, puisqu'elles conserveront en dur l'ancienne valeur
de la constante. Du fait ce cette spécificité, il est important de ne pas utiliser abusivement les constantes pour des valeurs
qui pourraient être modifiées au cours du temps, en particulier dans le cadre du développement d'une librairie.

Plutôt que d'utiliser des constantes, il est généralement préférable d'utiliser des enums ou des objets immuables. Les
constantes sont utiles seulement pour des grandeurs fixes et amorphes.

lien : [Java 5.0] Qu'est-ce qu'une enum (type énuméré) ?

Qu'est-ce qu'un membre "synthetic" ?


Auteurs : adiGuba ,
Les membres d'une classe (c'est à dire ses attributs, constructeurs ou méthodes) peuvent être marqués en tant que
"synthetic" par le compilateur pour indiquer qu'il s'agit d'un élément qui a été introduit par le compilateur et qui n'est
donc pas directement présent dans le code source original de la classe.

La plupart du temps les membres "synthetic" sont générés lors de l'utilisation de classes interne, par exemple :

• Une classe interne non-static se verra ajouté un attribut référençant l'instance de la classe parente avec laquelle
elle est liée.
• Lorsqu'une classe interne accède à une méthode ou un attribut privé de la classe parente, le compilateur
ajoutera et utilisera en réalité une méthode d'accès de visibilité "package-only" dans la classe parente.
• Lorsqu'une classe interne accède à un constructeur privé de la classe parente, le compilateur génèrera en fait un
autre constructeur de visibilité "package-only".

Bref toute les membres introduits par le compilateur sans correspondance dans le code source original sont marqué
comme "synthetic", à l'exception toutefois des constructeurs par défaut (qui sont automatiquement rajoutés lorsque
une classe ne définit aucun constructeur).

lien : Member.isSynthetic()

[Java 5.0] Qu'est-ce qu'une méthode "bridge" ?


Auteurs : adiGuba ,
Les méthodes bridges sont des méthodes "synthetics" générées par le compilateur sous certaines conditions lors de
l'implémentation ou la redéfinition de méthodes paramétrées par les Generics, et que l'on spécifie un type particulier.

Prenons l'exemple d'une classe qui implémente l'interface Comparator>T< en utilisant le type String :

- 45 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public class StringIgnoreCaseComparator implements Comparator<String> {


public int compare(String o1, String o2) {
return o1.compareToIgnoreCase(o2);
}
}

Les paramètres de la méthode compare() sont bien de type String, or puisque le type des Generics est perdu à l'exécution
la méthode compare(String,String) ne respecte plus la signature de base de l'interface Comparator qui correspond
plutôt à compare(Object,Object) (c'est à dire sans les types paramétrés).

Pour pallier à cela le compilateur génèrera automatiquement une méthode supplémentaire correspondant à la signature
de base de la méthode, qui se contentera d'appeler la bonne méthode après un cast de ses paramètres. Ce qui donnerait
dans notre cas :

public class StringIgnoreCaseComparator implements Comparator<String> {


public int compare(String o1, String o2) {
return o1.compareToIgnoreCase(o2);
}

// Méthode bridge créée par le compilateur :


public int compare(Object o1, Object o2) {
return compare((String)o1, (String)o2);
}
}

Afin de pouvoir être facilement repéré par l'API de réflection, ces méthodes sont marquées en tant que "bridge" par
le compilateur.

lien : [Java 5.0] Qu'est-ce que les Generics (types paramétrés) ?


lien : Qu'est-ce qu'un membre "synthetic" ?
lien : Method.isBridge()

- 46 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités

- 47 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > Gestion des nombres et chaînes de caractères


Comment comparer des chaînes de caractères ?
Auteurs : Clément Cunin ,
Avant d'essayer de comparer deux chaînes de caractères, il faut bien comprendre que l'opérateur '==' permet de
comparer entre eux les types primitifs (int, float, boolean, etc. ) mais dans le cas des objets, cet opérateur compare les
emplacements mémoire des objets : deux instances initialisées avec les mêmes paramètres occupent un espace mémoire
différent, elles sont donc différentes du point de vue de '=='. L'opération qui permet de comparer les objets entre eux
est la méthode equals() de java.lang.Object.

String a = "coucou";
String b = "coucou";
String c = "bonjour";
String d = c;

a==b;
/** FAUX, a et b sont des instances différentes de String.
* Ce résultat est théorique, car certains compilateurs pourraient optimiser
* le code pour ne créer qu'une seule instance mémoire
*/

a.equals(b);
// VRAI, equals() compare les chaînes caractère par caractère.

c==d;
// VRAI, c et d représentent la même instance mémoire de String

JDK 1.4, méthode 'intern()'


Le JDK 1.4 vient un peu compliquer la chose en conservant une liste privée d'instances de String. Initialement, la liste
est vide. L'appel de la méthode intern() cherche dans la liste si une instance est égale d'après 'equals()', si oui, cette
instance est retournée, sinon la chaîne est ajoutée à la liste.

String a = "coucou"; // 1ère instance


String b = "coucou"; // 2ème instance
a=a.intern(); // l'instance 1 est ajoutée à la liste, 'a' ne change pas de valeur
b = b.intern(); // Equivalent à : b = a;

a==b; // VRAI

Comment comparer des chaînes de caractères selon la Locale ?


Auteurs : adiGuba ,
Par défaut, toutes les opérations de comparaisons et égalités des chaînes de caractères se basent sur leurs valeurs
unicodes. Cela permet des traitements très rapides car il s'agit d'une comparaison bit à bit, mais cela produit des
résultats non-souhaitables avec certaines locales...

Prenons par exemple le code suivant qui permet de trier une liste et de l'afficher :

List list = new ArrayList();


list.add("oxygène");
list.add("où");
list.add("ou");
Collections.sort(list);

- 48 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

System.out.println(list);

On pourrait s'attendre à obtenir un résultat par ordre alphabétique, c'est à dire : "ou, où, oxygène". Or on obtient
le résultat suivant :

[ou, oxygène, où]

Ce résultat est dû au fait que le tri s'effectue sur la valeur unicode des caractères. Or le caractère 'ù' prend la valeur
249 alors que 'u' et 'x' ont respectivement les valeurs 117 et 120. Ce qui fait que le caractère 'x' vient s'intercaler entre
les caractères 'u' et 'ù', ce qui peut être gênant dans une langue comme le français où les accents ont une certaine
importance.

Pour remédier à cela, il faut utiliser la classe Collator, qui permet d'effectuer des comparaisons en prenant en compte
la locale :

Collections.sort(list, Collator.getInstance(Locale.FRANCE));

La méthode statique Collator.getInstance() permet de créer une nouvelle instance de Collator pour la locale. Le Collator
implémente l'interface Comparable afin de comparer les chaînes de caractères.

De plus, les Collators permettent également de fixer des contraintes plus ou moins fortes concernant la comparaison
des caractères, et permet de définir 4 niveaux via la méthode setStrength() :

• IDENTICAL : Les caractères doivent être strictement identiques.


• TERTIARY : Diminue les contraintes de IDENTICAL en ignorant les différences sur les caractères de contrôles
(ex: \u0001 == \u0002).
• SECONDARY : Diminue les contraintes de TERTIARY en ignorant les différences de case minuscule/
majuscule (ex: 'a' == 'A').
• PRIMARY : Diminue les contraintes de TERTIARY en ignorant les accents (ex: 'a' == 'à' == 'â' == 'ä' == 'A'
== 'Ä' etc.)

Attention toutefois, étant données que les Collators se basent sur des règles plus complexes, ils peuvent prendre plus
de temps que la comparaison standard des chaînes.

lien : How should I compare String objects?


lien : java.text.Collator

Comment convertir une chaîne en nombre ?


Auteurs : Clément Cunin ,
Méthode parseXXX()
La conversion de chaînes de caractères en valeurs numériques est assurée par les différentes classes de gestion des types
de base de Java : java.lang.Integer, java.lang.Double, java.lang.Float, java.lang.Long, java.lang.Byte. La chaîne ne doit
contenir que le nombre à convertir : toute erreur lève l'exception java.lang.NumberFormatException.

Exemple :

int i = Integer.parseInt(maString);
long l = Long.parseLong(maString);
byte b = Byte.parseByte(maString);

- 49 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

// etc...

Pour convertir une chaîne hexadécimale en entier il faut utiliser la méthode suivante:

Integer.parseInt(hexa, 16);

Le 16 spécifie la base à utiliser pour parser l'entier.

Méthode XXXXFormat.parse(pattern)
Une autre méthode, plus lourde mais aussi plus flexible consiste à utiliser un Formatter pour parser la chaîne en nombre.
Cette méthode vous permet de parser les nombres en tenant compte de l'internationalisation du séparateur décimal.

NumberFormat monFormatteurDeNombre = NumberFormat.getInstance();


// par défaut localisation France sur mon ordinateur
String maChaine = "1053,52";
double resultat = monFormatteurDeNombre.parse(maChaine).doubleValue();
// Le parse doit catcher l'exception ParseException

lien : Comment convertir un nombre en chaîne ?

Comment convertir un nombre en chaîne ?


Auteurs : Clément Cunin ,
Methode toString(valeur)
La conversion de chaîne de caractères en valeurs numériques est assurée par les différentes classes de gestion des types
de base de Java : java.lang.Integer, java.lang.Double, java.lang.Float, java.lang.Long, java.lang.Byte.

Exemple :

String chaine = Integer.toString(monInt);


String chaine = Long.toString(monLong);
String chaine = Byte.toString(monByte);
// etc...

lien : Comment convertir une chaîne en nombre ?


lien : Comment convertir un nombre en chaîne formatée ?

Comment convertir un nombre en chaîne formatée ?


Auteurs : L'équipe Java ,
La classe java.text.DecimalFormat permet de formater une valeur numérique dans le format de son choix en utilisant
un pattern dont les symboles principaux sont les suivants :

• 0 permet de représenter un chiffre qui devra obligatoirement être présent, même s'il s'agit d'un zéro inutile.
• # permet de représenter un chiffre en ignorant les zéros inutiles.
• . (le point) permet de représenter le séparateur de la partie décimale.
• , (la virgule) permet de représenter le séparateur des groupes (milliers, millions, etc.).

(vous pouvez vous reporter à la documentation de la classe DecimalFormat pour obtenir la liste complète de tous les
symboles).

- 50 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le nombre de 0 et/ou de # dans le pattern détermine la taille des parties entière et décimale de la valeur numérique,
sachant que 0 représentera un chiffre obligatoirement présent (et éventuellement remplacé par un zéro inutile) et # un
chiffre optionnel (qui ignorera donc les zéro inutile).

Par exemple, pour afficher un nombre réel avec 2 décimales, on utilisera le code suivant :

DecimalFormat df = new DecimalFormat("0.00");


System.out.println(df.format(mon_nombre));

Vous trouverez dans le tableau suivant quelques exemples de pattern :

Format 0 0,02 0,8 12,9


# 0 0 1 13
### 0 0 1 13
0 0 0 1 13
000 000 000 001 013
#.## 0 0,02 0,8 12,9
0.## 0 0,02 0,8 12,9
0.00 0,00 0,02 0,80 12,90
#.00 ,00 ,02 ,80 12,90
#,##0.00 0,00 0,02 0,80 12,90

Par défaut, la partie entière sera toujours agrandit même si le pattern précise un nombre d'élément moins important.

A noter que toutes les caractéristiques du pattern peuvent être modifié par les méthodes de la classe DecimalFormat, et
que la classe NumberFormat permet d'obtenir un certain nombre de formatage standard via des méthodes statiques.

Enfin, à partir de Java 5.0 il est possible d'utiliser une syntaxe proche du printf() du C via la classe java.util.Formatter.
Dans la pratique on n'utilisera pas directement cette classe mais des méthodes l'utilisant comme PrintStream.printf()
ou String.format().

Cette syntaxe différencie les types entiers (short, int, long et BigInteger) des types réels (float, double et BigDecimal).

Les types entiers sont représentés par la syntaxe %d :

System.out.printf ("%d", 12); // Affiche 12

Quelques exemples de formatage pour la valeur 12 :

Syntaxe Exemple Description


%d "12" Valeur entière.
%5d " 12" Valeur entière sur 5
caractères minimum
(complété par des espaces
avant le nombre).
%-5d "12 " Valeur entière sur 5
caractères minimum

- 51 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

(complété par des espaces


après le nombre).
%05d "00012" Valeur entière sur 5 chiffres
minimum, complété par des
zéros.

Les types réels sont quand à eux représentés par la syntaxe %f :

System.out.printf ("%f", 1234.567); // Affiche 1234,567000

Quelques exemples de formatage pour la valeur 1234.567 :

Syntaxe Exemple Description


%f "1234,567000" Valeur réelle avec 6
décimales par défaut.Valeur
réelle avec 6 décimales par
défaut. Valeur réelle avec 6
décimales par défaut.
%5f "1234,567000" Valeur réelle sur 5 caractères
minimum (partie entière +
décimale).
%.0f "1235" Partie entière sans décimale.
%.2f "1234,57" Valeur réelle avec 2
décimales.
%10.2f " 1234,57" Valeur réelle sur 10
caractères minimum, avec 2
décimales
%,.2f "1 234,57" Valeur réelle avec 2
décimales et séparateur de
millier.

Note : il est possible d'utiliser des formats scientifiques et exponentielles avec %g et %e...

La documentation de la classe java.util.Formatter contient toutes les informations détaillées sur la syntaxe à utiliser.

Note : Ces deux solutions (Formatter et DecimalFormat) utilisent les spécificités de la locale par défaut pour formater
la chaine (caractère de séparateur de millier, des décimales, etc.). Il est bien sûr possible de préciser une autre locale
via les paramètres des méthodes ou du constructeur.

lien : Comment convertir un nombre en chaîne ?


lien : java.text.NumberFormat
lien : java.text.DecimalFormat
lien : java.util.Formatter

Comment convertir un nombre entier décimal en une


chaîne représentant ce nombre dans une autre base ?
Auteurs : Nourdine Falola ,
Conversion en base 2, 8, 16 : int toXXXString()

- 52 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

La classe Integer dispose de 3 méthodes statiques permettant de convertir un entier décimal en une chaîne représentant
son équivalent binaire, octal et hexadécimal.

int intBase10 = 192;


String intBase2 = Integer.toBinaryString(intBase10); // "11000000"
String intBase8 = Integer.toOctalString(intBase10); // "300"
String intBase16 = Integer.toHexString(intBase10); // "c0"

public static String toString(int i,int base)

Afin d'obtenir la représentation dans la base de son choix d'un entier décimal, la classe Integer dispose des méthodes
statiques toString().

int intBase10 = 19587;


String intBase2 = Integer.toString(intBase10,2); // "100110010000011"
String intBase5 = Integer.toString(intBase10,5); // "1111322"
String intBase27 = Integer.toString(intBase10,27); // "qnc"

Si la base n'est pas dans l'intervalle [Character.MIN_RADIX,Character.MAX_RADIX], alors la base 10 est utilisée.

Comment convertir une chaîne représentant un nombre entier en base quelconque en un entier décimal ?
Auteurs : Nourdine Falola ,
Comment convertir une chaîne représentant un nombre entier en base quelconque en un entier décimal ?

La méthode statique parseInt() de la classe Integer permet de convertir une chaîne représentant un nombre entier en
base quelconque en un entier décimal.

parseInt("99", 8) // throws a NumberFormatException


parseInt("Kona", 10) // throws a NumberFormatException
parseInt("Kona", 27) //returns 411787
parseInt("-0", 10) //returns 0
parseInt("-FF", 16) //returns -255
parseInt("1100110", 2) //returns 102

Integer decode(String nm) throws NumberFormatException

La méthode decode() de la classe Integer permet de convertir en Integer une chaîne vérifiant la grammaire suivante :

• (-) DecimalNumeral
• (-) 0x HexDigits
• (-) 0X HexDigits
• (-) # HexDigits

- 53 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• (-) 0 OctalDigits

Comment convertir une date en chaîne ?


Auteurs : Clément Cunin ,
La conversion d'une date en chaîne de caractères est délicate au premier abord. En effet, le format des dates est très
différent d'une langue à l'autre. Heureusement, les fonctions d'internationalisation de Java vont faire le travail à notre
place...

// IMPORT
import java.util.Locale;
import java.text.DateFormat;

// 1. Choix de la langue
Locale locale = Locale.getDefault();

/** 2. Construction du DateFormat en choisiant un format :


* SHORT = 01/01/2002
* FULL = lundi 1 janvier 2002
*/
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL, locale);

// 3. Affichage
System.out.println(dateFormat.format(maDate));

Si vous souhaitez utiliser un format de sortie plus exotique, vous pouvez accéder directement à la classe
java.text.SimpleDateFormat.

DateFormat dateFormat = new SimpleDateFormat("hh'h'mm dd-MM-yy");


//résultat : "23h59 31-12-2000"

lien : Comment convertir une date en chaîne ?

Comment convertir une chaîne en Date ?


Auteurs : Grégory Danelon ,
Pour convertir une chaine en date, il faut connaître le format de la date. Par défaut, une seule classe dans l'API gère
les formats de date : java.text.SimpleDateFormat. On utilise le parser de date pour effectuer la conversion. Voici une
méthode générique :

public static Date stringToDate(String sDate, String sFormat) throws Exception {


SimpleDateFormat sdf = new SimpleDateFormat(sFormat);
return sdf.parse(sDate);
}

Le parser déclenche l'exception ParseException quand la chaine ne respecte pas le format. La documentation sur
java.text.SimpleDateFormat décrit le format d'une date, et des lettres à utiliser pour caractériser le jour, le mois, ... etc.
Cette méthode est valable à partir du JDK 1.1
Un exemple d'utilisation est fourni en téléchargement.

- 54 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Comment convertir une date en chaîne ?


Exemple d'utilisation.

Comment convertir des 'char' en ASCII ?


Auteurs : Clément Cunin ,
Définition du type char :
Le type 'char' de Java est un type primitif, codé sur 16 bits, qui contient la valeur unicode du caractère. De plus, le type
'char' est un entier non-signé qui peut contenir des valeurs de 0-65535; Toutes les opérations arithmétiques sont légales
( voir Les spécifications du langage Java ).

Conversion en ASCII :
La manière la plus simple de passer de l'Unicode à l'ASCII est d'utiliser la classe java.lang.String.

try {
String chaine = "Ma chaîne à traduire !";

// traduction en tableau de code ASCII :


byte[] bytes = chaine.getBytes("ASCII");

// affichage à l'écran :
for( int i=0; i<bytes.length; i++ ) {
System.out.println( bytes[i] );
}
} catch( java.io.UnsupportedEncodingException e ) {
// Le codage n'est pas reconnu.
e.printStackTrace();
}

Conversion dans d'autres formats :


Quelques autres formats d'encodage sont gérés par Java en interne : US-ASCII, ISO-8859-X (1 à 7), UTF-8, UTF-16BE,
UTF-16LE, UTF-16. (voir la classe java.nio.charset.Charset pour plus d'informations)

lien : Encodage des bytes et des chaines


lien : Convertion des textes Non-Unicode

Comment gérer l'encodage d'un tableau de bytes dans des String ?


Auteurs : cyberzoide ,
Pour faire cela, on peut utiliser le constructeur de String prenant en paramètre un tableau de bytes ainsi que l'encodage
à utiliser.

Voici un exemple permettant de convertir une chaîne codée en UTF-8 en ISO-8859-1 (Latin 1, français)

byte[] bytesUTF8 = ... ;

- 55 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

byte[] bytesISO = new String(bytesUTF8, "ISO-8859-1").getBytes();

Comment découper facilement une chaîne ?


Auteurs : Clément Cunin , Jean-Baptiste Bugeaud ,
JDK 1.0 :
Il faut utiliser un objet java.util.StringTokenizer qui permet aisément de découper une chaîne en sous-chaînes séparées
par des délimiteurs que l'on peut préciser.

JDK 1.4 :
Le JDK 1.4 apporte la gestion des expressions régulières, le découpage d'une chaîne est maintenant possible directement
de la classe java.lang.String grâce à la méthode split(java.lang.String regex).

Comment utiliser des caractères bizarres tels que : ? ?


Auteurs : Johann Heymes ,
Rien de plus facile ! Java utilise la norme Unicode pour gérer les chaînes de caractères. Il suffit donc de se reférer au
site http://www.unicode.org/charts/ et d'utiliser le code proposé sous le caractère souhaité.

Exemple :
Nous désirons afficher dans notre application le caractère ? .
Il s'agit d'un caractère de type mathématique. Une rapide étude de la liste Mathematical Operators nous permet de
trouver le code 2200.

monJTextArea.append( "\u2200 le caractère unicode Java le connait." );

Attention :
Le résultat de l'affichage d'un caractère bizarre dans une console sous Windows ou sous Linux dépend de l'encodage
supporté par la console ; dans la pratique cela marche rarement.

lien : Le site du Consortium Unicode


lien : La page proposant les listes
Exemple d'implémentation.

Quelle est la longueur maximale d'une chaîne de caractères ?


Auteurs : Clément Cunin ,
Les chaînes de caractères ne sont pas vraiment limitées en java. On notera cependant que les caractères de la chaîne
sont indexés par des 'int', ce qui nous fixe une limite à 2^32 caractères (soit une chaîne de plus de 4Go en mémoire).

Note :

- 56 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Attention, si vous manipulez des chaînes (modification, concaténation, etc ...) et à plus forte raison des chaînes de grande
taille, vous devez utiliser des java.lang.StringBuffer (Comment concatener des chaînes de caractères ?).

lien : Comment concatener des chaînes de caractères ?

Comment concatener des chaînes de caractères ?


Auteurs : Clément Cunin ,
Théoriquement, chaque fois que l'on doit créer ou modifier une chaîne par concaténation. Dans la pratique, il est
nécessaire de bien comprendre comment Java gère les chaînes de caractères et les concaténations pour manipuler
efficacement les chaînes.

La classe String :
En Java, une instance de la classe String est dite non-mutable, c'est à dire qu'après avoir été créée, la chaîne ne peut plus
être modifiée. Cela s'avère très pratique dans beaucoup de situations : inutile par exemple de dupliquer une instance
de String pour s'assurer qu'elle restera constante (comme c'est le cas en C++ par exemple). Mais cette propriété se
révèle désastreuse avec l'emploi de l'opérateur '+' pour la concaténation de chaîne, car chaque étape de la concaténation
implique la construction d'une nouvelle instance de String.

String resultat = ""; // création d'un chaine vide


for( int i=0; i<10; i++) {
resultat = resultat + i;
}
System.out.println(resultat); // "0123456789"

Lors de l'éxecution de ce programme, chaque itération de la boucle construit une nouvelle instance de String. Chaque
itération oblige donc la JVM à trouver de la place en mémoire, instancier l'objet, copier le contenu des 2 chaînes dans
la nouvelle, libérer la mémoire, recommencer à l'itération suivante. Cela revient à créer 10 instances de String pour
les résultats intermédiaires.

La classe StringBuffer :
La classe java.lang.StringBuffer est une classe qui gère une chaîne modifiable. Cette classe a été spécialement conçue
pour manipuler des chaînes de caractères...

StringBuffer sb = new
StringBuffer(20); // 20 = une estimation de la taille maximale de notre chaîne.
for( int i=0; i<10; i++) {
sb.append(i);
}
System.out.println(sb.toString()); // "0123456789"

Ce code produit exactement le même résultat que le précédent, sauf qu'il instancie un seul objet là où 10 étaient
nécessaires.

La classe StringBuffer :
Depuis J2SE 5.0 (Tiger), vous pouvez aussi utiliser la classe StringBuilder (du package java.lang). Son fonctionnement
est identique à celui de StringBuffer à la différence qu'il n'est pas "thread-safe". Si vous n'avez pas besoin de
synchronization (comme c'est souvent le cas), préférez StringBuilder car il sera plus performant.

Note :

- 57 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Si vous ne précisez pas la taille maximale ou que vous sous-estimez cette taille, StringBuffer/StringBuilder recréera
automatiquement son tableau de caractères pour pouvoir accueillir votre texte, mais cette option est aussi coûteuse que
la création d'une instance de String, il convient donc de choisir intelligemment cette valeur.

Comment faire des calculs de précision corrects avec des floats ou des doubles ?
Auteurs : duj ,
Si vous essayez ceci :

System.out.println(1.3-1.2);

Vous obtenez : 0.10000000000000009 au lieu de 0.1 , comme indiqué sur votre calculatrice. En fait, il est impossible
de représenter exactement 0.1 ou n'importe quelle puissance négative de 10 au moyen d'un float ou d'un double. La
meilleure solution pour résoudre ce problème est d'utiliser la classe java.math.BigDecimal. On l'utilise par exemple
comme ceci:

BigDecimal bd1 = new BigDecimal("1.3");


BigDecimal bd2 = new BigDecimal("1.2");
System.out.println(bd1.substract(bd2));

Attention, les chiffres que vous voulez représenter doivent être passés comme des Strings dans le constructeur

Comment arrondir un nombre ?


Auteurs : Clément Cunin , Johann Heymes , adiGuba ,
Arrondir un réel en entier :
Il suffit d'utiliser la méthode Math.floor() pour arrondir un réel à l'entier inférieur le plus proche :

double a = Math.floor(1.99); // 1.0

A l'inverse la méthode Math.ceil() permet arrondir un réel à l'entier supérieur le plus proche :

double a = Math.ceil(1.01); // 2.0

Si l'on souhaite respecter la règle standard de l'arrondi, en utilisant l'entier supérieur ou inférieur le plus proche selon
la valeur partie décimale, il suffit d'ajouter 0.5 à la valeur passé à Math.floor() :

double a = Math.floor(1.99+0.5); // 2.0

double a = Math.floor(1.49+0.5); // 1.0

• Si la valeur de la partie décimale est inférieure à [b]0.5[/b], la valeur sera arrondie à l'entier inférieur.
• Si la valeur la partie décimale est supérieur ou égale à [b]0.5[/b], la valeur sera arrondie à l'entier supérieur.

Attention : on pourrait également utiliser un cast vers les types int ou long pour "perdre" la partie décimale, mais
cela peut poser des problèmes avec des grandes valeurs car les cast peuvent conduire à une perte d'information par
troncature.
Arrondir un réel à 'n' décimales :

- 58 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

On peut également faire un arrondi à 'n' décimales en utilisant le code suivant :

double a = 1.6666666;
// Arrondir la valeur a 10^-2
a *= 100.0;
a = Math.floor(a+0.5);
a /= 100.0; // 1.67

Pour simplifier on peut utiliser directement cette méthode

/**
* Arrondi d'un double avec n éléments après la virgule.
* @param a La valeur à convertir.
* @param n Le nombre de décimales à conserver.
* @return La valeur arrondi à n décimales.
*/
public static double floor(double a, int n) {
double p = Math.pow(10.0, n);
return Math.floor((a*p)+0.5) / p;
}

Qui s'utilise de la manière suivante :

double a = floor(1.6666666, 2); // 1.67

Mais attention toutefois, on peut obtenir un résultat incorrect lorsqu'on s'approche de la limite maximum des doubles
( 1e308 quand même). Pour des résultats plus précis, on pourra se trouver vers la classe BigDecimal et ses méthodes
setScale().
Arrondir pour afficher :
En revanche, si le résultat est destiné à une conversion en chaîne de caractères, il est préférable de se tourner vers la
classe java.text.DecimalFormat (plus d'info ici)

lien : Comment convertir un nombre en chaîne formatée ?

Quelles API utiliser pour faire des maths ?


Auteurs : Ioan Calapodescu ,
Voici la description de différents "outils" pouvant vous permettre de faire des calculs mathématiques. Les deux premiers
sont des classes faisant partie du JDK standard, le dernier est une API du projet Jakarta Commons.

• Math (package java.lang) : La classe Math contient un ensemble de méthodes statiques permettant de faire des
opérations numériques basiques (logarithmes, exponentielles ou fonctions trigonométriques). Contrairement à la
classe StrictMath, les différentes implémentations d'une même méthode ne donnent pas le même résultat "bit
à bit". On peut quand même noter que, en général, les implémentations des méthodes de la classe Math font
appel aux méthodes de StrictMath. Si la précision n'est pas le critère primordial, vous pouvez préférer Math à
StrictMath pour des raisons de performance.
• StrictMath (package java.lang) : Les méthodes de StrictMath sont les mêmes que celles de Math, à la différence
que les résultats obtenus sont les mêmes que ceux produits par la fdlibm (Freely Distributable Math Library).
Plus d'informations dans la description de la classe StrictMath : http://java.sun.com/j2se/1.5.0/docs/api/java/lang/
StrictMath.html
• Math 1.0 (Jakarta Commons) : Cette API (disponible à cette adresse : http://jakarta.apache.org/commons/math/)
met à la disposition du développeur Java un plus grand nombre d'algorithmes mathématiques et statistiques. Plus
d'informations dans la documentation : http://jakarta.apache.org/commons/math/userguide/index.html

- 59 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Il en existe bien d'autres, plus d'informations sur la page API.

Comment obtenir des nombres aléatoires ?


Auteurs : Ioan Calapodescu ,
Pour tout connaître de la génération de nombres aléatoires, je vous conseille de regarder cet excellent tutoriel de Hugo
Etiévant : Génération de variables aléatoires uniformes, normales et exponentielles avec l'API Random de Java.

lien : http://cyberzoide.developpez.com/java/random/

Comment empêcher les expressions régulières d'interpréter une sous-chaînes ?


Auteurs : adiGuba ,
Il est utile de 'protéger' certaines chaînes de caractères avant de les utiliser dans une expression régulière. En effet, de
nombreux caractères peuvent être interprétés par les regexp alors qu'on souhaite simplement représenter le caractère
lui-même...

Le moyen le plus simple est de protéger ces caractères avec un anti-slash afin d'indiquer qu'ils ne doivent pas être
interprétés... Toutefois, cette solution ne peut se limiter qu'à des expressions simples, et elle est complexe à mettre en
place lorsque la chaîne provient d'une saisie utilisateur...

Dans ce cas, il est préférable d'utiliser les éléments de quotation \Q et \E. En effet, toute la sous-chaîne comprise entre
ces deux éléments sera protégée lors de son traitement par les expressions régulières (il faut bien sûr penser à doubler
l'anti-slash).

Il existe dans Java 5.0 une méthode statique permettant de protéger une chaîne simplement : Pattern.quote(String).
Pour information, cette méthode se contente généralement de renvoyer la chaîne entouré par \Q et \E. Elle gère toutefois
le cas particulier où cette dernière contiendrait déjà le code \E.
Si vous n'utilisez pas encore Java 5.0, cette méthode correspond au code suivant :

La méthode Pattern.quote() :
public static String quote(String s) {
int slashEIndex = s.indexOf("\\E");
if (slashEIndex == -1)
return "\\Q" + s + "\\E";

StringBuffer sb = new StringBuffer(s.length() * 2);


sb.append("\\Q");
slashEIndex = 0;
int current = 0;
while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
sb.append(s.substring(current, slashEIndex));
current = slashEIndex + 2;
sb.append("\\E\\\\E\\Q");
}
sb.append(s.substring(current, s.length()));
sb.append("\\E");
return sb.toString();
}

lien : Pourquoi dois-je doubler/quadrupler le caractère anti-slash ('\') ?

- 60 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Documentation de la classe Pattern

Comment remplacer une sous-chaîne en la reportant dans la chaîne de remplacement ?


Auteurs : adiGuba ,
Les expressions régulières permettent de créer des groupes lors d'un remplacement. Un groupe est simplement entouré
de parenthèses. Ainsi, si on veut formater un texte HTML afin que toutes les occurences d'une chaîne soient entourées
par une balise <strong>, on peut utiliser le code suivant :

String texte = "Un simple mot et un autre mot...";


String resultat = texte.replaceAll("(mot)", "<strong>$1</strong>");

Explication : Lors du remplacement, le contenu du groupe (mot) sera reporté dans la chaîne de remplacement par son
indice ($1 en l'occurrence). Ainsi, dans notre exemple, le code $1 de la chaîne de remplacement sera remplacé par la
chaîne "mot", pour obtenir :

Un simple <strong>mot</strong> et un autre <strong>mot</strong>...

Ceci est d'autant plus utile lorsqu'on utilise un pattern plus complexe. Par exemple, pour créer des balises <a href/>
lorsqu'on trouve une URL dans un texte, on peut utiliser le code suivant :

Création de lien HTML pour les URL :


String texte = "Bienvenue sur http://www.developpez.com !!!";
String resultat = texte.replaceAll("(http://[^ ]*)", "<a href='$1'>$1</a>");

Il est bien sûr possible d'utiliser plus d'un groupe, l'indice dépendra alors de la position du groupe dans le texte, sachant
que la lecture se fait de gauche à droite. L'expression ((A)(B(C))) donnera :

• $1 : ABC
• $2 :A
• $3 : BC
• $4 :C

Il faut bien sûr veiller à ce que tous les groupes soient correctement fermés...

lien : Documentation de la classe Pattern

Pourquoi dois-je doubler/quadrupler le caractère anti-slash ('\') ?


Auteurs : adiGuba ,
Java, comme beaucoup d'autres langages, utilise le caractère anti-slash ('\') afin de représenter des caractères spéciaux,
tels que \n et \t (pour le retour à la ligne et la tabulation), les quottes (\" et \') et les caractères unicodes (\u**** où ****
correspond au code unicode).

Ceci afin de pouvoir les insérer dans une String ou un char, alors qu'ils ne sont pas forcément représentable dans un
code source, ou qu'ils rentreraient en conflit avec la grammaire du langage...

Ainsi, lors de la compilation, ces séquences sont transformées vers leurs caractères équivalents. Donc, afin de pouvoir
utiliser le caractère anti-slash comme un simple caractère, il faut utiliser la séquence le représentant, c'est à dire \\.

- 61 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

D'ailleurs, si une séquence commençant par \ n'est pas reconnue par le compilateur, la compilation échouera ("invalid
escape sequence").

Ainsi, la chaîne "MOT1 \\ MOT2" dans le code source donnera bien MOT1 \ MOT2 lors de l'exécution du programme :
pour représenter un caractère anti-slash, il faut le doubler.

Toutefois, bien qu'on ne souhaite représenter qu'un seul caractère \, il peut être parfois nécessaire de le quadrupler. En
effet, le package java.util.regex permet de manipuler des Expressions régulières (ou regexp). Les expressions régulières
représentent une famille de notations compactes et puissantes permettant de décrire des "modèles" (pattern) de chaînes
de caractères. Elles utilisent pour cela un grand nombre de caractères spéciaux permettant de représenter d'autres
ensembles de caractères (Cf. la documentation de la classe Pattern pour plus de détails). Or il se trouve que les
expressions régulières utilisent le caractères anti-slash afin de 'protéger' ces caractères spéciaux, c'est à dire pour leurs
permettre d'être utilisés comme de simples caractères. Donc pour représenter le caractère anti-slash il faut encore le
doubler.
Etant donné que les expressions régulières interprètent la chaîne de caractère lors de l'exécution du programme, il faut
donc qu'il soit quadruplé dans le code source (une fois à la compilation et une fois à l'exécution).

Exemples :

Code Source A l'exécution Interprétation des regexps


"abc\abc" Erreur de compilation : "invalid -
escape sequence : \a"
"abc\\abc" abc\abc abcabc (\a est équivalent à a pour les
regexp)
"abc\\\abc" Erreur de compilation : "invalid -
escape sequence : \a"
"abc\\\\abc" abc\\abc abc\abc

Donc pour obtenir le caractère \ dans une expression régulière, il faut le quadrupler dans le code source !!!

lien : Documentation de la classe Pattern

Comment déterminer précisément le nombre de caractères d'une chaîne ?


Auteurs : adiGuba ,
La réponse peut sembler évidente : il suffit d'utiliser la méthode length() de la classe String.

Mais si l'on regarde de plus près, on s'aperçoit que cette méthode renvoit en réalité le nombre de char utilisés pour
représenter la chaîne. Or un char en Java est codé sur 2 octets alors que les caractères Unicodes peuvent avoir une taille
variable selon l'encodage et l'alphabets (entre 1 et 4 octets).

Ainsi la valeur renvoyé par la méthode length() reflète donc la taille occupée en mémoire et non pas le nombre de
caractères de la chaîne (même si dans la majorité des cas le résultat sera le même).

Ainsi, afin de connaitre avec précision le nombre de caractères réels de la chaîne, il est neccéssaire d'utiliser la méthode
codePointCount() de la classe String, qui permet de renvoyer le nombre de caractères Unicode entre deux emplacement
de la chaîne, quel que soit leurs tailles en mémoire. Ainsi, pour connaitre le nombre de caractères effectif d'un String,
il faut utiliser le code suivant :

String str = ... // la chaine


int count = str.codePointCount(0, str.length());

- 62 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

L'exemple suivant permet de mettre en évidence cette différence en utilisant une lettre gothique codé sur 4 octets :

String testString = "\uD800\uDF30";


int charCount = testString.length();
int characterCount = testString.codePointCount(0, charCount);

System.out.printf("char count: %d\n", charCount);


System.out.printf("character count: %d\n", characterCount);

Qui nous donne le résultat suivant :

char count: 2
character count: 1

lien : How long is your String object?

Comment effectuer un tirage aléatoire ?


Auteurs : Baptiste Wicht ,
Pour effectuer un tirage aléatoire, il faut utiliser la classe Random. Cette classe va nous permettre d'effectuer des
générations de nombre pseudo-aléatoire.

On peut tirer des chiffres de différents types : boolean, byte, double, float, int et long. Tout cela au moyen des méthodes
nextXXX() de la classe Random.

Une particularité avec un tirage d'int est le fait que l'on puisse configurer la séquence sur laquelle le nombre va être
tiré. On peut en effet passer un paramètre int à la méthode nextInt() qui sera le nombre maximum à tirer, le nombre
minimal étant zéro.

Random random = new Random();

int pseudoRandomNumber = random.nextInt(); //Un nombre aléatoire


int pseudoRandomNumberTwo = random.nextInt(25); //Un nombre aléatoire entre 0 et 25

Comment supprimer les accents d'une chaîne ?


Auteurs : divxdede ,
Selon votre version de Java et vos besoins, il y a plusieurs solutions possibles à cet épineux problème.

Avec Java 6, il est possible d'utiliser la classe java.text.Normalizer afin de décomposer le codage unicode des accents
en deux "caractères" :
Le premier caractère correspond à la lettre sans aucune accentuation.
Le second caractère est un "diacritique", c'est à dire un signe qui s'ajoute au caractère auquel il est associé.

Ces caractères diacritiques font partie de la plage unicode 0300-036F.


Il est donc possible de les supprimer assez facilement avec une expression régulière, par exemple :

public static String sansAccents(String source) {


return Normalizer.normalize(source, Normalizer.Form.NFD).replaceAll("[\u0300-\u036F]", "");
}

- 63 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Malheureusement cette classe n'est pas présente sous cette forme dans l'API des versions précédentes de Java. En effet
cette classe faisait partie de l'API propriétaire de Sun et se nommait sun.text.Normalizer.

public static String sansAccents(String s) {


return Normalizer.normalize(s, Normalizer.DECOMP, 0).replaceAll("[\u0300-\u036F]", "");
}

S'il est toutefois possible de l'utiliser tel quel, il faut bien prendre en compte qu'il s'agit d'une classe "non standard/
portable" qui pourrait très bien ne pas exister dans une JVM standard, et qu'il est donc fortement conseillé de ne pas
utiliser.

La troisième solution consiste à utiliser une librairie externe comme ICU4J :

public static String sansAccents(String s) {


Transliterator accentsconverter = Transliterator.getInstance("NFD; [:M:] Remove; NFC; ");
return accentsconverter.transliterate(s);
}

Il s'agit toutefois d'une bibliothèque assez conséquente (plus de 4 Mo dans sa dernière version).

Enfin la dernière solution consiste tout simplement à coder manuellement une classe prévue à cet effet, comme cet
exemple dans les sources Java : Supprimer les accents d'une chaine

- 64 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > Gestion des dates


Comment connaître l'heure courante ?
Auteurs : Clément Cunin ,
Le constructeur par défaut de la classe java.util.Date construit une date initialisée à l'heure courante du système.

lien : Comment convertir une date en chaîne ?


lien : Comment mettre à jour l'heure courante du système ?

Comment mettre à jour l'heure courante du système ?


Auteurs : Clément Cunin ,
L'API standard ne permet pas de modifier l'heure du système. La seule solution est de passer par une commande externe.

lien : Comment exécuter une application externe ?


lien : Comment connaître l'heure courante ?

Comment faire des opérations sur des dates ?


Auteurs : Johann Heymes ,
Tout est prévu, il n'y a qu'à utiliser les classes de Sun tel que :
• java.util.GregorianCalendar
• java.util.Calendar
• java.util.Date

Tout d'abord il nous faut une instance de GregorianCalendar

GregorianCalendar calendar = new java.util.GregorianCalendar();


// Initialisé à la date et l'heure courrante.
calendar.setTime( maDate );
// Initialisé avec une instance de Date.

Voici ensuite quelques exemples d'opération (pour plus d'information lire la doc, évidemment...)
- sur le champs "jour" (7 jours plus tôt) :

calendar.add (Calendar.DATE, -7);

- sur le champs "mois" (5 mois plus tard) :

calendar.add (Calendar.MONTH, 5);

Et pour ce qui est des affichages je vous conseille d'utiliser la solution proposée Comment convertir une date en chaîne ?
en utilisant la méthode

- 65 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public Date calendar.getTime ();

Comment convertir une date en chaîne ?


Auteurs : Clément Cunin ,
La conversion d'une date en chaîne de caractères est délicate au premier abord. En effet, le format des dates est très
différent d'une langue à l'autre. Heureusement, les fonctions d'internationalisation de Java vont faire le travail à notre
place...

// IMPORT
import java.util.Locale;
import java.text.DateFormat;

// 1. Choix de la langue
Locale locale = Locale.getDefault();

/** 2. Construction du DateFormat en choisiant un format :


* SHORT = 01/01/2002
* FULL = lundi 1 janvier 2002
*/
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL, locale);

// 3. Affichage
System.out.println(dateFormat.format(maDate));

Si vous souhaitez utiliser un format de sortie plus exotique, vous pouvez accéder directement à la classe
java.text.SimpleDateFormat.

DateFormat dateFormat = new SimpleDateFormat("hh'h'mm dd-MM-yy");


//résultat : "23h59 31-12-2000"

lien : Comment convertir une date en chaîne ?

Comment convertir une chaîne en Date ?


Auteurs : Grégory Danelon ,
Pour convertir une chaine en date, il faut connaître le format de la date. Par défaut, une seule classe dans l'API gère
les formats de date : java.text.SimpleDateFormat. On utilise le parser de date pour effectuer la conversion. Voici une
méthode générique :

public static Date stringToDate(String sDate, String sFormat) throws Exception {


SimpleDateFormat sdf = new SimpleDateFormat(sFormat);
return sdf.parse(sDate);
}

Le parser déclenche l'exception ParseException quand la chaine ne respecte pas le format. La documentation sur
java.text.SimpleDateFormat décrit le format d'une date, et des lettres à utiliser pour caractériser le jour, le mois, ... etc.
Cette méthode est valable à partir du JDK 1.1
Un exemple d'utilisation est fourni en téléchargement.

- 66 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Comment convertir une date en chaîne ?


Exemple d'utilisation.

Comment connaître la date de création d'un fichier ?


Auteurs : L'équipe Java ,
Date de création :
Aucune solution n'est disponible pour connaître la date de création d'un fichier. Certains systèmes comme Linux ne
fournissant pas cette information, aucun solution portable n'est possible.

Date de la dernière modification :


Là, en revanche, aucun problème, la méthode lastModified() de la classe java.io.File est disponible.

long dateModification = monFichier.lastModified();

Toutefois, le long retourné par la méthode lastModified() peut dépendre du système d'exploitation et donc ne pas être
toujours extrêmement précise.

Comment forcer le parsing d'une Date à échouer en cas de Date incorrecte ?


Auteurs : bulbo ,
Par défaut la classe DateFormat essaie d'interpréter une date incorrecte. Ainsi le 31 février 2000 retournera un objet
Date valide.

Date d = new SimpleDateFormat("dd/MM/yyyy").parse("31/02/2000");


System.out.println("Date: " + d);

Ce code retourne la date suivante: Thu Mar 02 00:00:00 CET 2000


Pour forcer la classe SimpleDateFormat à retourner une erreur, il faut utiliser la méthode setLenient(false).
Le code suivant retournera une exception:

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");


sdf.setLenient(false);
System.out.println("Date: " + sdf.parse("31/02/2000"));

java.text.ParseException: Unparseable date: "31/02/2000"

Comment vérifier la validité d'une date ?


Auteurs : Morpheus2144 ,
Il faut utiliser la propriété Lenient de l'objet Calendar, cela forcera le parsing de la date à échouer si la date est invalide.

Les messages d'exceptions indique même d'ou vient l'erreur ("MONTH", "DAY_OF_MONTH").

On peut donc utiliser ce problème en parsant la date et en voyant s'il y a une erreur :

- 67 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public boolean estValide(int annee, int mois, int jour){


Calendar c = Calendar.getInstance();
c.setLenient(false);
c.set(annee,mois,jour);
try{
c.getTime();
}
catch(IllegalArgumentException iAE){
return false;
}

return true;
}

Remarques :

• Ne pas oublier que pour un objet Calendar les mois commence à 0 et les jours à 1
• L'exception est relevée lors du getTime() et non pas du set(), donc vous pourrez créer un calendar non valide
mais pas l'utiliser

lien : Comment forcer le parsing d'une Date à échouer en cas de Date incorrecte ?

- 68 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > Gestion des threads


Qu'est ce qu'un thread ?
Auteurs : Clément Cunin ,
Définition :
Un thread désigne un point d'exécution dans le programme. En fait, le langage Java est multi-thread, c'est à dire qu'il
peut exécuter du code à plusieurs endroits de façon indépendante.

Exemple d'utilisation :
L'utilisation des threads est très fréquente dans la programmation réseau. Un client FTP peut télécharger plusieurs
fichiers, naviguer sur plusieurs serveurs en même temps, chaque connexion étant gérée par un thread différent. Autre
exemple : dans un traitement de texte, un thread s'occupe de ce que tape l'utilisateur, un autre est en charge de souligner
les erreurs, un 3ème se charge de faire parler le trombone ! :-)

lien : Comment créer un thread ?


lien : Programmation des Threads en Java par Valère VIANDIER

Comment créer un thread ?


Auteurs : Clément Cunin ,
Créer un thread est très simple en Java. Deux solutions s'offrent à vous :

Dériver de la class Thread :


Vous pouvez créer une nouvelle classe qui dérive de la classe java.lang.Thread. Il suffit ensuite de redéfinir la méthode
run(). C'est cette méthode que le thread va exécuter.

Implémenter java.lang.Runnable :
Si vous ne souhaitez pas faire une classe dédiée à la gestion du processus, vous pouvez simplement implémenter
l'interface java.lang.Runnable et définir la méthode run(). Ensuite il suffit de créer un objet java.lang.Thread en lui
passant la classe en paramètre.

Dans tous les cas :


Pour lancer l'exécution d'un thread vous devez exécuter la méthode start() et en aucun cas exécuter vous-même la
méthode run() (L'exécution se déroulerait alors dans le processus courant !).

lien : Qu'est ce qu'un thread ?


lien : Comment terminer un thread sans la méthode stop() ?
lien : Programmation des Threads en Java par Valère VIANDIER

Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?


Auteurs : Clément Cunin ,
Pour ceux qui maîtrisent l'anglais, un petit tour sur le site de Sun : http://java.sun.com/j2se/1.4/docs/guide/misc/
threadPrimitiveDeprecation.html.

Pour les autres, toutes ces méthodes ont été marquées deprecated car, sous certaines conditions et sans qu'il y ait d'erreur
de conception, l'application peut se bloquer. Typiquement, lorsqu'un thread est tué, il n'est pas possible de savoir ce

- 69 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

qu'il était en train de faire, il est donc possible qu'il soit arrêté au milieu d'une modification d'un objet; cet objet est donc
laissé dans un état incohérent. Des problèmes similaires peuvent se produire avec les méthodes suspend() et resume().

lien : Comment terminer un thread sans la méthode stop() ?


lien : Qu'est ce qu'une méthode 'deprecated' ?
lien : Programmation des Threads en Java par Valère VIANDIER

Comment terminer un thread sans la méthode stop() ?


Auteurs : Clément Cunin ,
La méthode stop() de la classe java.lang.Thread étant dépréciée, il est nécessaire de prévoir soit-même la possibilité
d'arrêter le processus.

Squelette standard d'un Thread


Ce squelette permet de facilement arrêter le processus sans utiliser la méthode dépréciée stop().

/** Ce boolean sera utilisé pour signaler au


* processus s'il doit continuer ou s'arrêter.
*/
private boolean stopThread = false;

public void run() {


boolean fin = false;

while( !fin ) {
try {
// traitement

synchronized(this) {
Thead.yield();

// lecture du boolean
fin = this.stopThread;
}
} catch( InterruptedException e ) {

}
}
}

public synchronized void stop() {


this.stopThread = true;
}

2ème squelette standard


La solution précédente est adaptée aux threads qui effectuent régulièrement le même traitement. Si le traitement est
très long, il peut être nécessaire de tester la requête de fin en cours de traitement. Le plus simple est alors de lever une
exception en cours de traitement.

private boolean stopThread = false;

public synchronized void testFin() throws InterruptedException {


if( stopThread ) {
throw new InterruptedException();
}
}
public void run() {
try {

- 70 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

// traitement avec un appel régulier à testFin();


} catch( InterruptedException e ) {

}
}
public synchronized void stop() {
this.stopThread = true;
}

Attention : les appels à la méthode testFin() doivent être effectués uniquement lorsque tous les objets sont dans un état
cohérent. (voir :Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?).

lien : Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?
lien : Programmation des Threads en Java par Valère VIANDIER

Comment faire une "pause" dans mon application ?


Auteurs : bahamouth ,
On peut simuler une "pause" dans l'exécution d'une application en utilisant la méthode sleep() de la classe Thread.
Cette méthode force le Thread courant à cesser son exécution pendant le temps passé en paramètres.

Par exemple :

long milliSecondes = 500L;


int nanosSecondes = 6000;
Thread.sleep(milliSecondes, nanosSecondes);
// ou
Thread.sleep(milliSecondes);

Ces deux méthodes sont susceptibles de lever une InterruptedException.

Ou trouver plus d'informations sur les Threads ?


Auteurs : Ioan Calapodescu ,
Pour mieux comprendre l'utilisation des Threads, vous pouvez vous pencher sur ces deux tutoriels :

• Programmation des Threads en Java, première partie par Valère VIANDIER.


• Sémaphores et Mutex en Delphi et Java par Wormful_sickfoot.

Depuis J2SE 5.0, java dispose aussi du package java.util.concurrent qui permet une meilleure gestion des concurrences.

lien : Programmation des Threads en Java, première partie


lien : Sémaphores et Mutex en Delphi et Java
lien : Package java.util.concurrent

- 71 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > Structures de données -Tableaux et collections


Comment bien utiliser les collections ?
Auteurs : Clément Cunin ,
Les collections font partie de Java (J2SE) depuis la version 1.2. Les collections proposent une série de classes, d'interfaces
et d'implémentations pour gérer efficacement les données.

Pour chaque type de structure de données (liste, ensemble, association) existe une interface et plusieurs implémentations.
Chaque implémentation utilise une stratégie avec des avantages et des inconvénients. Il est important de bien
comprendre les différentes stratégies pour choisir l'implémentation la plus performante en fonction de ses besoins.

Conseil :
Tout d'abord, afin de minimiser la quantité de code à modifier pour changer d'implémentation, il convient de
toujours faire référence aux collections en utilisant les interfaces, seule l'étape de construction faisant référence à
l'implémentation.

// La bonne solution :
List list = new ArrayList();
Set set = new HashSet();
Map map = new TreeMap();
// La mauvaise solution :
ArrayList list = new ArrayList();
HashSet set = new HashSet();
TreeMap map = new TreeMap();

Il peut néanmoins arriver qu'on soit contraint d'utiliser la 2ème solution pour avoir accès aux méthodes spécifiques
à l'implémentation. En effet les classes concrètes sont souvent plus riches que les interfaces, ce qui peut se révéler
nécessaire pour tirer le meilleur parti possible d'une implémentation.

Détails :
Les java.util.Set (ensembles) sont un groupe d'éléments uniques.
Les java.util.List (listes) sont une suite d'éléments ordonnés accessibles par leur indice (leur place dans la liste). Les
listes ne garantissent pas l'unicité des éléments.
Les java.util.Map (associations) mémorisent une collection de couples clé-valeur. Si vous avez une clé, l'association
retrouvera la valeur associée à cette clé. Les clés sont uniques, mais la même valeur peut-être associée à plusieurs clés.

lien : Quel différence entre HashSet, TreeSet et LinkedHashSet ?


lien : Quelles différences entre ArrayList, LinkedList et Vector ?
lien : Quels sont les différents types de Map ?

Quel différence entre HashSet, TreeSet et LinkedHashSet ?


Auteurs : Clément Cunin ,
L'API propose trois implémentations concrètes pour les ensembles (java.util.Set). Un ensemble est un groupe d'élément
uniques.

java.util.HashSet :
Le java.util.HashSet est la plus utile des implémentations.
Note : L'ordre d'itération des éléments est aléatoire.
Complexité : Les opérations add, remove, contains and size sont exécutées en un temps constant.

- 72 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

java.util.TreeSet :
Le java.util.TreeSet contient un ensemble d'éléments ordonnés (il implémente également l'interface java.util.SortedSet).
Les éléments sont ordonnés en fonction de leur ordre naturel (voir java.util.Comparable), ou en fonction d'un
java.util.Comparator précisé à la construction du TreeSet.
Complexité : Les opérations add, remove, contains and size sont exécutées en un temps log(n).

java.util.LinkedHashSet :
Un java.util.LinkedHashSet est identique au HashSet sauf qu'il conserve l'ordre d'insertion des éléments dans une liste
doublement chainée.
Note : L'ordre d'itération des éléments correspond à l'ordre d'insertion, l'ordre reste inchangé si l'on ajoute un élément
déjà présent.
Complexité : Les opérations add, remove, contains and size sont exécutées en un temps constant (mais supérieur au
temps du HashSet car il faut également gérer la liste chainée).

lien : Comment bien utiliser les collections ?

Quelles différences entre ArrayList, LinkedList et Vector ?


Auteurs : Clément Cunin ,
L'API propose deux implémentations concrètes pour les listes (java.util.List). Une liste est une suite ordonnée d'éléments
(les éléments peuvent être ajoutés à plusieurs endroits de la liste).

java.util.ArrayList :
Un java.util.ArrayList utilise un tableau en interne pour ranger les données. Un ArrayList fournit un accès aux éléments
par leur indice très performant et est optimisé pour des opérations d'ajout/suppression d'éléments en fin de liste.
Complexité : Les opérations size, isEmpty, get, set, iterator sont exécutées en temps constant.
Les opérations d'ajout/suppression sont exécutées en temps constant amorti (les ajouts/suppressions en fin de liste sont
plus rapides).

java.util.LinkedList :
Un java.util.LinkedList utilise une liste chainée pour ranger les données. L'ajout et la suppression d'éléments est aussi
rapide quelle que soit la position, mais l'accès aux valeurs par leur indice est très lente.
Complexité : Les opérations size, isEmpty, add, remove, set, get sont exécutées en temps constant. Toutes les méthodes
qui font référence à un indice sont exécutées en temps O(n).

java.util.Vector :
La classe java.util.Vector est une classe héritée de Java 1. Elle n'est conservée dans l'API actuelle que pour des raisons
de compatiblité ascendante et elle ne devrait pas être utilisée dans les nouveaux programmes. Dans tous les cas, il est
préférable d'utiliser un ArrayList.
Note : Cette classe est "thread-safe", c'est-à-dire que plusieurs processus peuvent l'utiliser en même temps sans risque.
Complexité : idem que pour ArrayList, plus le temps de synchronisation des méthodes.

lien : Comment bien utiliser les collections ?

Quels sont les différents types de Map ?


Auteurs : Clément Cunin ,
L'API propose cinq implémentations concrètes pour les 'Map' (java.util.Map). Une map permet de créer un ensemble
de couples clé/valeur (On parle aussi de tableaux associatifs), la clé permettant de retrouver rapidement la valeur qui
lui a été associée. Les clés sont des objets uniques pouvant être NULL; Les valeurs peuvent être multiples et NULL.

- 73 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

java.util.HashMap :
La classe java.util.HashMap est l'implémentation concrète la plus standard, elle est adaptée à la plupart des situations.

java.util.TreeMap :
La classe java.util.TreeMap ajoute une fonction de tri des clés de la Map. L'ordre des clés peut être choisi en donnant
une instance de java.util.Comparator sinon c'est l'ordre naturel des clés qui sera utilisé (elles doivent donc implémenter
java.lang.Comparable). Si vous avez une grande quantité de données à ajouter dans la collection et que l'ordre clés n'est
utile qu'après l'ajout, il est plus efficace de créer un HashMap pour ajouter les éléments et de construire la TreeMap
à partir de la HasMap :

Map map = new HashMap();


// Toutes les operations pour ajouter les éléments...
map.put(....);

// ... puis on construit la TreeMap.


map = new TreeMap(map);

java.util.LinkedHashMap :
La classe java.util.LinkedHashMap conserve l'ordre d'ajout des clés (même principe que Quel différence entre HashSet,
TreeSet et LinkedHashSet ? avec un set). Si la clé ajoutée est déjà présente, l'ordre ne change pas.

java.util.IdentityHashMap :
La classe java.util.IdentityHashMap, contrairement aux autres implémentations concrètes, utilise l'opérateur '==' pour
savoir si deux clés sont identiques (les autres utilisent le résultat de la méthode equals(java.lang.Object)).

java.util.WeakHashMap :
La classe java.util.WeakHashMap conserve les couples en utilisant des références faibles, donc si la clé n'est
plus référencée ailleurs dans le programme, le couple est automatiquement supprimé de la collection (voir
java.lang.ref.WeakReference).

java.util.Hashtable :
La classe java.util.Hashtable est une classe héritée de Java 1. Elle n'est conservée dans l'API actuelle que pour des
raisons de compatiblité ascendante et elle ne devrait pas être utilisée dans les nouveaux programmes. Dans tous les cas,
il est préférable d'utiliser un HashMap.

lien : Comment bien utiliser les collections ?

Comment créer une pile (LIFO) ?


Auteurs : Clément Cunin ,
La classe Stack
La classe java.util.Stack pourrait correspondre à nos besoins, mais elle hérite de Vector, ces méthodes sont synchronisées
et donc plus lentes que si l'on créait une pile en se basant sur une collection de l'API java 2 ( voir : Comment bien
utiliser les collections ?).

La classe LinkedList
La classe java.util.LinkedList contient toutes les méthodes nécessaires à la création d'un pile : addFirst(Object o),
getFirst() et removeFirst(). On peut donc très bien utiliser cette classe comme une pile.

Créer sa propre classe

- 74 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le but n'est pas de réinventer la roue, mais juste d'utiliser une classe qui porte le nom 'Stack' ou 'Pile' pour plus de
clarté dans le code source sans plomber les performances avec la classe Stack de Java 1. L'implémentation proposée ici
est basée sur le modèle des collections de Java2, elle utilise une interface Stack et une classe concrète LinkedStack.

lien : Comment bien utiliser les collections ?


Stack.java LinkedStack.java

Comment augmenter la taille d'un tableau ?


Auteurs : Clément Cunin ,
La taille d'un tableau est fixée lors de sa construction et ne peut plus être modifiée. La seule solution consiste à créer
un nouveau tableau plus grand et à copier les anciennes valeurs dans le nouveau tableau. Pour effectuer la copie de
tableau, on utilise la méthode arraycopy(java.lang.Object, int, java.lang.Object, int, int) de la classe java.lang.System
bien plus performante qu'une itération.

/** la méthode simple */


int[] nouveau = new int[longueur];
System.arraycopy(vieuxTableau,0,nouveau,0,vieuxTableau.length);
/** Note : On place ici les anciennes valeurs au début du nouveau tableau. */

Note :
La création d'un nouveau tableau est une opération coûteuse en terme de performances, si vous devez utiliser une
structure de données dont la taille change souvent, il est fortement conseillé d'utiliser une liste (Quelles différences entre
ArrayList, LinkedList et Vector ?).

lien : Quelles différences entre ArrayList, LinkedList et Vector ?

Comment fonctionne un ArrayList ?


Auteurs : Clément Cunin ,
Bien utiliser une structure de données implique d'en comprendre le fonctionnement. Les classes java.util.Vector et
java.util.ArrayList fonctionnent de la même manière (Quelles différences entre ArrayList, LinkedList et Vector ?).

Structure interne :
Les données de la liste sont rangées dans un tableau d'objets. Le principal intérêt d'un ArrayList ou d'un Vector étant de
pouvoir facilement ajouter un élément à la liste, le tableau utilisé en interne est surdimensionné par rapport au besoin.
Exemple : Un ArrayList de 5 éléments pourrait utiliser un tableau de 10 éléments, lorsque qu'on ajoute un nouvel
élément, on le place dans la 1ère case libre du tableau interne, on n'est pas obligé d'instancier un nouveau tableau.
Evidemment, à force d'ajouter des éléments, le tableau interne peut se trouver saturé, dans ce cas un nouveau tableau
est créé et les anciennes valeurs sont recopiées dedans.

Optimisation :
La gestion automatique de la taille du tableau interne ne nous empêche pas de donner un coup de main pour améliorer
les performances. Lors de la création d'une liste, il est important d'utiliser un constructeur précisant la capacité (taille
du tableau interne), il est en général facile d'estimer la taille moyenne de sa structure de données, on évite ainsi de passer
par plusieurs dizaines de réallocation du tableau interne. De même, avant d'insérer une grande quantité d'information,
il est possible de demander de garantir une capacité minimale. Ces précautions sont d'autant plus importantes si la liste
contient beaucoup d'éléments.

lien : Comment bien utiliser les collections ?

- 75 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Quelles différences entre ArrayList, LinkedList et Vector ?

Comment trier une List (ArrayList, Vector, ...) ou un tableau?


Auteurs : braim , duj , Grégory Danelon ,
La classe java.util.Collections apporte la solution :

List ma_liste = new ArrayList();


Collections.sort(ma_liste);

ma_liste est ainsi triée par ordre croissant. Pour trier dans l'ordre décroissant, il suffit de faire ceci :

Collections.sort(ma_liste, Collections.reverseOrder());

Attention cependant, cet exemple fonctionne que si les éléments dans la liste sont de type Comparable, comme int,
String, Date, ... (voir l'interface java.lang.Comparable). Si ce n'est pas le cas (les éléments sont des objets que vous avez
défini), il faut que votre classe implémente l'interface java.lang.Comparable, donc en fait il faut définir la méthode int
compareTo(Object o). Prenons un exemple simple :

class Voiture {
String marque = "";
int nbCheveau = 0;

public Voiture(String s, int i) {


marque = s;
nbCheveau = i;
}

public int getNbCheveau() { return nbCheveau; }

public String toString() { return marque + "\t" + nbCheveau; }


}

On veut pouvoir trier une liste de Voiture suivant leur nombre de chevaux. Voilà alors les modifications à apporter
à la classe :

class Voiture implements java.lang.Comparable {


// méthode à implémenter
/**
* @param other other doit être de type Voiture !
*/
public int compareTo(Object other) {
int nombre1 = ((Voiture) other).getNbCheveau();
int nombre2 = this.getNbCheveau();
if (nombre1 > nombre2) return -1;
else if(nombre1 == nombre2) return 0;
else return 1;
}
}

Maintenant, vous pouvez trier facilement une liste de voitures :

Collections.sort(liste_voitures);

Le code est identique pour un tableau. Il faut seulement utiliser la classe Arrays.

- 76 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Arrays.sort(unTableauDeVoitures);

Vous avez aussi la possibilité de facilement mélanger une liste grâce à la méthode shuffle de Collections.

lien : Comment bien utiliser les collections ?


lien : Quelles différences entre ArrayList, LinkedList et Vector ?

Comment déterminer si un objet est un tableau ?


Auteurs : Clément Cunin ,
Tout simplement en faisant :

boolean estUnTableau = monObjet.getClass().isArray();

Comment déterminer le nombre de dimensions d'un tableau ?


Auteurs : Clément Cunin ,
Cette propriété n'est pas directement accessible, mais une petite fonction permet de la calculer rapidement. On se base
sur le fait qu'un tableau à plusieurs dimensions est en fait un tableau de tableaux.

public static int getNbDimension( Object monTableau ) {


int dim=0;
Class cls = monTableau.getClass();
while( cls.isArray() ) {
cls = cls.getComponentType();
dim++;
}
return( dim );
}

Comment instancier un tableau?


Auteurs : vasilov ,
Pour instancier un tableau, il faut :

• Réserver la place en mémoire pour les N références vers les objets du tableau,
• Réserver la place pour chaque objet, car la création d'un tableau d'objets, va créer un tableau rempli de null

Par exemple :

Point[] p = new Point[10];


// réserver la place en mémoire pour 10 références vers des objets Point
for(int i=0 ; i<p.length ; i++) {
p[i] = new Point(i, i+10); // réserve en mémoire la place pour un objet point (10 fois)
}

Si l'on essaye d'instancier des tableaux d'objets sans réserver la place de chaque objets en mémoire, on reçoit une
exception «NullPointerException » lors de l'accès à l'objet. Comme par exemple en créant un tableau de Point comme
on créerais un tableau d'int.

- 77 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Alors qu'avec un tableau de types primitifs, chaque "case" du tableau est directement rempli avec la valeur par défaut
de celui-ci, car un type primitif ne peut pas être null.

lien : Comment agrandir un tableau ?

Comment agrandir un tableau ?


Auteurs : Clément Cunin ,
En Java, les tableaux ne sont pas extensibles. On doit donc procéder en 2 étapes, créer un nouveau tableau plus grand,
puis copier toutes les valeurs de l'ancien tableau dans le nouveau.

Object nouveauTableau = Array.newInstance( ancienTableau.getClass().getComponentType(),


nouvelleTaille );
System.arraycopy( ancienTableau, 0, nouveauTableau, Array.getLength(ancienTableau);

Note :
Avant de vous embarquer dans cette solution, réfléchissez bien si un .ArrayList ou un Vector ne seraient pas plus
appropriés à votre problème.

Comment parcourir tous les éléments d'un tableau ?


Auteurs : Nourdine Falola ,
Boucle "for"
A l'ancienne, avec une boucle for traditionnelle

int tab[50];
...
for (int index = 0; index < tab.length; index++)
System.out.println(tab[index]);

Boucle "for each"


Le JDK 5.0 apporte une construction de boucle performante qui permet de parcourir tous les éléments d'un tableau,
ou d'un objet implémentant l'interface Iterable (ArrayList, ...), sans se préoccuper de l'indice.

int tab[50];
...
for (int n : tab)
System.out.println(n);

Comment caster un type non-paramétré vers son équivalent paramétré ?


Auteurs : adiGuba ,
Les Generics introduits dans Java 5.0 permettent une compatibilité avec les anciennes librairies qui utiliserait
leurs équivalent non paramétrés. Ainsi s'il est possible d'affecter une référence non-paramétré dans son homologue
paramétré, par exemple :

Map<String,String[]> parameters = request.getParameterMap(); // retourne une Map

- 78 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Malheureusement, ce code génère un warning car il n'est pas sécurisé :

warning: [unchecked] unchecked conversion

En effet il est impossible pour le compilateur de vérifier que l'objet non-paramétré respectent les conditions de la
déclaration en Generics. Ainsi dans notre exemple la Map retourné par getParameterMap() pourrait très bien contenir
des objets de type différents sans que le compilateur ne puisse le détecter, ce qui provoquerait des exceptions inattendus
lors de l'utilisation de la variable parameters.

Toutefois, ce type d'affectation peut s'avérer utile afin d'utiliser conjointement des API Generics avec d'autres qui ne
le sont pas, surtout que dans cet exemple la documentation de la méthode précise bien que la Map renvoyé respecte
bien la déclaration Map<String,String[]>.

On peut ainsi utiliser l'annotation @SuppressWarning pour indiquer au compilateur que l'on prend en charge la
sécurité de ce code :

@SuppressWarnings("unchecked")
Map<String,String[]> parameters = request.getParameterMap();

L'annotation @SuppressWarning ne pouvant pas s'appliquer à une seule instruction en dehors des déclarations de
variable, on peut utiliser la méthode suivante afin de limiter son scope d'utilisation :

/**
* Cast non sécurisé.<br/>
* Cette méthode permet de caster des types non-paramétré en
* type paramétré.<br/>
* Exemple :
* {@code List<String> list = uncheckedCast( maListeNonParamétré ); }
* <br/>
* <b>Attention :</b> cela peut avoir des effets de bords
* indésirables si la référence en paramètre ne respectent
* pas le type paramétré !
*
* @param <P> Type du paramètre de la méthode.
* @param <R> Type de la valeur de retour.
* @param p Paramètre à "caster".
* @return La référence 'p', castée dans le type de R.
* @throws ClassCastException en cas de type incompatible.
*/
@SuppressWarnings("unchecked")
public static <P,R extends P> R uncheckedCast(P p) throws ClassCastException {
return (R) p;
}

Map<String,String[]> parameters = null;


parameters = uncheckedCast(request.getParameterMap());

Cette méthode est très proche d'un cast standard et permet les mêmes vérifications.

Quelques exemples :

Object reference = new ArrayList();


Map<String,String> map = uncheckedCast(reference); // ClassCastException

- 79 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Ce code compilera sans erreur (car une référence de type Object pourrais contenir une Map), mais génèrera une
exception à l'exécution (puisqu'en réalité il contient un type incompatible avec Map).

ArrayList reference = new ArrayList();


Map<String,String> map = uncheckedCast(reference); // Erreur

A l'inverse, ce code provoquera une erreur car le compilateur détectera que la type de la référence est incompatible
avec le type attendu.

Attention : La sécurité du code et de la correspondance entre le type standard et la déclaration utilisant les Generics
est entièrement à la charge du développeur. Une mauvaise utilisation pourrait provoquer des erreurs d'exécutions plus
loin dans le code.

lien : [Java 5.0] Comment supprimer un warning en particulier ?

Pourquoi ne peut-on pas instancier de tableau paramétré ?


Auteurs : adiGuba ,
Le compilateur interdit toute création de tableau de type paramétré, ainsi la ligne suivante provoquera
irrémédiablement une erreur :

List<String> stringListArray[] = new List<String>[100];

Ce problème vient du fait que les tableaux et les Generics ont une approche totalement opposée de la vérifications des
types.

Avec les tableaux, la quasi-totalité des vérifications est effectué pendant l'exécution, et la plupart des opérations sur
les tableaux peuvent générer des ClassCastException selon le type réel du tableau et le type réel de l'élément qu'on
lui affecte.

A l'inverse, les Generics sont sécurisé à la compilation. C'est à dire que c'est le compilateur qui se charge de vérifier la
cohérence de l'ensemble pendant la compilation, et qui garantit l'absence d'exception pendant l'exécution.

Du fait de leurs fortes oppositions et de l'héritage particulier des tableaux, l'utilisation de tableaux Generics peut aboutir
à des situations complètement fausses et générer des exceptions inattendus.

Ainsi, si la création de tableaux Generics étaient possible, il serait relativement simple de passer outre la protection des
Generics sans warnings ni erreurs :

List<String>[] stringListArray = new List<String>[100]; // ERREUR

Object[] simpleArray = stringListArray;

simpleArray[0] = new ArrayList<Number>(); // OK ?!?!?

Le pire c'est que ce code ne génèrerait même pas d'exception lors de son exécution. Au contraire l'exécution serait
reporté lors de l'utilisation des données du tableaux alors qu'il devrait s'agir d'un code sécurisé...

Bref, l'utilisation de tableaux Generics est loin d'assurer la sécurité de code promise par les Generics, et le compilateur
interdit donc leurs créations.

- 80 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Il existe pourtant deux alternatives.

La meilleur solution serait d'utiliser l'API de Collection, et donc une List à la place du tableau. En effet dans ce cas le
cas de figure décris ci-dessus, l'utilisation des Generics permettrait d'être avertit du problème via un warning :

List<List<String>> stringListList = new ArrayList<List<String>>();

List simpleList = stringListList;

simpleList.add( new ArrayList<Number>() ); // Warning unchecked

La seconde solution, à n'utiliser que si l'utilisation du tableau est vraiment une nécessité, consiste à créer un tableau
non-Generics et à ignorer le warning reçu :

@SuppressWarnings("unchecked")
List<String>[] stringListArray = new List[100];

Mais bien entendu cela ne corrige en rien le problème des tableaux Generics...

lien : Comment caster un type non-paramétré vers son équivalent paramétré ?

Comment trier un Map selon les valeurs et non pas les clés ?
Auteurs : djo.mos ,
Dans un Map, il n'y pas de notion d'ordre vu que l'on n'accède généralement pas à ses éléments par indice comme dans
une Liste mais plutôt par clés.

Trier un Map suivant les valeurs revient en fait à :

• Soit copier la liste des valeurs du Map dans une Liste et trier cette dernière : consultez "Comment trier une List
(ArrayList, Vector, ...) ou un tableau?" dans la FAQ. L'inconvénient est que l'on ne travaille plus sur le Map et
donc on n'a plus un accès direct aux éléments par clés.
• Ou encore récupérer l'ensemble des clés dans une Liste, la trier suivant les valeurs et accéder aux éléments
du Map en parcourant séquentiellement les éléments de cette Liste. L'avantage est qu'on accède toujours aux
éléments directement par clé dans le Map. C'est à cette méthode que l'on s'intéressera via un exemple.

Exemple:
Considérons la classe suivante :

public Class Personne {


private Long id;//Identifiant d'une personne
private int age;
private String nom;

//implémenter les getters et les setters


}

et supposons que l'on stocke un ensemble de personnes dans un Map avec l'identifiant comme clé.

Map<Long, Personne> personnes;

- 81 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pour trier ce Map en fonction de l'age des personnes par exemple, on procède comme suit :

1. Créer un Comparator qui compare deux personnes suivant l'age. Le problème est que l'on va trier l'ensemble des clés,
donc le Comparator reçoit deux identifiants (Long). Il suffit alors de passer le Map au Comparator dans le constructeur
pour que l'on puisse retrouver une personne via son identifiant.

public class PersonneComparator implements Comparator<Long>{


private Map<Long, Personne> personnes;//pour garder une copie du Map que l'on souhaite traiter

public PersonneComparator(Map<Long, Personne> personnes){


this.personnes = personnes; //stocker la copie pour qu'elle soit accessible dans compare()
}

public int compare(Long id1, Long id2){


//récupérer les personnes du Map par leur identifiant
Personne p1 = personnes.get(id1);
Personne p2 = personnes.get(id2);

//comparer les deux clés en fonction de l'age des personnes qu'ils indexent.
return p1.getAge() - p2.getAge();
}
}

2. Trier les clés du Map en utilisant ce Comparator.

List<Long> cles = new ArrayList<Long>(personnes.keySet());


Collections.sort(cles, new PersonneComparator(personnes));

3. Accéder aux éléments du Map en utilisant la liste triée.

for(Long id : cles){
Personne p = personnes.get(id);
...
}

Comment parcourir une Map ?


Auteurs : le y@m's , Baptiste Wicht , osopardo ,
On peut parcourir une collection de type Map au moyen d'Iterator. Pour cela, il suffit de récupérer soit les clefs avec la
méthode keySet() soit les valeurs avec la méthode values() et d'appeller ensuite la méthode iterator() sur la collection :

Parcours de clefs
Map<TypeClefs,TypeValeurs> map = new ClasseImplementantMap<TypeClefs,TypeValeurs>

for (Iterator<TypeClefs> i = map.keySet().iterator() ; i.hasNext() ; ){


System.out.println(i.next());
}

Parcours de valeurs
Map<TypeClefs,TypeValeurs> map = new ClasseImplementantMap<TypeClefs,TypeValeurs>

for (Iterator<TypeValeurs> i = map.values().iterator() ; i.hasNext() ;){


System.out.println(i.next());

- 82 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Parcours de valeurs
}

Pour les personnes n'ayant pas Java 5.0, il vous suffira de supprimmer les generics.

On peut aussi récupérer les clefs et les valeurs avec une seule boucler. Il suffit pour cela de boucler sur les clefs et de
récupérer ensuite la valeur à partir de la Map :

Map map = new ClasseImplementantMap();

for (Iterator i = map.keySet().iterator() ; i.hasNext() ; ){


TypeClefs key = i.next();
System.out.println("key = " + key + " value = " + map.get(key));
}

Depuis Java 5.0, on peut aussi utiliser la boucle for étendu pour parcourir une Map. Il suffit d'utiliser la méthode
entrySet() qui renvoie une collection de Map.Entry qui représentent un couple clé-valeur. Voici un exemple :

//Pour récupérer les clefs et les valeurs


for (Map.Entry<TypeClefs, TypeValeurs> e : map.entrySet()){
System.out.println(e.getKey() + " : " + e.getValue());
}

Pourquoi ne faut-il pas employer la classe Vector ?


Auteurs : Baptiste Wicht , glob ,
Il est déconseillé d'utiliser la classe Vector. En effet, celle-ci fait partie des vieilles du framework de collections de Java.
Ces méthodes ne respectent donc pas les standards de nommage des collections. De plus, cette classe est synchronisée,
c'est à dire qu'elle peut s'utiliser dans un environement multi-threadé mais cela résulte en une perte de performances.

Il vaut donc mieux utiliser la classe ArrayList qui s'utilise presque de la même manière que Vector, mais qui n'est pas
synchronisé et fait partie des nouvelles classes du framework.

Si vous avez tout de même besoin d'une collection synchronisée du type de Vector, il vous suffit d'utiliser la méthode
synchronizedList de la classe Collections :

List list = Collections.synchronizedList(new ArrayList(...));

Vous aurez ainsi une ArrayList tout à fait normale mais synchronisée.

lien : ArrayList
lien : Vector

- 83 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > La reflexivité


A quoi sert l'introspection ou la réflexivité, et comment l'utiliser ?
Auteurs : Ricky81 ,
L'introspection consiste en la découverte dynamique des informations propres à une classe Java ou à un objet. Ce
mécanisme est notamment utilisé au niveau de la machine virtuelle Java lors de l'exécution de votre programme, et
donne lieu à une API.

Le paquetage java.lang.reflect permet l'introspection en rendant possible l'accès aux classes, à leurs champs, méthodes
ou encore constructeurs, et à toutes les informations les caractérisant, même celles qu'on pensaient inaccessibles Elle
est également très utile pour instancier des classes de manière dynamique, dans le processus de sérialisation d'un bean
Java, ainsi que dans la génération de code.

Les méta données présentes dans les fichiers binaires renseignent sur le contenu de chaque classe répertoriée et
permettent à la jvm de procéder à des vérifications lors de l'exécution d'un programme (pensez à l'exception
java.lang.NoSuchMethodError).
La jvm utilise également ces informations pour vous proposer la complétion de code dans les environnements de
développement Java, ce qui se fait en temps réel (pas de génération à faire au préalable).

Des détails sur le format des méta données dans un fichier binaire sont disponibles dans les documents de spécification de
la machine virtuelle Java. Sachez seulement que les champs et méthodes sont identifiés par leur nom, le type (identifiants
spécifiques à la jvm) pour les champs, et la signature pour les méthodes. A partir de ces informations, la jvm sait
directement localiser la portion de byte code correspondant à l'implémentation d'une méthode.

lien : API Reflection

Comment connaître l'ensemble des classes dont hérite une classe ?


Auteurs : Ricky81 ,
Il existe dans la classe Class une méthode nommée getSuperClass(), c'est cette méthode que nous allons utiliser.

Class c = Class.forName("maClasse");
while((c=c.getSuperclass()) != null)
{
System.out.println(c.getName());
}

lien : API Reflection

Comment connaître l'ensemble des interfaces qu'implémente une classe ?


Auteurs : Ricky81 ,
Il existe dans la classe Class une méthode nommée getInterfaces() qui renvoie un tableau des interfaces implémentées
par la classe.

Class c = Class.forName("maClasse");
Class[] interfaces = c.getInterfaces();
for(int i=0;i<interfaces.length;++i)
{
System.out.println(interfaces[i].getName());

- 84 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : API Reflection

Comment connaître le nom du paquetage dans lequel se situe une classe ?


Auteurs : Ricky81 ,
Il existe dans la classe Class une méthode nommée getPackage() qui renvoie un objet de type java.lang.Package.

Class c = Class.forName("monPackage.maClasse");
Package p = c.getPackage();
System.out.println(p.getName());

lien : API Reflection

Comment récupérer la liste des méthodes d'une classe ?


Auteurs : Ricky81 ,
La liste des méthodes publiques (même celles héritées) est disponible grâce à la méthode getMethods().

Class c = Class.forName("maClasse");
java.lang.reflect.Method[] m = c.getMethods();

Il est également possible de récupérer une méthode par son nom et sa signature en utilisant la méthode :

getMethod(String name, Class[] parameterTypes)

lien : Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?
lien : Comment récupérer la liste des champs d'une classe ?
lien : API Reflection

Comment connaître la signature d'une méthode ?


Auteurs : Ricky81 ,
La classe java.lang.reflect.Method dispose d'un certain nombre de méthodes permettant de reconstituer la signature
d'une méthode. Voici un exemple de deux d'entre elles :

// m est un objet de type Method


Class r = m.getReturnType();
Class[] params = m.getParameterTypes();

lien : API Reflection

Comment récupérer la liste des champs d'une classe ?


Auteurs : Ricky81 ,
Il existe dans la classe Class une méthode nommée getFields(), c'est cette méthode que nous allons utiliser.

- 85 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Class c = Class.forName("maClasse");
java.lang.reflect.Field[] f = c.getFields();

Il est également possible de récupérer un champ par son nom en utilisant la méthode getField(String name).

lien : Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?
lien : Comment récupérer la liste des méthodes d'une classe ?
lien : API Reflection

Comment savoir si une méthode ou un champ est de classe ?


Auteurs : Ricky81 ,
Il existe une classe dans java.lang.reflect appelée Modifier.
Cette classe gère l'ensemble des informations définies pour un champ ou une méthode, à savoir : la visibilité, l'attribut
"constante" ainsi que le caractère statique. Ce sont essentiellement des méthodes de classe qui permettent de consulter
ces caractéristiques à partir d'un entier.

// m est un objet de type Method


int mod = m.getModifiers();
if(java.lang.reflect.Modifier.isStatic(mod))
{
System.out.println("méthode statique");
}

lien : Comment connaître la signature d'une méthode ?


lien : Comment déterminer l'ensemble des informations concernant un champ ?
lien : API Reflection

Comment déterminer l'ensemble des informations concernant un champ ?


Auteurs : Ricky81 , Baptiste Wicht ,
Il existe bien entendu les méthodes getName() et getType() qui renvoie des le nom et le type du champ. Une dernière
méthode permet d'obtenir les informations complémentaires : getModifiers(). Nous nous retrouvons avec un entier qu'il
faut analyser à l'aide de la classe java.lang.reflect.Modifier. Nous allons ici utiliser la méthode statique toString() pour
obtenir ces informations sous la forme d'une chaîne de caractères.

// f est un objet de type Field


int mod = f.getModifiers();
System.out.println(java.lang.reflect.Modifier.toString(mod));

Avec les infos de la méthode getModifiers(), vous pouvez aussi définir via la classe Modifier si les informations
contiennent quelque chose de spécifique, via les méthodes isXXX, par exemple :

// f est un objet de type Field


int mod = f.getModifiers();
System.out.println("f est static = " + Modifier.isStatic(mod));
System.out.println("f est transient = " + Modifier.isTransient(mod));
System.out.println("f est volatile = " + Modifier.isVolatile(mod));
...

lien : Comment connaître la signature d'une méthode ?

- 86 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : API Reflection

Comment accéder dynamiquement à la valeur d'un champ donné d'un objet ?


Auteurs : Ricky81 ,
Pour consulter ou modifier un champ donné d'un objet de façon dynamique, il faut commencer par récupérer l'objet
de type Field correspondant au champ en question. Il suffit ensuite d'appeler la méthode correspondante avec pour
premier paramètre l'objet cible.
Prenons l'exemple suivant où nous modifions le contenu du champ défini par la variable nomChamp de l'objet obj en
lui donnant la valeur définie par la variable val.

void changeValeur(Object obj, String nomChamp, Object val) throws Exception


{
java.lang.reflect.Field f = obj.getClass().getField(nomChamp);
f.set(obj,val);
}

Un exemple de consultation de la valeur d'un champ donné :

void afficheValeur(Object obj, String nomChamp) throws Exception


{
Field f = obj.getClass().getField(nomChamp);
System.out.println(f.get(obj));
}

Remarque : les methodes set et get sont des méthodes générales mais il existe aussi des équivalents pour les types
classiques : setDouble(Object obj, double d) ou setBoolean(Object obj, boolean z).

lien : Comment lancer dynamiquement une méthode donnée d'un objet ?


lien : Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?
lien : Y a-t-il un moyen de consulter et/ou de modifier la valeur d'un champ privé ?
lien : API Reflection

Comment lancer dynamiquement une méthode donnée d'un objet ?


Auteurs : Ricky81 ,
Nous allons utiliser la méthode invoke définie dans la classe Method :

Object invoke(Object obj, Object[] args)

Voici un exemple générique de lancement dynamique d'une méthode donnée sur un objet :

Object lancerMethode(Object obj, Object[] args, String nomMethode) throws Exception


{
Class[] paramTypes = null;
if(args != null)
{
paramTypes = new Class[args.length];
for(int i=0;i<args.length;++i)
{
paramTypes[i] = args[i].getClass();
}
}

- 87 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Method m = obj.getClass().getMethod(nomMethode,paramTypes);
return m.invoke(obj,args);
}

A noter que cette méthode ne fonctionne que pour les types exacts de classe pour les paramètres. C'est-à-dire qu'on ne
pourra pas utiliser une classe fille comme argument de paramètre.

lien : Comment lancer dynamiquement une méthode de classe donnée ?


lien : Comment accéder dynamiquement à la valeur d'un champ donné d'un objet ?
lien : Comment passer les types primitifs en paramètre lors de l'utilisation de la réflexivité ?
lien : API Reflection

Comment passer les types primitifs en paramètre lors de l'utilisation de la réflexivité ?


Auteurs : bulbo ,
Les types primitifs (byte, char, short, int, long, float, double, boolean) ont tous des wrapper dans le package java.lang.
Respectivement: Byte, Character, Short, Integer, Long, Float, Double, Boolean.

Chacune de ces classes contient une variable static TYPE de type Class. C'est cette classe qu'il faut utiliser pour spécifier
le type du paramètre; la valeur quand a elle sera contenue dans un objet du type du wrapper.

Exemple: Appel d'une méthode prenant un int en paramètre.

Dans cet exemple nous allons appeler la méthode statique abs(int) de la classe java.lang.Math

Class types[] = { Integer.TYPE };


Method method = Math.class.getMethod("abs", types);
Object parametres[] = { new Integer(-1) };
Integer iWrap = (Integer) method.invoke(null, parametres);
System.out.println("Valeur absolue de -1 = " + iWrap);

lien : Comment lancer dynamiquement une méthode donnée d'un objet ?


lien : API Reflection

Comment lancer dynamiquement une méthode de classe donnée ?


Auteurs : Ricky81 ,
Pour lancer dynamiquement une méthode de classe, le principe est le même que pour une méthode sur un objet (voir
lien). La signature de la méthode (classe Method) à utiliser étant :

Object invoke(Object obj, Object[] args)

Lorsque la méthode est de classe, le paramètre obj n'est pas évalué. Vous pouvez mettre n'importe quel objet ou tout
simplement null.

lien : Comment lancer dynamiquement une méthode donnée d'un objet ?


lien : Comment savoir si une méthode ou un champ est de classe ?

- 88 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : API Reflection

Y a-t-il un moyen de consulter et/ou de modifier la valeur d'un champ privé ?


Auteurs : Ricky81 ,
Après avoir récupéré un objet sur un champ privé (voir lien), vous pouvez tenter de désactiver la protection en utilisant
la méthode setAccessible(boolean b). Si l'utilisation de cette méthode ne provoque pas le déclenchement d'une exception
par un SecurityManager, vous allez pouvoir modifier la valeur du champ.

Exemple : prenons une classe Secret avec un champ privé priv de type String.

void modifierChamp(Secret s, String val)


{
Field f = s.getClass().getDeclaredField("priv");
f.setAccessible(true);
f.set(s,val);
}

lien : Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?
lien : API Reflection

Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?
Auteurs : Ricky81 ,
Les moyens mis à disposition par l'API Reflection permettent de passer outre les règles de l'encapsulation. Vous pourrez
consulter les champs et méthodes privés/protégés de la même manière que les champs et méthodes publiques, mais
en utilisant les méthodes getDeclaredFields et getDeclaredMethods (ainsi que leurs variantes) au lieu de getFields et
getMethods.

Exemple :

Class c = Class.forName("maClasse");
java.lang.reflect.Field[] f = c.getDeclaredFields();

Remarque : contrairement aux méthodes getFields et getMethods, getDeclaredFields et getDeclaredMethods ne renvoient


pas les informations héritées. Dans ce cas, il est nécessaire d'aller interroger la classe mère.

lien : Y a-t-il un moyen de consulter et/ou de modifier la valeur d'un champ privé ?
lien : API Reflection

[Java 5.0] Comment connaitre les annotations d'un élément ?


Auteurs : adiGuba ,
Java 5.0 permet de marquer certains éléments du langage avec des Annotations, ces dernières peuvent être accessibles
lors de l'exécution (seulement pour les annotations dont la rétention est RetentionPolicy.RUNTIME). Le package
java.lang.reflect se voit ainsi doté d'une nouvelle interface qui décrit quatre méthodes permettant d'accéder aux
annotations, on y trouve ainsi les méthodes suivantes :

• getAnnotation(Class) qui permet d'obtenir une annotation particulière (si elle est présente).
• getAnnotations() qui permet d'obtenir un tableau contenant toutes les annotations de l'élément.

- 89 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• getDeclaredAnnotations() qui permet d'obtenir un tableau contenant toutes les annotations directement
déclarées sur l'élément (en ignorant ainsi les annotations héritées de la classe parent).
• isAnnotationPresent(Class) qui permet simplement de savoir si une annotation particulière est présente.

Cette interface, nomméee AnnotatedElement, est implémentée par les classes suivantes : Class, Package, Constructor,
Method et Field. Enfin les classes Constructor et Method proposent également une méthode getParameterAnnotations()
afin d'accéder aux annotations de leurs paramètres...

lien : [Java 5.0] Qu'est-ce qu'une annotation ?


lien : API Reflection
lien : Tutoriel : Les Annotations de Java 5.0
lien : java.lang.reflect.AnnotatedElement

- 90 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > De C++ à Java


Quel est l'équivalent Java des pointeurs sur fonctions C/C++ ?
Auteurs : Clément Cunin ,
En Java il n'existe pas de pointeurs sur méthodes, il faut utiliser un objet là où en C/C++ vous utilisiez une fonction.

1ère étape : définiton d'une interface


On utilise des objets implémentant une interface commune. Cette interface devra définir le prototype de la fonction
à exécuter.

public interface IFonctionpublic void execute(int);

2ème étape : définition de classes implémentant l'interface


Ces classes définissent différentes implémentations de la fonction.

public class Fonction implements IFonction {


public void execute(int arg) {
/** Faire ce que l'on aurait fait dans la fonction
* en C/C++
*/
}
}

3ème étape : passage de paramètres et exécution


Il ne reste plus qu'à définir une fonction qui prend en paramètre une instance du type de l'interface et de faire appel
à la méthode définie dans cette interface.

public void fonction(IFonction uneFonction) {


uneFonction.execute(unint);
}

Un bel exemple d'une telle méthodologie est le système de callback de AWT: au lieu de passer des fonctions comme en
C/C++, on passe des instances de classes appelées Listener.

Une alternative intéressante est offerte par Jakarta Comons : l'API Functor. Un functor est une fonction qui peut être
manipulée comme un objet, ou un objet repésentant une fonction. Cette API définit trois types de functors : les prédicats
(retournent un booléen), les fonctions (retournent un Object) et les procédures (qui ne retournent rien).

Peut-on surcharger les opérateurs comme en C++ ?


Auteurs : Clément Cunin ,
NON.

- 91 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Cela fait partie des spécifications du langage. Les concepteurs de Java n'ont pas souhaité intégrer cette fonctionnalité
car le code qui découle de telles pratiques est beaucoup plus difficile à lire et à comprendre.

Comment faire pour hériter de plusieurs classes ?


Auteurs : Clément Cunin ,
L'héritage multiple n'est pas possible en Java. C'est l'une des propriétés fondamentales du langage, et c'est un point
qui le différencie de beaucoup d'autres langages objets. Ce choix a été fait pour éviter que les nombreux problèmes lié
à l'héritage en 'diamant' (une classe qui hérite de 2 parents qui héritent d'une classe commune !) ne se pose en Java.

Oui, mais comment faire alors ?


Afin de contourner le problème, Java introduit la notion d'interface. Une interface est une classe privée de toute
implémentation. Il devient alors possible de dériver d'une classe et d'en implémenter plusieurs autres. Cette solution
permet de contourner très élégamment les problèmes liés à l'héritage multiple.

Existe-t-il des templates en Java ?


Auteurs : L'équipe Java ,
Non, pas pour l'instant. Cependant Sun étudie, dans le cadre d'un processus communautaire ( community process ),
l'intégration d'un mécanisme de généricité à Java.

Les templates seront ajoutés à Java dans sa version 1.5, pour plus d'info http://developer.java.sun.com/developer/
technicalArticles/releases/generics/

lien : [Java 5.0] Qu'est-ce que les Generics (types paramétrés) ?


lien : Java 5.0 et les types paramétrés
lien : Présentation de Tiger : Les Générics
lien : http://developer.java.sun.com/developer/technicalArticles/releases/generics/

- 92 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Généralités > JNI


Qu'est-ce que JNI ?
Auteurs : adiGuba ,
Java Native Interface (JNI) est une interface de programmation standard permettant d'appeler des fonctions natives
au sein d'une classe Java.

Pour cela, la méthode Java est marqué avec le mot-clef native, et l'outil javah (fournit avec le JDK) permet de générer un
fichier d'entête C contenant la signature de la fonction native à implémenter et à exporter dans une librairie dynamique.

Le code natif n'étant pas binairement portable, il est nécessaire de générer une librairie par système/architecture cible.

JNI est souvent utilisé pour pallier les limites de Java dès que l'on s'approche des fonctionnalités systèmes spécifiques
à un système.

lien : Java Native Interface - API & Developer Guides

A quoi correspond java.library.path et comment le modifier ?


Auteurs : adiGuba ,
La variable système java.library.path comporte une liste de répertoire qui seront utilisés par la machine virtuelle pour
rechercher les librairies natives (*.dll pour Windows, *.so pour Unix/Linux, *.jnilib pour Mac).

Par défaut, Java respecte les conventions du système hôte pour le chargement des librairies natives, c'est à dire que
cette propriétée reprend les valeurs de variable d'environnement système :

• Sous [b]Windows[/b], cela correspond à la variable d'environnement [b]PATH[/b] (également utilisé pour
rechercher les applications).
• Sous [b]Unix/Linux[/b], cela correspond à la variable d'environnement [b]LD_LIBRARY_PATH[/b].
• Sous [b]Mac[/b], cela correspond à la variable d'environnement [b]DYLD_LIBRARY_PATH[/b].

En Java il suffit d'utiliser la methode System.getProperty() pour vérifier sa valeur :

String javaLibraryPath = System.getProperty("java.library.path");

Ici encore, la JVM respecte les conventions du système hôte et utilise son séparateur de chemin ( ';' sous Windows et ':'
pour les autres systèmes - on peut utiliser la valeur de File.pathSeparatorChar pour obtenir cela dynamiquement).

Il existe plusieurs solutions pour modifier la valeur du java.library.path :

• En ligne de commande en rajoutant [b]-Djava.library.path=la_nouvelle_valeur[/b] lors de l'appel de la JVM.


• Via la méthode [b]System.setProperty()[/b] afin de remplacer la valeur existante.

Toutefois ces solutions ont le désavantage d'écraser les valeurs par défaut, ce qui peut poser des problèmes avec d'autres
librairies natives. Pour éviter cela il est préférable d'ajouter un élément plutôt que de remplacer la valeur existante :

public static void appendToJavaLibraryPath(String newPath) {


String javaLibraryPath = System.getProperty("java.library.path");
System.setProperty("java.library.path", javaLibraryPath + File.pathSeparatorChar + newPath);

- 93 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : System.getProperty()
lien : File.pathSeparatorChar

- 94 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Fichiers, flux et réseaux

- 95 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Fichiers, flux et réseaux > Flux et fichiers


Comment connaître les racines des arborescences de fichiers ?
Auteurs : Clément Cunin ,
La classe java.io.File fournit la méthode statique listRoots(). Sous Windows, le résultat est la liste des lecteurs logiques
( a:/, c:/, d:/ ), sous Unix, le résultat se limite à la seule racine système.

File[] listeRacine = File.listRoots();

Comment parcourir une arborescence de fichiers ?


Auteurs : Clément Cunin ,
Pour obtenir la liste des fichiers d'un répertoire :

/** Class : java.io.File */


public File [] listFiles ();

Pour connaître le type d'un fichier :

/** Class : java.io.File */


public boolean isDirectory ();
public boolean isFile ();

Exemple :
Cet exemple effectue un parcours récursif d'une arborescence de fichiers et affiche (sur la sortie standard) la liste de
tous les fichiers contenus dans le répertoire et ses sous-répertoires.

public static void listeRepertoire ( File repertoire ) {


System.out.println ( repertoire.getAbsolutePath());

if ( repertoire.isDirectory ( ) ) {
File[] list = repertoire.listFiles();
if (list != null){
for ( int i = 0; i < list.length; i++) {
// Appel récursif sur les sous-répertoires
listeRepertoire( list[i]);
}
} else {
System.err.println(repertoire + " : Erreur de lecture.");
}
}
}

Attention : cet algorithme ne fonctionne pas correctement avec une arborescence cyclique sous Unix !

lien : Comment connaître les racines des arborescences de fichiers ?

- 96 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Comment indiquer la position d'un fichier en conservant la portabilité ?

Comment copier ou déplacer un fichier ?


Auteurs : Clément Cunin ,
Copie de fichier :
L'Api ne fournissant pas de solution clé en main pour la copie de fichier, voila un bout de code qui devrait fonctionner.

/** copie le fichier source dans le fichier resultat


* retourne vrai si cela réussit
*/
public static boolean copyFile(File source, File dest){
try{
// Declaration et ouverture des flux
java.io.FileInputStream sourceFile = new java.io.FileInputStream(source);

try{
java.io.FileOutputStream destinationFile = null;

try{
destinationFile = new FileOutputStream(dest);

// Lecture par segment de 0.5Mo


byte buffer[] = new byte[512 * 1024];
int nbLecture;

while ((nbLecture = sourceFile.read(buffer)) != -1){


destinationFile.write(buffer, 0, nbLecture);
}
} finally {
destinationFile.close();
}
} finally {
sourceFile.close();
}
} catch (IOException e){
e.printStackTrace();
return false; // Erreur
}

return true; // Résultat OK


}

Depuis Java 1.4, l'Api de Java a été enrichie de nio. Voici le code à utiliser pour une copie plus rapide de fichier en
utilisant nio :

FileChannel in = null; // canal d'entrée


FileChannel out = null; // canal de sortie

try {
// Init
in = new FileInputStream("toto.txt").getChannel();
out = new FileOutputStream("tutu.txt").getChannel();

// Copie depuis le in vers le out


in.transferTo(0, in.size(), out);
} catch (Exception e) {
e.printStackTrace(); // n'importe quelle exception
} finally { // finalement on ferme
if(in != null) {
try {

- 97 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

in.close();
} catch (IOException e) {}
}
if(out != null) {
try {
out.close();
} catch (IOException e) {}
}
}

Déplacer un fichier
On n'a vu que le déplacement d'un fichier pouvait être fait grâce à la méthode renameTo(java.io.File) de la classe
java.io.File ( Comment renommer/déplacer un fichier ? ) Mais cette solution n'est valable que pour des déplacements
à l'intérieur d'un disque physique...
On va donc utilisé l'algorithme de copie lorsque le renommage ne suffit pas :

public static boolean deplacer(File source,File destination) {


if( !destination.exists() ) {
// On essaye avec renameTo
boolean result = source.renameTo(destination);
if( !result ) {
// On essaye de copier
result = true;
result &= copier(source,destination);
if(result) result &= source.delete();

} return(result);
} else {
// Si le fichier destination existe, on annule ...
return(false);
}
}

Comment supprimer un fichier ou un répertoire ?


Auteurs : Clément Cunin ,
Supprimer un fichier ou un répertoire vide :
La suppression des fichiers et des répertoires vides est effectuée grâce à la méthode delete() de la classe java.io.File. Un
booléen en résultat indique si la suppression a réussi (cause d'échec : Fichier inexistant; Fichier en lecture seule; Le
fichier est ouvert par une application ou par le système; Flux ouvert sur le fichier; etc...).

Supprimer un répertoire non-vide :


L'Api de base ne permet pas de supprimer un répertoire contenant des fichiers, il faut donc supprimer à la main tous
les fichiers du répertoire avant !

static public boolean deleteDirectory(File path) {


boolean resultat = true;

if( path.exists() ) {
File[] files = path.listFiles();
for(int i=0; i<files.length; i++) {
if(files[i].isDirectory()) {
resultat &= deleteDirectory(files[i]);
}
else {
resultat &= files[i].delete();
}

- 98 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

}
}
resultat &= path.delete();
return( resultat );
}

Comment renommer/déplacer un fichier ?


Auteurs : Clément Cunin ,
La méthode renameTo(java.io.File) de la classe java.io.File permet très facilement de renommer un fichier. De plus,
si le répertoire destination est différent du répertoire source, le fichier sera déplacé. (ATTENTION : le déplacement
n'est effectué que si la source et la destination sont sur le même disque physique, sinon Comment copier ou déplacer
un fichier ?)

File source = new File("mon fichier");


File destination = new File("mon fichier renommé");
source.renameTo(destination);

lien : Comment indiquer la position d'un fichier en conservant la portabilité ?


lien : Comment copier ou déplacer un fichier ?

Comment créer un fichier temporaire ?


Auteurs : Clément Cunin ,
Un fichier temporaire est un fichier qui sera créé dans le répertoire temporaire du système et qui sera automatiquement
supprimé à la fin de l'application (si la JVM quitte correctement).

File temp = File.createTempFile("nom",".tmp");


temp.deleteOnExit();

Comment écrire à la fin d'un fichier ?


Auteurs : bulbo ,
Pour écrire à la fin d'un fichier il faut utiliser la classe java.io.FileWriter.
Cette classe possède des constructeurs acceptant parmi leurs arguments un booléen nommé append.
Si cet argument est positionné à true, les données écrites dans ce fichier seront mises à la fin de celui-ci.

Voici un exemple d'utilisation:

FileWriter writer = null;


String texte = "texte à insérer à la fin du fichier";
try{
writer = new FileWriter("fichier.txt", true);
writer.write(texte,0,texte.length());
}catch(IOException ex){
ex.printStackTrace();
}finally{
if(writer != null){
writer.close();
}

- 99 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : http://anisfrikha.developpez.com/tutoriel/java-io/

Comment connaître le type MIME d'un fichier ?


Auteurs : Ioan Calapodescu ,
Cette information peut être accessible grâce à la classe URLConnection du package java.net Par exemple :

public static String getMIMEType(File file){


if(file.isDirectory()){return "repertoire";}
if(!file.exists()){return "fichier inexistant";}
try{
URL url = file.toURL();
URLConnection connection = url.openConnection();
return connection.getContentType();
}catch(MalformedURLException mue){
return mue.getMessage();
}catch(IOException ioe){
return ioe.getMessage();
}
}

Pour plus de "sécurité", vous pouvez utiliser la méthode statique guessContentTypeFromStream. A la différence
de getContentType (ou guessContentTypeFromName) cette méthode essaye de déterminer le type MIME en lisant
directement les premiers bytes de l'InputStream.

Comment connaître la date de création d'un fichier ?


Auteurs : L'équipe Java ,
Date de création :
Aucune solution n'est disponible pour connaître la date de création d'un fichier. Certains systèmes comme Linux ne
fournissant pas cette information, aucun solution portable n'est possible.

Date de la dernière modification :


Là, en revanche, aucun problème, la méthode lastModified() de la classe java.io.File est disponible.

long dateModification = monFichier.lastModified();

Toutefois, le long retourné par la méthode lastModified() peut dépendre du système d'exploitation et donc ne pas être
toujours extrêmement précise.

Comment connaître la taille d'un fichier ?


Auteurs : bulbo ,
En utilisant la classe java.io.File:

- 100 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

File.length();

Comment connaître l'espace libre d'un disque ?


Auteurs : Clément Cunin ,
Aucune solution n'est pleinement portable, donc aucune solution pure Java.

JConfig
est une bibliothèque supplémentaire qui est lié à du code natif disponible pour plusieurs plateformes. Elle permet
d'accéder à cette information, ainsi que beaucoup d'autre choses. http://www.tolstoy.com/samizdat/jconfig.html

Dans Java 6, il est désormais possible de connaître simplement l'espace libre, l'espace utilisable et l'espace totale grâce
à trois nouvelles méthodes de la classe File.

public long getTotalSpace();


public long getFreeSpace();
public long getUsableSpace();

Comment indiquer la position d'un fichier en conservant la portabilité ?


Auteurs : Clément Cunin ,
Les différents systèmes d'exploitation ne gèrent pas les arborescences de fichier de la même façon. Le monde Windows
associe les périphériques physiques à des lettres de lecteur, le monde Unix utilise un seul répertoire racine. De plus,
les séparateurs de fichier ne sont pas les mêmes (respectivement '\' et '/'). Tout ceci doit être analysé afin d'assurer la
portabilité de l'application. Heureusement Java fournit tous les outils pour localiser efficacement les fichiers en gardant
toute l'indépendance vis à vis du système d'exploitation.

Le plus important est de ne jamais utiliser directement de séparateur de fichier mais d'utiliser la constante définie en
fonction du système dans la classe java.io.File.

/** Class : java.io.File */


public static final char separatorChar;

Si vous désirez exprimer une liste de fichiers, il convient également d'utiliser la constante prévue à cet effet.

/** Class : java.io.File */


public static final char pathSeparatorChar;

lien : Comment parcourir une arborescence de fichiers ?

Comment lire des informations sur l'entrée standard ?


Auteurs : Clément Cunin ,
L'entrée standard est accessible au programmeur grâce au flux 'in' de la classe java.lang.System. Si vous exécutez votre
application dans une console, l'entrée standard contiendra tous les caractères entrés au clavier dans la console. La
manipulation directe du flux n'étant pas très aisée, une petite conversion en java.io.BufferedReader s'impose.

- 101 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

/** Convertion du flux en BufferedReader */


BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));

try {
/** Lecture d'une ligne : */entree.readLine();
} catch( IOException e ) {
e.printStackTrace();
}

Note : La lecture d'une ligne est une méthode dite 'blocante', tant que l'utilisateur n'a pas fait 'entrée', le processus
attends.

Depuis J2SE 5.0 (Tiger) vous pouvez aussi utiliser un Scanner pour parser la sortie standard. Par exemple :

Scanner scanner = new Scanner(System.in);


// traitement
scanner.close();

Le Scanner a l'avantage de possèder un ensemble de méthodes permettant de lire "directement" les types primitifs.
Vous pouvez aussi l'utiliser pour faire des recherches dans les flux scannés avec des expressions régulières.

Depuis JAVA SE 6, il est possible de lire sur l'entrée standard via la classe http://java.sun.com/javase/6/docs/api/java/
io/Console.html.

Par exemple :

Console console=System.console();
String ligneLue=console.readLine();

La classe Console propose également la méthode printf (si chère aux programmeurs C), ainsi qu'une méthode
readPassword() qui n'affiche pas les carctères sur la console.

Comment rediriger les flux standards dans des fichiers ?


Auteurs : Baptiste Wicht ,
Si pour une raison quelconque, vous avez besoin de récupérer tout ce qui arrive sur la sortir standard dans des fichiers,
il suffit d'employer les méthodes setOut et setErr de la classe System :

System.setOut(new PrintStream(new FileOutputStream("out.log")));


System.setErr(new PrintStream(new FileOutputStream("err.log")));

Comment charger une ressource présente dans le CLASSPATH (répertoire ou jar) ?


Auteurs : bulbo ,
Pour faire cela, il faut utiliser les méthodes getResource et getResourceAsStream de la classe Class. Le chemin à passer
en argument est celui commençant dans le répertoire du CLASSPATH ou a la racine d'un fichier jar. Attention si le
chemin ne commence pas par "/" alors le package courant est ajouté au début du chemin. Exemple:

package com.developpez;

- 102 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public class Test


{

public Test()
{
InputStream is1 = getClass().getResourceAsStream("fichier.txt");

InputStream is2 = getClass().getResourceAsStream("/fichier.txt");


}
}

Dans le code de l'exemple is1 sera un InputStream ouvert sur un fichier "com/developpez/fichier.txt" présent dans un
des répertoires du CLASSPATH ou dans la même arborescence à partir de la racine d'un fichier jar du CLASSPATH.
is2 sera un InputStream ouvert sur un fichier "fichier.txt" présent directement dans un répertoire du CLASSPATH
ou a la racine d'un fichier jar.

Comment changer l'encodage d'un fichier texte ?


Auteurs : Ioan Calapodescu ,
On peut spécifier l'encodage utilisé pour lire un flux. Voici un exemple qui lis un fichier en UTF-8 et écris celui-ci en
ISO-8859-1 :

public static void toISO(String source, String destination){


BufferedReader br = null;
PrintWriter pw = null;
try{
//flux de lecture en UTF-8
br = new BufferedReader(
new InputStreamReader(
new FileInputStream(source),"UTF-8"));
//flux d'écriture en ISO (valeur par défaut)
pw = new PrintWriter(new FileOutputStream(destination));
String ligne;
while((ligne = br.readLine())!=null){
pw.println(ligne);
}
}catch(Exception e){e.printStackTrace();}
finally{
try { pw.close(); } catch( Throwable e ) {}
try { br.close(); } catch( Throwable e ) {}
}
}

lien : Comment gérer l'encodage d'un tableau de bytes dans des String ?

Comment connaître les Charset disponibles et leurs alias ?


Auteurs : Ioan Calapodescu ,
La classe java.nio.Charset nous permet de facilement accèder à ces informations.

Voici un exemple listant l'ensemble des charsets disponibles :

SortedMap<String,Charset> charsets = Charset.availableCharsets();


for(String nom : charsets.keySet()){
System.out.println("Charset "+nom);
Charset charset = charsets.get(nom);

- 103 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

for(String alias : charset.aliases()){


System.out.print(" "+alias+",");
}
System.out.println();
}

lien : Comment changer l'encodage d'un fichier texte ?


lien : Comment gérer l'encodage d'un tableau de bytes dans des String ?

Peut-on modifier l'encodage de la sortie standard ?


Auteurs : Ioan Calapodescu ,
Oui, cela est possible. Ceci peut être utile par exemple pour afficher corectement les caractères accentués.

Voici un exemple permettant d'écrire correctement les caractères accentués sur la console windows (DOS) :

PrintStream ps = new PrintStream(System.out,true,"IBM850");


// on commence par changer l'encodage en IBM850 (connu aussi sous l'alias Cp850)
System.setOut(ps);
// ensuite l'utilisation de la sortie standard reste la même
System.out.println("àâäÂÄéèêëîïÎÏÊËôöÔÖûüùÛÜÿç");

lien : Comment gérer l'encodage d'un tableau de bytes dans des String ?
lien : Comment changer l'encodage d'un fichier texte ?
lien : Comment connaître les Charset disponibles et leurs alias ?

Comment libérer proprement les ressources (ou comment utiliser proprement les bloc try/finally) ?
Auteurs : adiGuba ,
La machine virtuelle Java (et plus précisément le Garbage Collector) s'occupe de libérer proprement la mémoire lorsque
les objets ne sont plus utilisés.
Toutefois, il existe un certain nombre de ressources qui doivent être libéré explicitement, comme par exemple les fichiers,
les sockets ou les connections JDBC, car ils utilisent des ressources systèmes qui ne peuvent pas être gérées par le
Garbage Collector...

Ces ressources doivent être "libérées" explicitement grâce à une méthode spécifique (généralement nommé close()).

Or on ne peut pas se contenter d'appeler cette méthode à la fin du traitement, car il y a un certain nombre de cas où
cette méthode ne serait pas appelée (par exemple en cas d'exception ou de retour de la méthode).

Il est également fortement déconseillé d'appeler cette méthode aux divers points de sortie du code (fin du traitement,
dans les catch, avant les return, etc.), car cela complexifie le code et son traitement, et augmente ainsi les chances de se
tromper (en oubliant un cas particulier par exemple).

La solution la plus propre à mettre en oeuvre est d'utiliser un bloc try/finally qui respecte la structure suivante :

// 1 - Création de la ressource
try {
// 2 - Utilisation de la ressource
} finally {
// 3 - Libération de la ressource
}

- 104 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Ainsi, lorsque la ressource est correctement créé, on l'utilise exclusivement à l'intérieur du try, et on la libère dans le
bloc finally quoi qu'il arrive. En effet, si on rentre dans le bloc try, le code du bloc finally sera exécuté dans tous les cas
lorsqu'on sort de celui-ci, même si une exception est levée ou que l'on quitte la méthode avec return...

Cette organisation en trois étapes permet donc de garantir la libération propre des ressources dans tous les cas.

Par exemple le code permettant de lire un fichier texte pourrait ressembler à ceci :

public static String readFile(File file) throws IOException, FileNotFoundException {


// 1 - Création de la ressource
FileReader reader = new FileReader(file);
try {
// 2 - Utilisation de la ressource
StringBuffer buffer = new StringBuffer();
char[] cbuf = new char[2048];
int len;
while ( (len = reader.read(cbuf)) > 0 ) {
buffer.append(cbuf, 0, len);
}
return buffer.toString();
} finally {
// 3 - Libération de la ressource
reader.close();
}
}

Cela permet de faire remonter simplement les exceptions à la méthode appelante tout en fermant correctement la
ressource (FileReader).

De la même manière, si l'on souhaite gérer les exceptions dans la méthode, il est préférable d'utiliser un bloc try/catch
en plus du bloc try/finally et non pas un bloc try/catch/finally qui nécessiterais un nouveau try/catch dans le bloc finally
(et donc un double traitement des exceptions). Par exemple :

public static String readFile(File file) {


try {
// 1 - Création de la ressource
FileReader reader = new FileReader(file);
try {
// 2 - Utilisation de la ressource
StringBuffer buffer = new StringBuffer();
char[] cbuf = new char[2048];
int len;
while ( (len = reader.read(cbuf)) > 0 ) {
buffer.append(cbuf, 0, len);
}
return buffer.toString();
} finally {
// 3 - Libération de la ressource
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
return null;
}

Enfin, si l'on utilise plusieurs ressources à la fois, il ne faut pas hésiter à encapsuler plusieurs try/finally (un par
ressource). Par exemple dans ce code qui permet de sauvegarder une URL dans un fichier :

- 105 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public static void writeToFile(URL url, File file) throws IOException, FileNotFoundException {
// 1 - Création de la ressource (Fichier)
FileOutputStream fos = new FileOutputStream(file);
try {
// 2 - Utilisation de la ressource (Fichier)

// 1 - Création de la ressource (URL)


InputStream is = url.openStream();
try {
// 2 - Utilisation de la ressource (URL)
byte[] buf = new byte[2048];
int len;
while ( (len = is.read(buf)) > 0) {
fos.write(buf, 0 , len);
}
} finally {
// 3 - Libération de la ressource (URL)
is.close();
}
} finally {
// 3 - Libération de la ressource (Fichier)
fos.close();
}
}

Si cela peut avoir peu d'importance dans une application de bureau, c'est nettement plus critique dans une application
serveur car on peut vite atteindre les limites autorisées par le système, et se retrouver avec une application complètement
bloquée !

A noter enfin que le Garbage Collector "limite" quand même ce phénomène, car la méthode close() est généralement
appelé implicitement lors de la destruction de l'objet (plus précisément via la méthode finalize()) si la ressource n'a pas
été fermé explicitement.

Toutefois, étant donnée que l'on ne peut pas maîtriser le passage du Garbage Collector avec exactitude , il est préférable
de fermer les ressources explicitement avec un bloc try/finally.

Comment lire les éléments d'un fichier en utilisant un délimiteur aproprié ?


Auteurs : bobuse ,
Pour lire les éléments d'un fichier en utilisant un délimiteur, il suffit d'avoir recours à la classe java.util.Scanner (arrivée
dans le JDK 5.0).

Par exemple pour lire un fichier dont les champs sont séparé par des tabulations, on pourra écrire :

Reader reader = null;


// initialisation du reader ...

Scanner scanner=new Scanner(reader);

// L'expression régulière qui délimite les champs


scanner.useDelimiter(Pattern.compile("[\t\n]"));

// On boucle sur chaque champ detecté


int champ;
while (scanner.hasNext()) {
// Si le champ n'est pas un entier, une exception de type InputMismatchException sera levée
champ = scanner.nextInt();

- 106 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

//Utilisation du champ...
}

Comment lire un fichier ligne par ligne ?


Auteurs : sironimo , Baptiste Wicht ,
Le traitement d'un fichier ligne par ligne est assez simple, mais il faut quand même connaître la manière de s'y prendre.
Pour se faire, on va utiliser un simple BufferedReader pour lire le fichier et ensuite utiliser la méthode readLine() pour
lire une ligne de notre fichier.

Voilà donc ce que pourrait donner notre code :

String filePath = "g:\\fichier.txt";

try{
// Création du flux bufférisé sur un FileReader, immédiatement suivi par un
// try/finally, ce qui permet de ne fermer le flux QUE s'il le reader
// est correctement instancié (évite les NullPointerException)
BufferedReader buff = new BufferedReader(new FileReader(filePath));

try {
String line;
// Lecture du fichier ligne par ligne. Cette boucle se termine
// quand la méthode retourne la valeur null.
while ((line = buff.readLine()) != null) {
System.out.println(line);
//faites ici votre traitement
}
} finally {
// dans tous les cas, on ferme nos flux
buff.close();
}
} catch (IOException ioe) {
// erreur de fermeture des flux
System.out.println("Erreur --" + ioe.toString());
}

Depuis Java 5.0, On peut également utiliser la classe Scanner pour lire un fichier ligne par ligne :

String filePath = "g:\\fichier.txt";

Scanner scanner=new Scanner(new File(filePath));

// On boucle sur chaque champ detecté


while (scanner.hasNextLine()) {
String line = scanner.nextLine();

System.out.println(line);
//faites ici votre traitement
}

scanner.close();

lien : La classe java.util.Scanner

- 107 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Fichiers, flux et réseaux > Sérialisation


Comment serializer un objet ?
Auteurs : aDamas ,
Le but est de sauvegarder une instance d'un objet particulier. Dans cette exemple, je sauvegarde des options
paramétrables par l'utilisateur.

La class de l'objet à "serializer" doit implémenter l'interface Serializable!

Options options=new Options(); //implémente Serializable


FileOutputStream fos = new FileOutputStream("options.tmp"); //fichier de sortie
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(options);
oos.close();

lien : Pour en savoir plus : Le tutorial de Sun

Comment récupérer (déserializer) un objet sérializé ?


Auteurs : aDamas ,
L'instance d'un objet serializé(sauvegardé à l'aide de l'interface Serializable) se récupère comme suit :

FileInputStream fis = new FileInputStream("options.tmp");


ObjectInputStream ois = new ObjectInputStream(fis);
Options options=(Options)ois.readObject();
ois.close();

lien : Pour en savoir plus : le tutorial de Sun

Si je fais évoluer ma classe, pourrai-je relire les objets déjà sérialisés ?


Auteurs : gifffftane ,
Oui, si vous prenez la précaution d'indiquer la valeur du serialVersionUID dans votre classe, et que cette valeur reste
constante.

Exemple :

public final class Alfred implements java.io.Serializable


{
static final long serialVersionUID = 1515L; // Bataille de Marignan, 16.000 morts.
...
}

Ceci protège des évolutions mineures (ajout ou retrait d'attributs ou méthodes).

La commande serialver offre le calcul d'un serialVersionUID à partir de l'état présent d'une classe :

$ serialver -classpath build/classes praline.Alfred


praline.Alfred: static final long serialVersionUID = -4630845128859230043L;

- 108 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Ma classe a changée, mais je n'avais pas mis de serialVersionUID, que puis-je faire alors ?
Auteurs : gifffftane ,
Lire le message d'erreur, et affecter à la nouvelle version de la classe le serialVersionUID de l'ancienne version.

Par exemple, si la désérialization renvoie ce message d'erreur :

Exception in thread "main" java.io.InvalidClassException: praline.Alfred; local class incompatible:


stream classdesc serialVersionUID = -2335767472728093557, local class serialVersionUID =
-4630845128859230043
... donnez à votre classe le serialVersionUID -2335767472728093557.

- 109 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Fichiers, flux et réseaux > Réseaux


Comment établir une connexion FTP ?
Auteurs : Clément Cunin , Pierre-Yves Varoux ,
Rien n'est spécifiquement prévu dans l'Api pour gérer les connexions FTP. Mais à partir des RFC959 et 1123 et avec
un peu de courage, vous pouvez faire votre propre client FTP.

Heureusement, d'autres programmeurs sont passés avant vous, et des bibliothèques sont à votre disposition :

• Java FTP Client Library disponible sous licence LGPL, avec toutes les fonctions nécessaires.
• FTPConnection également libre et complète (voir ci dessous).
• Jakarta Commons Net, disponible sous licence Apache, propose les implémentations clients de plusieurs
protocoles de base d'Internet (dont le FTP).

FTPConnection

Comment puis-je faire un 'ping' en Java ?


Auteurs : Christophe Ludet , Clément Cunin ,
Depuis J2SE 5.0 (Tiger)
Vous pouvez utiliser la méthode isReachable(int timeout) de la classe InnetAdress qui indique si l'adresse est accessible.
Les implémentation de cette méthode utilisent en général ICMP. En cas de problèmes d'accès ICMP, la méthode tente
une connexion TCP sur le port 7 (echo).

Avant : aucune solution portable !

La commande ping nécessite des paquets ICMP (Internet Control Message Protocol : voir http://www.faqs.org/rfcs/
rfc792.html).Les bibliothèques standards de Java ne supportent pas ICMP. Il n'est donc pas possible d'effectuer de ping
en Java sans avoir recours à du code natif ou un programme externe.

Proposition d'une solution portable

http://www.geocities.com/SiliconValley/Bit/5716/ping/index_eng.html

Comment connaître l'adresse IP de sa machine ?


Auteurs : Clément Cunin ,
Si vous avez Windows et une seule carte réseau, l'information n'est pas trop difficile à obtenir, ce petit code suffit :

String ip = InetAddress.getLocalHost ().getHostAddress ();

Sinon, cela va se compliquer. Il faut parcourir les interfaces réseaux et filter les bonnes addresses :

/**
* Retourne toutes les adresses ips des carte réseau de la machine. Retourne seulement les addresses IPV4
*
* @return Une liste des addresses ip
*/
public List<String> getIps(){
List<String> ips = new ArrayList<String>();

- 110 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

try{
Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

while (interfaces.hasMoreElements()) { // carte reseau trouvee


NetworkInterface interfaceN = (NetworkInterface)interfaces.nextElement();
Enumeration<InetAddress> ienum = interfaceN.getInetAddresses();
while (ienum.hasMoreElements()) { // retourne l adresse IPv4 et IPv6
InetAddress ia = ienum.nextElement();
String adress = ia.getHostAddress().toString();

if( adress.length() < 16){


//On s'assure ainsi que l'adresse IP est bien IPv4
if(adress.startsWith("127")){ //Ce n'est pas l'adresse IP Local'
System.out.println(ia.getHostAddress());
}
else if(adress.indexOf(":") > 0){

System.out.println(ia.getHostAddress()); // les ":" indique que c'est une IPv6"


}
}

ips.add(adress);
}
}
}
catch(Exception e){
System.out.println("pas de carte reseau");
e.printStackTrace();
}

return ips;
}

lien : http://java.sun.com/j2se/1.4/docs/api/java/net/InetAddress.html

Comment spécifier un proxy pour se connecter à un serveur ?


Auteurs : Clément Cunin , Baptiste Wicht , adiGuba ,
Au lancement de la JVM :
La première solution consiste à préciser le proxy au démarrage de la JVM, idéale si une application ne gère pas cette
option...

java -DproxySet=true -DproxyHost=nomproxy -DproxyPort=numport test

Depuis le programme :
ces options peuvent également être initialisées par le programme en modifiant les propriétés systèmes.

Properties prop = System.getProperties();


prop.put("http.proxyHost","172.28.48.1");
prop.put("http.proxyPort","8080");

Si vous avez besoin de vous authentifier sur le proxy avec un user/mot de passe, il faut utiliser la classe Authenticator
pour indiquer ces informations. Il suffit pour d'utiliser la méthode setDefault(Authenticator a) avec un Authenticator
personnel :

Authenticator.setDefault(new Authenticator(){
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("user", "password".toCharArray());

- 111 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

}
});

Comment envoyer une requête de type POST en utilisant une URL ?


Auteurs : Ioan Calapodescu ,
Pour faire cela, on doit récuperer l'URLConnection correspondant à l'URL. Par exemple :

public void doPost(String adresse){


OutputStreamWriter writer = null;
BufferedReader reader = null;
try {
//encodage des paramètres de la requête
String donnees = URLEncoder.encode("clef", "UTF-8")+
"="+URLEncoder.encode("valeur", "UTF-8");
donnees += "&"+URLEncoder.encode("autreClef", "UTF-8")+
"=" + URLEncoder.encode("autreValeur", "UTF-8");

//création de la connection
URL url = new URL(adresse);
URLConnection conn = url.openConnection();
conn.setDoOutput(true);

//envoi de la requête
writer = new OutputStreamWriter(conn.getOutputStream());
writer.write(donnees);
writer.flush();

//lecture de la réponse
reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String ligne;
while ((ligne = reader.readLine()) != null) {
System.out.println(ligne);
}
}catch (Exception e) {
e.printStackTrace();
}finally{
try{writer.close();}catch(Exception e){}
try{reader.close();}catch(Exception e){}
}
}

Comment établir une communication entre une applet et une servlet ?


Auteurs : Pierre-Yves Varoux ,
Il existe différentes façons pour établir une communication entre une applet et une servlet. Les deux méthodes suivantes
ne sont pas propres aux servlets, et peuvent être aussi utilisées entre 2 applications quelconques.
• RMI : permet de manipuler des objets distants (plus d'infos ici)
• Socket : création d'un flux point à point (plus d'infos ici)

La méthode la plus proche du mode de fonctionnement d'une httpServlet est une communication HTTP; elle a l'avantage
d'utiliser (en général) le port 80, et donc de franchir plus facilement les firewalls. La requête HTTP de l'applet peut se
faire soit par GET, soit par POST (multipart).

/** Envoi de données par GET */

- 112 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

URL url = new URL("http://localhost/servlet?cle1=valeur1&cle2=valeur2");


URLConnection conn = url.openConnection();

/** Envoi de données par POST */


URL url = new URL("http://localhost/servlet");
String data = "cle1=valeur1&cle2=valeur2");
URLConnection conn = url.openConnection();
conn.setDoOutput(true);
OutputStreamWriter osw = new OutputStreamWriter(conn.getOutputStream());
osw.write(data);
osw.flush();
osw.close();

/** Récupération de la réponse de la servlet */


BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
/** traitement des lignes */
} br.close();

Pour envoyer la réponse à partir de la servlet, il suffit d'utiliser l'OutputStream de l'HttpServletResponse.

/** Réponse de la servlet */


String texte = "...";
PrintStream out = new PrintStream(response.getOutputStream());
out.println(texte);
out.close();

Remarque: pour le passage des données (clés ou valeurs), si des caractères spéciaux sont employés, utiliser
URLEncoder :

cle1 = URLEncoder.encode(cle1, "UTF-8")

Pourquoi mes sockets sont plus longues à se connecter depuis java 5.0 ?
Auteurs : bulbo , adiGuba ,
Depuis la version 5.0 du jdk, la machine virtuelle a introduit un mécanisme de sélection automatique de serveur proxy
lors de la connection au réseau.
Ce mécanisme qui devrait être totalement transparent est malheureusement entaché de quelques bugs problématiques.

Le premier d'entre eux touche particulièrement les machines Windows qui utilise le protocole NetBIOS, et provoque
des connections réseaux anormalement longues (environ 5 secondes par connection).

Pour pallier à ce bug, il est possible de désactiver ce comportement en utilisant la classe ProxySelector :

ProxySelector.setDefault(null);

Mais un second bug peut alors posé problème. Alors que le code ci-dessus est parfaitement valable, ce dernier peut
provoquer un NullPointerException lors de la connection.

- 113 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le premier de ces bugs a été corrigé dans l'update 6 de Java 5.0, alors que le second semble avoir été introduit dans une
version ultérieure pour n'être corrigé que dans les premières versions de Mustang (Java SE 6).

Ainsi, pour éviter tout problème quel que soit la JVM cliente utilisée, il est neccessaire de vérifier la version exacte de
la JVM avant d'utiliser le code ci-dessus, ce qui pourrait donner :

// Si on utilise une JVM 1.5


if ( "1.5".equals(System.getProperty("java.specification.version")) ) {
// On récupère le numéro exacte de l'update (en supprimant le numéro de version majeure) :
String update = System.getProperty("java.version").replaceAll("^1.5.0_", "");
try {
// Si on utilise une JVM antérieure à l'update 6
if (Integer.parseInt(update)<6) {
ProxySelector.setDefault(null);
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
}

Bien entendu, si votre application utilise Java 6 (ou supérieur) tout ceci est complètement inutile.

lien : [Bug ID: 5092063] Extremely slow socket creation using new Socket("ip-address", port)
lien : [Bug ID: 6215885] URLConnection.openConnection NPE if ProxySelector.setDefault is set to null

- 114 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Le développement

- 115 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Le développement > Installation et compilation


Comment compiler et exécuter mon application Java ?
Auteurs : Johann Heymes ,
Je ne parlerai en aucun cas des techniques à employer sous les divers environnements de programmation car tous
fournissent une documentation compétente et si ce n'est pas le cas ne méritent tout simplement pas qu'on y prête
attention.

Pré-requis/Rappel : Pour que la suite des opérations se passe bien, il est absolument nécessaire que les règles suivantes
soient respectées :
• un fichier contient une seule classe dont le modificateur de portée est public
• le nom du fichier est strictement le même que le nom de la classe public (majuscule/minuscule importante)
• il faut que les commandes java, javac, jar,... soient accessibles

Pour le vérifier le dernier point tapez dans une console ou un terminal ceci :

java -version

Si vous obtenez un message autre que la version de Java installée référez-vous à la documentation de votre système
d'exploitation, généralement le problème est dû à la variable d'environnement PATH qui ne pointe pas sur le répertoire
contenant les exécutables.

La Compilation :

La compilation se fait avec l'application nommée javac. Placez-vous dans votre répertoire de travail et exécutez la
commande suivante :

javac -d classes/ sources/MonFichierACompiler.java

Ici nous avons donc un fichier Java nommé "MonFichierACompiler.java" dans le répertoire nommé "sources" et
le résultat de la compilation sera placé dans le répertoire nommé "classes". Pour plus d'information sur les options
utilisées, tapez la commande "javac" et la liste apparaîtra à l'écran.

L'Exécution :

L'exécution se fait via la commande java. Placez-vous dans votre répertoire de travail et exécutez la commande suivante :

java -classpath classes/ MonFichierACompiler

Ici nous précisons à l'application java qu'elle doit trouver les fichiers *.class dans le répertoire classes (note : si vos
*.class se trouvent dans le répertoire courant, vous pouvez utiliser : "-classpath .") et qu'elle trouvera son point de
départ dans la classe public nommée "MonFichierACompiler". Pour rappel ce point de départ correspond à la méthode
dont la signature est :

public static void main (String argv [])

si vous avez ommis cette méthode vous obtiendrez un message d'erreur du style :

Exception in thread "main" java.lang.NoSuchMethodError: main

et si votre classpath est erroné vous obtiendrez :

- 116 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Exception in thread "main" java.lang.NoClassDefFoundError: MonFichierACompiler

Quel rôle joue les imports lors de la compilation ?


Auteurs : Clément Cunin ,
Le rôle des imports en Java est très différent de celui des includes en C / C++.

Les includes en C :
Lorsque le compilateur C (Le préprocesseur pour être précis) rencontre un include, il ouvre et analyse le fichier spécifié.
Le contenu du fichier influe directement sur la compilation.

Les imports en Java :


Les imports en Java n'ont aucun impact sur le fichier compilé, ils servent uniquement à préciser les classes que vous
souhaitez utiliser sans indiquer chaque fois le nom du paquet. Une classe peut être utilisée sans avoir été importée, il
suffit pour cela de préfixer le nom de la classe avec son nom de paquet.

- 117 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Le développement > Exécution


Comment récupérer des paramètres d'une ligne de commande ?
Auteurs : bahamouth ,
Cela se fait de la même manière que dans la plupart des langages comme C/C++, C-Shell, Bash, ...

Lors de l'appel du programme :

java MaClasse param1 param2 ... paramN

Les paramètres sont stockés dans un tableau de chaines de caractères qui se trouve dans la méthode main de la classe
principale :

public static void main (String[] args) { ... }

On peut ainsi accéder aux éléments rentrés en paramètres via le tableau "args", par exemple :

// nombre de paramètres
int nbParam = args.length;
for (int i = 0; i < nbParam; i++) {
System.out.println(args[i]);
}

Attention : une exception est levée si l'on tente d'accéder à un élément du tableau qui n'existe pas.

Comment créer un programme Java exécutable ?


Auteurs : Pierre-Yves Varoux ,
Il y a différentes façons de comprendre "exécutable" :

Une machine virtuelle est installée


Ecrire un script dans un fichier de commande (.bat, ...) pour lancer l'application
Créer une application .jar exécutable (plus d'infos)

• points positif : on simplifie le lancement de l'application.


• points négatif : la machine virtuelle installée n'est peut-être pas assez récente.

Installation automatique d'une machine virtuelle

Packager son application avec une machine virtuelle associée (exemple : InstallAnyWhere de ZeroG).
• points positif : L'utilisateur n'a pas à installer une machine virtuelle lui-même et on est sûr de la compatibilité
JVM / application.
• points négatif : L'application est plus lourde de quelques Mo supplémentaires et il faut réaliser un exécutable
par plateforme.

Plus de machine virtuelle

Utilisation d'un compilateur natif.


• points positif : L'application est plus légère qu'avec une JVM associée et on gagne en performance (Le gain est
nettement moins significatif maintenant que la JVM utilise un compilateur à la volée (Just In Time)).

- 118 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• points négatif : L'application n'est plus portable et le logiciel, pour rendre le code natif, se limite souvent aux
classes les plus courantes de l'API.

Pour les logiciels dont vous pourriez avoir besoin, cf. http://java.developpez.com/freewares/.

Comment créer un jar exécutable ?


Auteurs : bahamouth , Clément Cunin , le y@m's , sinok ,
Tout d'abord, il convient de créer un fichier Manifest.
Ce fichier contiendra le nom de la classe à exécuter ainsi que les archives à mettre dans le CLASSPATH.

Manifest-Version: 1.0
Created-By: 1.4.1_01 (Sun Microsystems Inc.)
Main-Class: Start
Class-Path: ./archive1.jar ./archive2.jar

Attention : il est nécessaire de terminer le fichier manifest par un saut de ligne.

Nous appellerons le fichier MANIFEST.MF et il sera placé dans un répertoire META-INF en racine de l'application
(par exemple).
Les archives jar du classpath ne seront pas inclues dans ce jar mais seront situées par la suite dans le même répertoire
que nous allons créer (ou dans un path bien défini).
Si l'on veut qu'elles soient rangées dans un répertoire il suffira de donner le path:

Class-Path: path1/archive1.jar path2/archive2.jar

A noter que de puis Java SE 6, on peut utiliser le caractère étoile (*) pour prendre tous les librairies d'un dossier :

Class-Path: path/*

Pour créer le jar il faut déjà supprimer tous les .java


L'idéal étant de copier tous les .class (avec leur arborescence s'ils sont packagés) dans un répertoire temporaire pour
créer le jar dans ce répertoire. On peut aussi copier les fichiers qui seront accessibles dans le jar (images) s'il y en a.

La commande permettant de créer un fichier .jar est la suivante :

jar cvfm fichier-jar fichier-manifeste fichiers...

Voilà la signification des différents paramètres :

• fichier-jar : est le nom du jar à créer


• fichier-manifeste : fichier MANIFEST.MF
• fichiers : fichiers à ajouter à l'archive. Si un des fichiers est un répertoire, celui-ci est traité récursivement.

Dans le répertoire des .class, on exécutera donc la commande suivante :

jar cvfm monappli.jar META-INF/MANIFEST.MF .

Cela va nous créer un .jar éxécutable nommé monappli.jar avec le fichier MANIFEST.MF présent dans le répertoire
META/INF. Ce jar se voit ajouter les fichiers du répertoire courant (spécifié par le caractère '.').

- 119 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le programme jar reconstruira le fichier Manifest et affichera sur la sortie standard les résultats (ça permet de vérifier
qu'il est codé correctement).
On exécute ensuite le jar de la façon suivante :

java -jar monappli.jar

Les archives indiquées dans le Class-Path du Manifest seront recherchées selon leurs chemin relatif par rapport au
fichier Jar principal.

lien : http://java.sun.com/docs/books/tutorial/jar/manifest/index.html

Comment signer un JAR ?


Auteurs : christopheJ ,
Il faut d'abord générer un certificat :

keytool -genkey -alias signature -keystore monStore

Il faut alors répondre aux différentes questions (nom, prénom, société, adresse,....) Cela génère un certificat "signature'
qui est stocké dans un dépot "monStore"

Ensuite pour signer le jar :

jarsigner -keystore monStore -signedjar sMonJar.jar monJar.jar signature

Cela génère le jar "sMonJar.jar" qui est la version signée avec le certificat "signature" du jar "monJar.jar".

lien : Creating a Trusted Applet with Local File System Access Rights

Comment obtenir la pile d'exécution d'une méthode ?


Auteurs : bulbo ,
Avant le SDK 1.4

Throwable t = new Throwable();


StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw, true));
String stackTrace = sw.toString();

La chaîne ainsi obtenue correspond a l'affichage d'un printStackTrace() d'une exception.

A partir du SDK 1.4

Throwable t = new Throwable();


StackTraceElement traces[] = t.getStackTrace();

- 120 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le tableau traces contient la pile d'exécution au moment de la création du Throwable. Le premier élément du tableau
correspond a la création du Throwable, le dernier élément du tableau représente le bas de la pile.

Comment avoir une seule instance de mon application qui tourne ?


Auteurs : Debernad , jcarre , adiGuba ,
Une astuce possible est d'utiliser une ServerSocket, du package java.net. On peut lancer un tel type de socket (sur un
port précis) lors de l'exécution du main. Si une Exception est levée, cela indique qu'une instance de l'application est
déjà en train de tourner. Voici un exemple :

private static int PORT = 12345;


public static void main(String[] args) {
try {
new ServerSocket(PORT);
System.out.println("Instance du programme unique");
}catch(Exception e){
System.out.println("Il y a deja une instance du programme active");
System.exit(0);
}
}

La seule difficulté sera de déterminer un port libre (non utilisé par une quelconque application de la machine).

Lorsque l'application est déployé via Java Web Start, il est possible d'utiliser un service conçu spécialement pour cela :

// Utilisation du service :
SingleInstanceService singleInstanceService =
(SingleInstanceService)ServiceManager.lookup("javax.jnlp.SingleInstanceService");

// Ajout d'un listener qui sera appelé pour chaque nouvelle instance :
singleInstanceService.addSingleInstanceListener( new SingleInstanceListener() {
public void newActivation(String[] params) {
// 'params' contient les paramètres passé à la nouvelle instance
}
});

lien : Classe javax.jnlp.SingleInstanceService


lien : Qu'est-ce que Java Web Start ?

- 121 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Le développement > Les erreurs et exceptions


Exception ... must be caught ... ?
Auteurs : Clément Cunin , Sébastien Meric ,
Qu'est qu'une exception ?
En Java, les erreurs sont gérées à travers des exceptions qui sont levées par exemple lorsqu'une méthode ne peut pas
accomplir correctement son travail. Le compilateur ne laisse pas le développeur ignorer ces exceptions potentielles,
chaque source d'erreur doit être traitée.

Traiter une exception :


Pour pouvoir traiter ces exceptions il faut utiliser une succession try/catch (essaye/attrape).

try {
/** ... mes instructions */
} catch (mon_type_d_Exception e) {
/** ... mon traitement si cette erreur intervient */
} catch (un_autre_Exception e) {
/** ... */
}

La "lancer" vers les méthodes appelantes :


Il est toujours préférable de traiter les exceptions au plus tôt pour préserver la lisibilité du code. Néanmoins, l'exception
levée présente parfois un intérêt non négligeable pour la méthode appelante. En effet, si votre méthode courante permet
de parser un fichier texte, il peut être utile pour la méthode appelante de savoir que le traitement n'a pas eu lieu, et
pourquoi celui-ci n'a pas eu lieu. Un fichier manquant ne se traite pas de la même manière qu'un fichier corrompu !
Afin de lancer une exception vers la méthode appelante, il suffit de prévenir dès la déclaration :

public int maMethode() throws UneException, UneAutre, ...

Utiliser une exception qu'il n'est pas nécessaire d'attraper :


Si vous définissez vos propres exceptions, il peut arriver que vous soyez géné par l'obligation systématique de les
"attraper". Certaines exceptions n'ont pas besoin d'être attrapées à la compilation, mais interrompent le déroulement
de votre méthode, et de sa pile d'appel, tout en laissant une trace de son passage dans les fichiers de log. Ce type
d'exception descend exclusivement de RuntimeException.

NullPointerException ?
Auteurs : Clément Cunin ,
L'exception 'NullPointer' est levée lorsque l'application essaye d'utiliser null alors qu'une instance d'un objet est requis.
Cela inclut :
- l'appel d'une méthode sur un objet null
- La lecture ou la modification d'un champ d'un objet null
- Demander la longueur de null comme s'il sagissait d'un objet
- La lecture ou la modification d'une case d'un tableau null
- Lever une exception null

- 122 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Cette exception est levée à chaque utilisation incorrecte d'un objet null.

ClassNotFoundException ... ?
Auteurs : Ioan Calapodescu , cyberzoide ,
Cette exception peut être levée principalement par trois méthodes :

• La méthode forName de la classe Class.


• La méthode findSystemClass de la classe ClassLoader .
• La méthode loadClass de la classe ClassLoader.

Cette exception peut indiquer deux choses:


• Soit que votre CLASSPATH est mal configuré.
• Soit que les droits du fichier jar ou du fichier class ne permettent pas la lecture de celui-ci pour l'utilisateur courant.

Vérifiez que vos librairies externes sont bien référencées dans le CLASSPATH. Pour mettre une librairie (jar) dans le
CLASSPATH vous pouvez la placer dans le répertoire JAVA_HOME/jre/lib/ext. Une seconde possibilité est de définir
le CLASSPATH lors du lancement de la commande java (-cp).

Si vous utilisez un jar, vous devez référencer les librairies extérieures dans le manifeste (cf Comment créer un jar
exécutable ? ).

Si votre CLASSPATH est correct, vérifiez alors les droits de vos fichiers, vous devez disposer au moins des droits en
lecture.

IndexOutOfBoundsException... ?
Auteurs : mavina ,
Cette exception est levée lorsque l'on essaie d'accéder à une case d'un tableau qui n'existe pas.

Il faut avant tout vérifier à la ligne indiquée(dans le stackTrace) qu'on ne tente pas d'accès à une case inexistante (X).

Exemple :

int [] monTab=new int[20]; // creation d'un tableau de taille 20


for(int i=0;i<20;i++) {
tab[i]=i; // on le remplit
}
System.out.println(tab[20]); // on accede a la case 21 en voulant acceder à la case 20...

Le plus fréquemment, cette erreur vient du fait qu'on essaie d'acéder à la dernière case du tableau sans prendre en
compte le fait que le tableau commence à l'index 0 et non pas un comme on pourrait le croire.

SecurityException ... ?
Auteurs : Ioan Calapodescu ,
Le SecurityManager lève ce genre d'exception quand vous tentez d'accèder à des ressources protégées.

- 123 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Cela peut être le cas pour les Applets, par exemple. Celles-ci doivent être signées pour pouvoir accèder aux ressources
de la machine cliente (Système de fichiers, classe Robot, etc.). Vous pouvez aussi éditer votre fichier java.policy pour
régler ces droits d'accès.

Regardez :

OutOfMemoryError ... ?
Auteurs : Ioan Calapodescu ,
L'erreur java.lang.OutOfMemoryError est levée lorsque la JVM (la machine virtuelle Java) ne peut plus allouer de
mémoire pour un Objet. Le GarbageCollector ne peut plus en liberer.

Une possibilité est d'allouer plus de mémoire au lancement de la JVM avec l'option -Xmsn. Vous pouvez aussi fixer la
taille maximale de la mémoire avec l'option -Xmxn. Ou n indique la mémoire initiale disponible. Les valeurs par défaut
sont respectivement de 2MB et 64 MB.

Voici un exemple de notation :

java -Xms6291456
// 6291456 bytes
java -Xms6144k
//6144 kilo
java -Xms6m
//6 méga

Comment intercepter tous les throwables d'une application ?


Auteurs : adiGuba ,
Dans une application graphique certaines exceptions se déclenchent depuis le thread dédié à l'affichage.
Il n'est pas possible d'intercepter ces exceptions avec un bloc try/catch classique.
Il est possible d'enregistrer une classe qui sera chargée de gérer ses erreurs.
Pour ce faire la propriété système sun.awt.exception.handler doit contenir le nom complet d'une classe ayant une
méthode handle().
Cela peut être fait en passant l'option "-Dsun.awt.exception.handler=..." à la machine virtuelle ou par le biais de la
méthode System.setProperty()
A chaque exception non interceptée, une nouvelle instance de cette classe est créée (il faut un constructeur vide) et la
méthode handle() est appelée.
Cela ne fonctionne pas avec Java 5.0.
Dans le cadre de Java 5.0 on peut utiliser les UncaughtExceptionHandler avec la méthode
Thread.setDefaultUncaughtExceptionHandler() (voir avec setUncaughtExceptionHandler() afin de l'effectuer thread
par thread...)
Cette solution est nettement plus propre mais malheureusement elle neccessite une JVM 5.0.

- 124 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Le développement > Les warnings


[Java 5.0] Comment activer/désactiver les warnings avec javac ?
Auteurs : adiGuba ,
Le compilateur Java du JDK 5.0 apporte son lot de nouveaux warnings. Pour rappel, un warning est un message
survenant à la compilation pour indiquer un problème potentiel, mais qui ne bloque pas le déroulement de la
compilation. Il est toutefois conseillé de les corriger car cela peut poser des problèmes à l'exécution.

Toutefois, ces warnings ne sont pas tous affichés par défaut. Seul certains d'entre eux affichent une note pour signaler
leurs présences, par exemple :

Résultat de la compilation :
Note: Main.java uses or overrides a deprecated API.
Note: Recompile with -Xlint:deprecation for details.

Ce message nous indique le problème potentiel (l'utilisation d'une méthode dépréciée dans ce cas) ainsi que la voie à
suivre pour obtenir plus de détails sur ce problème (recompiler avec l'option -Xlint:deprecation).

Le JDK 5.0 a introduit une nouvelle option dans le compilateur javac afin de gérer l'affichage ou non des warnings :
l'option -Xlint. Utilisée seule, elle permet d'activer tous les warnings du compilateur :

Compilation avec tous les warnings


javac -Xlint MaClasse.java

L'option -Xlint accepte également les paramètres suivant :

Valeur Description
all Active tous les warnings.
deprecation Active les warnings concernant les éléments dépréciés. il s'agit du même
comportement que l'option -deprecation qui existait déjà dans les versions
précédentes.
(Voir deprecation : "uses or overrides a deprecated API")
unchecked Active tous les warnings relatifs à l'utilisation des types paramétrés.
(Voir [Java 5.0] unchecked : "uses unchecked or unsafe operations").
fallthrough Active la vérification des switch par le compilateur.
(Voir fallthrough : "possible fall-through into case").
path Active les vérifications des chemins.
(Voir [Java 5.0] path : "bad path element").
serial Active tous les warnings concernant le Serialization (serialVersionUID).
(Voir [Java 5.0] serial : "serializable class Main has no definition of
serialVersionUID").
finally Active tous les warnings concernant les blocs finally incorrect.
(Voir [Java 5.0] finally : "finally clause cannot complete normally").

Plusieurs valeurs peuvent être utilisées en même temps en les séparant par des virgules. En précédant ces valeur par
un tiret (-), on désactive le warning associé. Par Exemple :

Afficher tous les warnings

- 125 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Afficher tous les warnings


javac -Xlint *.java

javac -Xlint:all *.java

Afficher seulement les warnings deprecation et unchecked


javac -Xlint:deprecation,unchecked

Afficher tous les warnings sauf unchecked


javac -Xlint:all,-unchecked

[Java 5.0] finally : "finally clause cannot complete normally"


Auteurs : adiGuba ,
Ce warning signale qu'un bloc finally ne se termine pas correctement. En effet, un bloc finally ne devrait pas contenir
d'instruction return puisqu'il est appelé en cas d'Exception ou de return dans le bloc try correspondant, ce qui fait que
l'instruction return éventuelle du bloc try sera ignorée.

Ainsi, si un bloc finally comporte le mot-clef return, il sera signalé par ce warning, par exemple :

Main.java:26: warning: [finally] finally clause cannot complete normally

Ce warning n'est actif qu'avec les options -Xlint ou -Xlint:finally de javac 5.0...

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?

[Java 5.0] serial : "serializable class Main has no definition of serialVersionUID"


Auteurs : adiGuba ,
Ce warning signale qu'une classe qui implémente l'interface java.io.Serializable n'a pas définit de serialVersionUID.
En effet, le serialVersionUID permet d'affecter un numéro de version à la classe. Ce numéro doit normalement être
changé lorsqu'un champs non-transiant est ajouté ou supprimé de la classe. Théoriquement, c'est au développeur de
gérer ce numéro de version. Toutefois, si ce champs est absent, le compilateur générera un numéro automatique.
Le champs serialVersionUID est utilisé lors de la désérialization afin de s'assurer que les versions des classes Java soient
concordantes. Si ce n'est pas le cas, une InvalidClassException sera levée.
Or il se trouve que le calcul des serialVersionUID par défaut est extrêmement sensible aux modifications apportées
au code source et peut même varier selon les compilateurs. Ce qui a pour inconvénient de provoquer des
InvalidClassExceptions inattendues lors de la désérialisation.
Il est ainsi fortement conseillé de gérer le serialVersionUID de toutes classes sérializable, et bien sûr de modifier cette
valeur lors d'un changement sur les champs de la classe. Ce warning signalera ainsi toutes classes Serializable sans
définition du serialVersionUID explicite :

Main.java:5: warning: [serial] serializable class Main has no definition of serialVersionUID

Pour définir le serialVersionUID, il faut utiliser le code suivant (où 1L est le numéro de la version qui devra être changé
à chaque modification sur les champs. La valeur n'a pas d'importance du moment qu'elle change lors d'un changement
sur les champs à sérializer) :

- 126 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Définition du serialVersionUID
private static final long serialVersionUID = 1L;

Il suffira ensuite de modifier ce numéro de version à chaque changement important dans la classe. Le plus simple étant
d'incrémenter sa valeur.

Ce warning n'est actif qu'avec les options -Xlint ou -Xlint:serial de javac 5.0...

Ceci concerne également les classes qui héritent d'une classe qui implémente Serializable,
puisqu'elle devient elle-même Serializable. Ainsi, ce warning concerne toutes les classes qui
étendent les composants Swing par exemple...

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?


lien : Que signifie le mot-clé transient ?
lien : Qu'est-ce que la sérialisation ?

[Java 5.0] path : "bad path element"


Auteurs : adiGuba ,
Ce warning permet d'afficher un message si les chemins passés à javac (classpath, sourcepath,...) sont inexistants. Il est
ainsi très pratique pour vérifier que tous les éléments du CLASSPATH sont corrects. Ainsi, si un chemin est incorrect,
il affichera le message suivant :

warning: [path] bad path element "../lib.jar": no such file or directory

Ce warning n'est actif qu'avec les options -Xlint ou -Xlint:path de javac 5.0...

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?

fallthrough : "possible fall-through into case"


Auteurs : adiGuba ,
Ce warning signale des erreurs possibles dans les blocs switch si l'on n'utilise pas de break à la fin de chaque case. En
effet, dans le code suivant :

switch (value) {
case 1:
System.out.println("Un");
case 2:
System.out.println("Deux");
case 3:
System.out.println("Trois");
}

Si value vaut 1, alors le code des trois case sera exécuté car il n'y a aucun break. Si cette conception est autorisée par le
langage, elle est toutefois fortement déconseillée car elle complexifie l'utilisation du switch. Ainsi, le warning fallthrough,
activé avec l'option -Xlint ou -Xlint:fallthrough de javac 5.0, permet de signaler l'oubli du mot-clef break à la fin d'un
case, et donc le 'saut' possible au bloc case suivant :

- 127 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Résultat de la compilation
Main.java:19: warning: [fallthrough] possible fall-through into case
case 2:
^
Main.java:21: warning: [fallthrough] possible fall-through into case
case 3:
^

Ce warning peut également être activé sur les versions précédentes de javac avec l'option -
Xswitchcheck.

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?

[Java 5.0] unchecked : "uses unchecked or unsafe operations"


Auteurs : adiGuba ,
Ce warning signale qu'une classe/méthode paramétrée avec les Generics est utilisée sans indication du type paramétré,
ce qui lui fait perdre la sécurisation des opérations apporté par les Generics. Si ce warning est désactivé, une note sera
quand même affichée à la fin de la compilation, par exemple :

Résultat de la compilation :
Note: Main.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Ce warning peut ainsi être affiché dans sa forme détaillée avec l'option -Xlint:unchecked de javac 5.0, ce qui donne
par exemple :

Résultat de la compilation :
Main.java:14: warning: [unchecked] unchecked call to add(E) as a member of the raw type
java.util.List
list.add("string");

Dans cet exemple, on utilise la méthode add() de l'interface java.util.List sans avoir paramétré son type. Concrètement,
ce warning apparaît avec le code suivant :

List list = new ArrayList();


list.add("string");

La raison est simple, l'interface java.util.List et la classe java.util.ArrayList qui l'implémente sont désormais
paramétrées. Elles doivent donc être utilisées en utilisant les Generics :

List<String> list = new ArrayList<String>();


list.add("string");

L'utilisation de la liste est ainsi sécurisée car le compilateur vérifiera que seul des objets de type String y sont ajouté...

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?

- 128 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : [Java 5.0] Qu'est-ce que les Generics (types paramétrés) ?

deprecation : "uses or overrides a deprecated API"


Auteurs : adiGuba ,
Ce warning signale toutes les méthodes/classes dépréciées, c'est à dire qui ne devrait plus être utilisées. Si ce warning
est désactivé, une note sera quand même affichée à la fin de la compilation, par exemple :

Résultat de la compilation :
Note: Main.java uses or overrides a deprecated API.
Note: Recompile with -Xlint:deprecation for details.

Ce warning peut ainsi être affiché dans sa forme détaillée avec l'option -Xlint:deprecation de javac 5.0 (ou -deprecation
avec une version plus ancienne du JDK). Il affichera ainsi l'élément concerné par la dépréciation :

Résultat de la compilation :
Main.java:7: warning: [deprecation] getYear() in java.util.Date has been deprecated
return d.getYear();

Il faut ensuite consulter la documentation de la méthode/classe concernée afin de connaître la solution de remplacement.

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?

[Java 5.0] Comment supprimer un warning en particulier ?


Auteurs : adiGuba ,
En plus d'introduire de nouvelles fonctionnalités, Java 5.0 à introduit un grand nombre de nouveaux warnings afin
d'indiquer un problème potentiel. Toutefois, il existe de nombreux cas où l'on ne peut pas faire autrement et ces warnings
peuvent alors être assez dérangeant.

Il est heureusement possible d'utiliser l'annotation @SuppressWarning afin de supprimer un warning en particulier.
Par exemple afin de supprimer le warning concernant l'absence de définition du serialVersionUID :

@SuppressWarnings("serial")
class MyFrame extends javax.swing.JFrame {

Ou encore afin d'utiliser une classe ou méthode dépréciée sans warning :

@SuppressWarnings("deprecation")
java.util.Date date = new java.util.Date(2007, 1, 1);

L'annotation attend en paramètre le(s) nom(s) des warnings à ignorer. Le JDK officiel de Sun utilise principalement les
warnings suivants : deprecation, unchecked, fallthrough, path, serial et finally. Toutefois d'autre compilateur peuvent
très bien utiliser d'autre type de warning. Si un nom de warning est inconnu pour le compilateur, il se doit de l'ignorer.

Attention : cacher un warning ne veut pas dire que le problème est résolu, et ne devrait être utiliser qu'en dernier
recours s'il n'existe vraiment pas de solution alternative.

- 129 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Il faut également faire attention à bien positionner l'annotation, qui agit sur l'élément dans sa totalité. Si elle est
positionné devant une déclaration de variable cela ne concernera que cette ligne, mais devant une méthode ou une classe
cela concernera la totalité de cette dernière, et cela risquerait de cacher d'autres warnings plus problématiques.

Il faut donc toujours essayer de limiter le plus possible la zone d'effet de l'annotation @SuppressWarning, par exemple
en créant une méthode simplement destiné à recevoir le code en question.

Remarque : bien que comprise dans les spécifications de Java 5.0, cette annotation n'est effectivement supporté par le
compilateur officiel du JDK de Sun qu'à partir de Java 5.0 update 6...

lien : [Java 5.0] Comment activer/désactiver les warnings avec javac ?


lien : Présentation de Java 5.0 (Tiger)

- 130 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Système


Comment connaître le système d'exploitation depuis le programme ?
Auteurs : Clément Cunin ,
Bien que Java soit conçu pour fonctionner indépendament du système, il est parfoit utile de savoir lequel exécute notre
programme. Cela permet, par exemple, de choisir si l'on doit exécuter Mozilla, Safari ou plutot Internet Explorer.

Pour cela, il suffit de consulter les variables d'environnement initialisées par la JVM :

String name = System.getProperty ( "os.name" );


String version = System.getProperty ( "os.version" );

lien : Comment accéder aux valeurs des variables d'environnement ?

Comment accéder aux valeurs des variables d'environnement ?


Auteurs : Clément Cunin ,
Variable d'environnement du système :
L'accès aux variables d'environnement se fait par l'intermédiaire de la classe java.lang.System et plus précisément par la
méthode getProperty(java.lang.String clé). Cette méthode donne accès à toutes les variables définies par le système. Des
variables peuvent facilement être initialisées lors du lancement du programme en les ajoutant à la ligne de commande :

java -DTEST="test" nom_programme


// Création d'une variable : TEST = "test"

Variable d'environnement de Java :


Se baser sur les variables du système n'étant pas très portable, Java définit un certain nombre de variables de façon
indépendante de la plateforme d'exécution.
Exemple :

System.getProperty("user.dir");
System.getProperty("java.home");
System.getProperty("os.name");

Connaître la liste des variables d'environnement :


La liste des variables d'environnement est disponible par la méthode getProperties() de la classe java.lang.System.
Programme affichant la liste de toutes les variables :

java.util.Enumeration liste = System.getProperties().propertyNames();


String cle;
while( liste.hasMoreElements() ) {
cle = (String)liste.nextElement();
System.out.println( cle + " = " + System.getProperty(cle) );

- 131 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Comment exécuter une application externe ?


Auteurs : Clément Cunin ,
Execution :
L'exécution d'un programme externe se fait grâce à la méthode exec(java.lang.String commande) de la classe
java.lang.Runtime.

try {
Process proc = Runtime.getRuntime().exec("commande paramétrée");
} catch (IOException e) {

Communication :
Il est possible de communiquer avec l'application grâce à l'objet java.lang.Process :
• destroy() pour tuer l'application fille.
• waitFor() pour attendre la fin de l'application fille (Attention à ne pas bloquer l'exécution du processus
d'évènement awt).
• getErrorStream(), getInputStream() et getOutputStream() pour communiquer avec l'application.
• exitValue() pour connaître l'état de sortie de l'application.

Comment lancer une application sans le terminal (Windows uniquement) ?


Auteurs : Clément Cunin ,
Lorsque l'on exécute une application Java sous windows, un terminal de commande permet d'afficher les entrées/sorties
de l'application. Si vous souhaitez exécuter votre application sans le terminal, il suffit d'utiliser javaw.exe à la place
de java.exe

javaw -CLASSPATH ... monAppli

Une deuxième solution consiste à créer une archive Jar contenant tous les fichiers de l'application et un fichier 'manifest'.
De cette manière, il suffit alors de double-clicker sur le fichier jar pour l'exécuter.
Pour plus d'informations, lire : Comment créer un jar exécutable ?

lien : Comment créer un jar exécutable ?

Comment lire/écrire du texte dans le presse-papier ?


Auteurs : Clément Cunin ,
L'accès au presse-papier se fait grâce à la classe java.awt.datatransfer.Clipboard disponible dans la boite à outils
(java.awt.Toolkit).

Lire du texte :

/** Lecture du contenu : */


Transférable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);

- 132 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

try {
/** Vérification que le contenu est de type texte. */
if( t!=null && t.isDataFlavorSupported(DataFlavor.stringFlavor) ) {
String txt = (String)t.getTransferData(DataFlavor.stringFlavor);
}
} catch( UnsupportedFlavorException e1) {
e1.PrintstackTrace();
} catch( IOException e2 ) {
e2.PrintstackTrace();
} catch( IllegalStateException ) {
e.PrintstackTrace();
/** Le presse-papier n'est peut-être pas disponible */
}

Ecrire du texte :

try {
StringSelection ss = new StringSelection("Mon Texte");
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,null);
} catch( IllegalStateException ) {
e.PrintstackTrace();
/** Le presse-papier n'est peut-être pas disponible */
}

A noter que sous Windows IllegalStateException peut être lancée si le presse-papier est vide.

Comment lire/écrire une Image dans le presse-papier ?


Auteurs : Ioan Calapodescu ,
Le principe est le même que pour l'écriture ou la lecture de texte. La seule difficulté viens du fait qu'il n'existe pas
d'image implémentant Transferable. Cette difficulté est toute relative car la création d'une telle classe tiens en quelques
lignes :

import java.awt.*;
import java.awt.datatransfer.*;
import java.io.*;

public class TransferableImage implements Transferable{


private Image image;
public TransferableImage(Image uneImage){
image = uneImage;
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException,
IOException{
if(!isDataFlavorSupported(flavor)){throw new UnsupportedFlavorException(flavor);}
return image;
}
public DataFlavor[] getTransferDataFlavors(){
return new DataFlavor[]{DataFlavor.imageFlavor};
}
public boolean isDataFlavorSupported(DataFlavor flavor){
return DataFlavor.imageFlavor.equals(flavor);
}
}

- 133 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pour un exemple d'utilisation regardez le fichier ci-dessous.

lien : Comment lire/écrire du texte dans le presse-papier ?

Comment connaitre la mémoire utilisable de la carte graphique ?


Auteurs : Seigne David ,
Voici une méthode permettant de récuperer la mémoire disponible (en Mo) pour la carte graphique :

public int getAvailableMemory(){


// obtenir le type d'environnement graphique sous lequel tourne la JVM
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
// obtenir le périphérique d'affichage (carte graphique)
GraphicsDevice device = environment.getDefaultScreenDevice();

// calcule le nombre de Méga Octets libres dans la carte graphique


int bytes = device.getAvailableAcceleratedMemory();
int mbytes = bytes /1048576;
return mbytes;
}

Comment ouvrir une page web avec le navigateur par défaut en restant portable ?
Auteurs : Baptiste Wicht , adiGuba ,
Soit vous vous amusez à aller fouiller sur le pc pour trouver quel est le navigateur, ou alors beaucoup plus simple, vous
utilisez l'api JDIC. Cette api permet une meilleure intégration au système tout en conservant la portabilité

Ainsi, vous pourrez faire :

try {
Desktop.browse(new URL("url du site");
} catch (MalformedURLException e1) {
//Problème avec votre URL
e1.printStackTrace();
} catch (DesktopException e2) {
//Problème lors du lancement de l'explorateur
e2.printStackTrace();
}

Il faut penser à ajouter jdic.dll dans le class-path pour qu'il soit utilisable. Il suffit normalement de le mettre au même
niveau que votre application et la JVM le trouvera.

Avec Java 6, cette fonctionnalité de JDIC a été intégré en standard via la classe java.awt.Desktop qui possède un
comportement similaire.

Toutefois, étant donné qu'il s'agit d'une fonctionnalité dépendant du système d'exploitation et/ou du gestionnaire de
fenêtre, elle n'est pas forcément disponible sur tous les systèmes et nécessite des vérifications préalables (sous peine de
recevoir une UnsupportedOperationException).

Voici donc le code Java 6 permettant d'ouvrir une page Web :

- 134 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

// On vérifie que la classe Desktop soit bien supportée :


if ( Desktop.isDesktopSupported() ) {
// On récupère l'instance du desktop :
Desktop desktop = Desktop.getDesktop();

// On vérifie que la fonction browse est bien supportée :


if (desktop.isSupported(Desktop.Action.BROWSE)) {

// Et on lance l'application associé au protocole :


desktop.browse(new URI("http://java.developpez.com"));
}
}

A noter qu'il est également possible d'utiliser cette méthode pour ouvrir d'autre type de protocole (ftp par exemple).

lien : Télécharger JDIC


lien : classe java.awt.Desktop
lien : Améliorez l'intégration au système de votre programme avec les classes Desktop et SystemTray de Java 6, par
Baptiste Wicht

Comment ouvrir un fichier avec le programme par défaut en restant portable ?


Auteurs : Baptiste Wicht , adiGuba ,
Soit vous vous amusez à aller fouiller sur le pc pour trouver quel est le programme par défaut pour tel fichier, ou
alors beaucoup plus simple, vous utilisez l'api JDIC. Cette api permet une meilleure intégration au système tout en
conservant la portabilité

Ainsi, vous pourrez faire :

try {
Desktop.open(new File("Chemin vers fichier"));
} catch (DesktopException e2) {
//Problème lors du lancement du programme
e2.printStackTrace();
}

Il faut penser à ajouter jdic.dll dans le class-path pour qu'il soit utilisable. Il suffit normalement de le mettre au même
niveau que votre application et la JVM le trouvera.

Avec Java 6, cette fonctionnalité de JDIC a été intégré en standard via la classe java.awt.Desktop qui possède un
comportement similaire.

Toutefois, étant donné qu'il s'agit d'une fonctionnalité dépendant du système d'exploitation et/ou du gestionnaire de
fenêtre, elle n'est pas forcément disponible sur tous les systèmes et nécessite des vérifications préalables (sous peine de
recevoir une UnsupportedOperationException).

Voici donc le code Java 6 permettant d'ouvrir un fichier avec le programme par défaut :

// On vérifie que la classe Desktop soit bien supportée :


if ( Desktop.isDesktopSupported() ) {
// On récupère l'instance du desktop :
Desktop desktop = Desktop.getDesktop();

// On vérifie que la fonction open est bien supportée :

- 135 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

if (desktop.isSupported(Desktop.Action.OPEN)) {

// Et on lance l'application associé au fichier pour l'ouvrir :


desktop.open(new File("Chemin vers fichier"));
}
}

A noter qu'il est également possible d'utiliser les méthodes edit() et print() de la même manière, ce qui a respectivement
pour effet d'ouvrir le fichier en édition et de l'imprimer, toujours en utilisant les programmes par défaut.

lien : Téléchargement de JDIC


lien : classe java.awt.Desktop
lien : Améliorez l'intégration au système de votre programme avec les classes Desktop et SystemTray de Java 6, par
Baptiste Wicht

Comment ouvrir la boite de dialogue d'envoi d'email du


logiciel de messagerie par défaut en restant portable ?
Auteurs : adiGuba ,
Soit vous vous amusez à aller fouiller sur le pc pour trouver quel est le logiciel de messagerie, ou alors beaucoup plus
simple, vous utilisez l'api JDIC. Cette api permet une meilleure intégration au système tout en conservant la portabilité

Ainsi, vous pourrez faire :

try {
Desktop.mail();
} catch (MalformedURLException e1) {
//Problème avec votre URL
e1.printStackTrace();
} catch (DesktopException e2) {
//Problème lors du lancement de l'explorateur
e2.printStackTrace();
}

Avec Java 6, cette fonctionnalité de JDIC a été intégré en standard via la classe java.awt.Desktop qui possède un
comportement similaire.

Toutefois, étant donné qu'il s'agit d'une fonctionnalité dépendant du système d'exploitation et/ou du gestionnaire de
fenêtre, elle n'est pas forcément disponible sur tous les systèmes et nécessite des vérifications préalables (sous peine de
recevoir une UnsupportedOperationException).

Voici donc le code Java 6 permettant d'ouvrir la saisie d'un nouvel email :

A noter qu'il est également possible d'utiliser le méthode mail(URI) en utilisant le protocol mailto pour spécifier des
paramètre avancée (nom du destinataire, copie, sujet, contenu du message,...).

lien : Télécharger JDIC


lien : classe java.awt.Desktop

- 136 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Améliorez l'intégration au système de votre programme avec les classes Desktop et SystemTray de Java 6, par
Baptiste Wicht

Comment trouver le répertoire contenant le jar où est ma classe ?


Auteurs : bulbo ,
Le bout de code suivant permet de retrouver le répertoire contenant le fichier jar où est la classe courante.

Si la classe n'est pas dans un jar, le répertoire sera celui présent dans le CLASSPATH.
Par exemple si la classe est:
C:\sources\java\lang\Object.class
Le répertoire trouvé sera:
C:\sources

Voici le code pour réaliser ça:

String path = "/" + TestLocation.class.getName().replace('.', '/') + ".class";


URL url = getClass().getResource(path);
path = URLDecoder.decode(url.toString(), "UTF-8");

// suppression de la classe ou du jar du path de l'url


int index = path.lastIndexOf("/");
path = path.substring(0, index);

if (path.startsWith("jar:file:"))
{
// suppression de jar:file: de l'url d'un jar
// ainsi que du path de la classe dans le jar
index = path.indexOf("!");
path = path.substring(9, index);
}
else
{
// suppresion du file: de l'url si c'est une classe en dehors d'un jar
// et suppression du path du package si il est présent.
path = path.substring(5, path.length());
Package pack = getClass().getPackage();
if (null != pack)
{
String packPath = pack.toString().replace('.', '/');
if (path.endsWith(packPath))
{
path = path.substring(0, (path.length() - packPath.length()));
}
}
}

System.out.println("Répertoire contenant la classe: " + path);

NB : Pour un JDK inférieur au 1.4 il faut utiliser URLDecoder.decode(String uneURL).


NB2 : Pour appeler ce code depuis un bloc static il faut remplacer getClass() par NomDeLaClasse.class.

Comment créer un service Windows en Java (Solution open-source) ?


Auteurs : bulbo ,
Un service Windows est un programme qui est soit démarré au démarrage du système soit qui peut être démarré depuis
le programme "Services" fournit avec Windows (NT, 2000 ou XP).

- 137 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pour ce faire il existe par exemple un projet open-source: JavaService


A noter toutefois qu'il n'est pas possible d'avoir une interface graphique pour une application java qui tournerait comme
un service.

http://javaservice.objectweb.org

Comment connaître le nombre de processeurs disponibles ?


Auteurs : NiCo5130 ,
La connaissance du nombre de CPU de la machine peut être utile dans certains cas. Par exemple combien de thread
maximum on peut lancer en concurrence sans trop affecter les performances générales de la machine.

La classe Runtime donne la solution:

int nbProc = Runtime.getRuntime().availableProcessors();

Où télécharger les anciennes versions de Java ?


Auteurs : elitost ,
Les versions antérieures des JDK, JRE, JEE et plus encores sont disponibles sur le site de SUN à l'adresse suivante :

http://java.sun.com/products/archive/

- 138 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Sommaire > Astuces et divers


Comment utiliser une police True Type n'importe où en Java ?
Auteurs : iubito ,
1. On récupère un InputStream sur le fichier TTF

InputStream ttf;

- depuis une servlet, le fichier TTF est dans le répertoire /fonts/ du war :

ttf = getServletContext().getResourceAsStream("fonts/ARIALN.TTF");

- depuis le système de fichiers :

ttf = new FileInputStream("/aaa/bbb/ccc/ARIALN.TTF");

2. On crée une Font :

Font arialNarrow;
try {
arialNarrow = Font.createFont(Font.TRUETYPE_FONT, ttf);
}
catch (Exception e) { //Une solution de rechange, au cas où...
arialNarrow = new Font("Arial", Font.PLAIN, 1);
}
finally {
try {
ttf.close();
}
catch (Exception ignore) {}
}

3. La Font obtenue est de taille 1. Ce qui n'est pas terrible. On utilise alors deriveFont pour en créer des dérivées. Par
exemple, on obtient du arial narrow grassouillet avec :

Font arialNarrowBold = arialNarrow.deriveFont(Font.BOLD);

Si besoin, créer une version avec ITALIC... Maintenant avec nos polices de bases, il suffit de modifier la taille.

BufferedImage bi = ImageIO.read("fichier.jpg");
Graphics2D g2d = bi.createGraphics();
//Antialiasing
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2d.setFont(arialNarrow.deriveFont(48f));
//et maintenant on peut écrire en Arial Narrow de taille 48
g2d.setFont(arialNarrowBold.deriveFont(24f));
//et là du Arial Narrow gras taille 24

- 139 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le petit f, c'est pour float, deriveFont accepte un int pour BOLD, ITALIC, PLAIN (qui sont des int), ou un float pour
modifier la taille.

Comment mettre mon application dans le "systray" ?


Auteurs : Ioan Calapodescu , adiGuba ,
Depuis Java SE 6, il est possible de placer des icônes dans le "system tray" du bureau. Toutefois cette fonctionnalité étant
fortement dépendante du système d'exploitation et de son bureau, elle n'est pas forcément supporté dans tous les cas.

Voici un exemple de code permettant d'ajouter une icône dans le "systray" :

// On vérifie que le "systray" est supporté


// par la JVM pour ce système d'exploitation
if (SystemTray.isSupported()) {

// On Crée un TrayIcon qui représentera notre icône :


TrayIcon trayIcon = new TrayIcon(
image, // L'image qui sera utilisé comme icône
tooltip, // Le texte affiché lors du survol de la souris
popup // Le PopupMenu qui s'affichera lors du clic droit
);

// On active le redimensionnement automatique de


// l'icône, afin qu'elle s'adapte au système
// (sinon l'icône peut être tronqué ou disproportionné)
trayIcon.setImageAutoSize(true);

// On récupère l'instance du SystemTray


SystemTray systemTray = SystemTray.getSystemTray();

// Et on ajoute notre TrayIcon dans le system tray


systemTray.add(trayIcon);
}

A noter qu'une fois que l'icône est présente dans le systray, on peut l'utiliser pour afficher une infobulle :

trayIcon.displayMessage(
"Titre", // Titre de la bulle
"Message", // Contenu du message
MessageType.INFO // Style de l'icone
);

Pour les versions antérieurs à Java SE 6, plusieurs API (plus ou moins portables), utilisant JNI, existent pour pallier
à ce manque :

• SysTray for Java : fonctionne sur les systèmes Windows et KDE.


• Java System Tray Manager : fonctionne uniquement sur Windows.

- 140 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

• JDIC (JDesktop Integration Components) : fonctionne sous Windows, Linux et Solaris

lien : Les classes Desktop et SystemTray, des alternatives à JDIC, par Baptiste Wicht

Comment gérer facilement les préférences de l'utilisateur ?


Auteurs : Ioan Calapodescu ,
La classe abstraite Preferences du package java.util.prefs permet d'enregistrer facilement certaines données. Les
implémentations dépendent du système (registres, SGBD, fichiers, etc.), mais ceci est invisible pour l'utilisateur.
Plusieurs niveaux de préférences peuvent être définis. Ceux-ci sont accessibles grâce aux méthodes statiques de la classe
Preferences.
Niveaux de Preferences
• Preferences.systemRoot() : préférences globales du système.
• Preferences.systemNodeForPackage(Class c) : préférences du système pour une classe donnée.
• Preferences.userRoot() : préférences globales de l'utilisateur.
• Preferences.userNodeForPackage(Class c) : préférences globales de l'utilisateur pour une classe donnée.

Les Preferences associent à une clef (String) une valeur. On peut stocker dans les Preferences tout type primitif. Voici
les méthodes correspondantes à :
La lecture de Preferences

Preferences prefs = Preferences.systemRoot();


String unString = prefs.get("uneClef","une valeur par défaut si il n'y a pas de valeur");
// on peut aussi récuperer d'autres types primitifs
int unInt = prefs.getInt("clefInt",123);
// on doit toujours spécifier une valeur par défaut

L'écriture de Preferences

Preferences prefs = Preferences.systemRoot();


prefs.put("clef","valeur");
prefs.putInt("clefInt",456);

Pour un exemple plus complet, regardez le fichier ci-dessous. Il consiste en une fenêtre capable de "mémoriser" sa
position, sa taille et son état (maximisée, iconifiée, etc.).

Exemple

Où trouver de l'aide sur JavaMail ?


Auteurs : L'équipe Java ,

lien : http://developer.java.sun.com/developer/onlineTraining/JavaMail/contents.html

Comment lire et générer des documents aux formats spécifiques (pdf, rtf, html, doc, etc.) ?
Auteurs : duj , Ioan Calapodescu ,
De nombreux formats de fichiers textes peuvent être utilisés avec Java. Malheureusement, tous ne sont pas utilisables
grâce à l'API standard. Voici quelques formats et les API qui peuvent les utiliser :

- 141 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Format API Remarques


HTML API Standard Cf. HTMLEditorKit,
JEditorPane et JTextPane
RTF API Standard Cf. RTFEditorKit,
JEditorPane et JTextPane
XML API Standard (SAX, DOM) Il existe de nombreuses
librairies facilitant le travail
avec ce type de documents
PDF iText, FOP Ces deux librairies sont
utilisées seulement pour la
génération
Excel POI, JExcelAPI
Word POI

Comment créer son propre Listener ?


Auteurs : Johann Heymes ,
Cas de figure :
Un composant donné a besoin d'informer un ou plusieurs composants externes que certains événements se sont produits.

Un petit exemple :
Le composant MonBouton a besoin d'informer une liste d'objets que le bouton gauche de la souris est appuyé et que
le bouton de la souris a été relaché.

Définir une nouvelle interface :

public interface MonBoutonMouseListener extends EventListener {


public void boutonGauchePresse (EventObject e);
public void boutonGaucheRelache (EventObject e);
}

class monBoutton :

/** import nécessaire : */


import javax.swing.event.EventListenerList;

/** attribut : */
protected EventListenerList listenerList;

/** instanciation nécessaire : (à faire dans son constructeur


* ou dans une méthode appelée par le constructeur)
*/
this.listenerList = new EventListenerList ();

/** méthode à faire :


* permet d'ajouter un composant dans la liste de ceux qui veulent
* être informés de l'évènement
*/
public void addMonBoutonMouseListener (MonBoutonMouseListener l) {
this.listenerList.add (MonBoutonMouseListener.class, l);
}

/** enlève un objet qui est actuellement écouteur de l'évènement */

- 142 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

public void removeMonBoutonMouseListener (MonBoutonMouseListener l) {


this.listenerList.remove (MonBoutonMouseListener.class, l);
}

/** lance un évènement à tous les objets écouteurs


* (== appelle la méthode boutonGauchePresse sur tous les objets
* écouteurs de la liste)
*/
protected void fireboutonGauchePresse () {
MonBoutonMouseListener [] listeners = (MonBoutonMouseListener [])
listenerList.getListeners( MonBoutonMouseListener.class);
EventObject e = new EventObject (this);
for (int i = listeners.length-1; i&gt;=0; i--) {
listeners [i].boutonGauchePresse (e);
}
}

Il suffit ensuite d'appeler cette méthode à chaque fois que l'évènement approprié est généré.

Exemple d'implémentation.

Comment faire en sorte que le paramètre int de ma méthode soit modifié en retour ?
Auteurs : Clément Cunin ,
En Java les types de base sont passés aux méthodes par valeur, ils ne peuvent pas être modifiés. Il va falloir utiliser une
instance de classe "encapsulant" un entier pour effectuer la modification. Attention la classe fournie Integer ne permet
pas la modification et est donc inutile dans ce cas.

Exemple :

class MonEntier {
/** champ privé : */
private int value;

/** mise à jour de la valeur */


public void setValue(int newValue) {
value = newValue;
}

/** Acces à la valeur */


public int getValue() {
return( value);
}
}

Dans la méthode maMethode faire :

public void maMethode (MonEntier i) {


i.setValue(maNouvelleValeur);

- 143 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Comment gérer les fermetures accidentelles ( Contrôle-C, kill -2, kill -15) ?
Auteurs : Johann Heymes ,
Contrôle-C, kill -2, kill -15 et autres sont des méthodes permettant d'arrêter l'exécution du programme sans lui
demander son avis. Pourtant, il est parfois nécessaire de faire au moins quelques instructions capitales telles que la
fermeture de flux de fichier, d'une connexion réseaux ou une sauvegarde rapide. Pour se faire il est possible de définir
un 'ShutdownHook' ce qui se traduit par un thread exécuté à la réception du signal de fin d'exécution.

Attention :
Ce traitement final sera également éxécuté lors de l'arrêt normal de l'application.

Cette astuce ne marche malheureusement pas pour le code kill -9.

Exemple d'implémentation.

Comment forcer le passage du 'Garbage collector' ?


Auteurs : Clément Cunin ,
Le garbage Collector (rammasse miette) est la partie de la JVM qui s'occupe de la récupération des zones mémoires.
Les phases de libération de la mémoire sont gérées de façon autonome, il est inutile de lui dire quand passer.

Il existe néanmoins la fonction gc de la classe java.lang.System qui permet de faire un appel explicite au garbage
collector. Cet appel ne garantit pas que tous les objets inutiles seront supprimés de la mémoire.

System.gc ();
//Appel explicite au Garbage collector

Néanmoins, cette méthode ne garantit par le passage du GC. Elle permet seulement d'augmenter la propabilité que le
GC se déclenche. Il est préférable de mieux gérer ses objets plutôt que d'utiliser cette méthode.

Comment faire une énumération en Java ?


Auteurs : Clément Cunin ,
Voici trois solutions :

1ère solution :

public class MonEnum {


public final static int Val1=0;
public final static int Val2=1;
public final static int Val3=2;
}

On peut ensuite utiliser MonEnum.Val1, MonEnum.Val2 etc, ou mieux on peut faire une interface plutôt qu'une classe
afin que les classes l'implémentant puissent directement appeler Val1, Val2...

- 144 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Le problème reste le typage des éléments, rien n'empêche de passer un objet d'une énumération à la place d'une autre.

2ème solution :
Cette deuxième catégorie de solutions, plus complexes, permet d'éviter ce problème. On peut par exemple penser à
utiliser des instances de classes :

public final class MonEnum1 {


private MonEnum1() {
/** Rien à faire */
}

/** liste des valeurs */


public final static MonEnum1 Val1 = new MonEnum1();
public final static MonEnum1 Val2 = new MonEnum1();
public final static MonEnum1 Val3 = new MonEnum1();
}

Ainsi un éventuel objet de type MonEnum2 ne pourra jamais être utilisé à la place d'un objet de type Enum1
(Enum1.Val1 Enum1.Val2 ...).

2ème bis solution :


La 2ème solution pose un autre problème, il reste possible d'utiliser la valeur 'null' alors que celle-ci n'appartient pas
au domaine de notre énumération. Pour ce faire, rien de plus simple, si on considère val1 comme la valeur par défaut,
on la déclare de la manière suivante :

public final static Enum1 val1 = null;

De cette manière il devient totalement impossible de passé un Enum1 non reconnu !

3ème solution :
Depuis Java 5.0, vous pouvez utiliser le mot-clé enum pour créer des énumérations. Voilà comment vous pouvez
procéder pour créer un énumération :

enum Align{
LEFT,
RIGHT,
CENTER,
JUSTIFIED
};

Vous pouvez accéder aux valeurs ainsi :

Align.LEFT;
Align.RIGHT;

Conclusion :
Si vous avez Java 5.0 ou une version plus récente, il vous faut utiliser la solution 3.

lien : http://jakarta.apache.org/commons/lang/api/org/apache/commons/lang/enum/package-summary.html

- 145 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Plus d'infos sur les enums

Comment annuler la construction d'un objet lors de la construction ?


Auteurs : Clément Cunin ,
Si les paramètres passés au constructeur sont incohérents ou que la construction provoque une erreur, la création de
l'objet est impossible et doit être annulée. Comme les méthodes, les constructeurs peuvent lever des exceptions, c'est la
façon la plus simple d'annuler l'exécution du constructeur. Techniquement, l'objet est créer en mémoire (l'allocation de
la mémoire a lieu au moment de l'appel du constructeur) mais l'appelant étant obligé de traiter l'exception, le pointeur
vers cette objet est perdu et sera donc recupéré par le ramasse-miettes.

Une solution plus élégante consiste à utiliser par une méthode statique qui verifie les paramètres et ne fait l'appel au
constructeur que si ceux-ci sont corrects.

public class Test {


/** Le constructeur est déclaré protected
* pour interdire son utilisation par les clients de la classe.
*/
protected Test(int val) {

}
public static Test createTest( int val ) {
if( val<100 ) {
return( new Test(val) );
} else {
return( null);
/** Ou alors on lève une exception... */
}
}
}

Comment recharger dynamiquement une classe ?


Auteurs : bulbo ,
En utilisant la méthode:

Class c = Class.forName("com.developpez.MaClasse");

On utilise le ClassLoader du système. Ce ClassLoader cache l'information et ne rechargera pas la classe lors d'un nouvel
appel a forName, et ce même si le fichier ".class" a changé depuis le dernier chargement.

Il y a deux solutions :

1 - La classe n'est pas présente dans le CLASSPATH C'est le cas le plus simple, il suffit d'utiliser un nouveau
URLClassLoader a chaque fois pour recharger une nouvelle version de la classe.

// le chemin ou trouver la classe a recharger


URL chemins[] = { new URL("file:/C:/MesClasses/") };
URLClassLoader loader = new URLClassLoader(chemins);
Class c = loader.loadClass("com.developpez.MaClasse");

Attention, il faut créer a chaque fois un nouvel URLClassLoader, sinon la classe est cachée par le loader.

- 146 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Si la classe est présente dans le CLASSPATH c'est le ClassLoader du système qui la charge (et la met dans son cache).

2 - La classe est présente dans le CLASSPATH

Dans ce cas, on ne peut pas utiliser l'URLClassLoader. Il faut créer son propre ClassLoader qui hérite de la classe
ClassLoader

import java.io.InputStream;

public class MonLoader extends ClassLoader


{

public Class loadNewClass(String aName) throws Exception


{
InputStream is = getClass().getResourceAsStream("/" + aName);
if (null == is)
{
return null;
}

byte buffer[] = new byte[is.available()];


is.read(buffer);
Class c = defineClass(aName, buffer, 0, buffer.length);
resolveClass(c);
return c;
}
}

Dans ce code, nous avons créé une nouvelle méthode "loadNewClass" qui recharge le fichier ".class" a chaque fois.

Le fait de ne pas avoir redéfini la méthode loadClass permet a ce nouveau ClassLoader d'utiliser le ClassLoader du
système pour charger d'eventuelles classes mères ou interfaces.

Si la méthode loadClass est redéfinie il faut qu'elle puisse aussi trouver les super classes et interfaces des classes qui
seront chargées, et ce sans recharger celles déjà présentes dans le système.

Qu'est-ce qu'un singleton ?


Auteurs : xavlours , osopardo ,
Un singleton est un objet qui ne peut être instancié qu'une seule et unique fois dans le programme.
Pour transformer une classe en singleton, il faut passer les constructeurs en accès private et ajouter au code une instance
et un accesseur statiques :

public class Singleton {

private static Singleton instance = new Singleton();

public static Singleton getInstance() {


return instance;
}

private Singleton() {
//constructeur
}

//reste de la classe

- 147 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Il existe une variante :

public class Singleton {

private static Singleton instance = null;

public static Singleton getInstance() {


if(instance == null)
instance = new Singleton();
return instance;
}

private Singleton() {
//constructeur
}

//reste de la classe

Enfin, pour accéder au singleton, il suffit d'appeler :

Singleton s = Singleton.getInstance();

Il existe encore une dernière variante consistant à utiliser une classe interne statique comme conteneur du singleton :

public class Something{


private Something() {
}

private static class LazyHolder {


private static final Something something = new Something();
}

public static Something getInstance(){


return LazyHolder.something;
}
}

Attention, toutes ces méthodes sont uniquement adaptées à un environnement mono-thread. Dans le cas où vous avez
plusieurs processus, dirigez-vous vers cet article.

lien : Le Singleton en environnement Multithread

Qu'est ce que le double-check locking ?


Auteurs : christopheJ ,
Le double-check locking est un idiome de programmation censé assurer la sécurité du Singleton en environnement
multithread.
Attention, ce pattern ne marche pas !
Il peut etre écrit comme suit :

public static Singleton getInstance(){


if (instance==null)
{
synchronized (Singleton.class){

- 148 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

if(instance==null)
instance=new Singleton();
}
}
return instance;
}

Bien qu'encore recommandé sur le web, son utilisation est fortement déconseillée.
Pour plus de détails : Le Singleton en environnement Multithread

Comment avoir un Singleton sûr en environnement multithread ?


Auteurs : christopheJ ,
Il existe trois solutions pour sécuriser un Singleton dans un programme multithread :
- Synchroniser toute la méthode getInstance() et payer le coût de la synchronisation à chaque appel
- Utiliser ThreadLocal dont l'implémentation n'est pas plus performante que la synchronisation
- Abandonner la synchronisation et utiliser un initialiseur static quand la construction du Singleton ne nécessite pas
de paramètres particuliers.
Pour plus d'informations : Le Singleton en environnement Multithread

Comment afficher la réference d'un objet redéfinissant la méthode toString()?


Auteurs : bulbo ,
La méthode toString() de la classe Object affiche le nom de l'objet suivi de la réference de l'objet dans la machine
virtuelle (une sorte de pointeur).
Ceci peut s'avérer utile parfois lors d'une phase de deboguage, mais comment faire lorsqu'une classe (comme la classe
String par exemple) redéfinie la méthode toString() ?
Il faut passer par la méthode System.identityHashCode(Object).
Le code suivant retourne la même chose que le toString() d'Object pour n'importe quel type d'objet:

public String getReference(Object anObject){


return anObject.getClass().getName() + "@" +
Integer.toHexString(System.identityHashCode(anObject));
}

Comment déterminer le temps écoulé entre deux points d'un programme ?


Auteurs : Nourdine Falola , Baptiste Wicht ,
System.currentTimeMillis()

En utilisant la méthode statique currentTimeMillis() de la classe System. Cette méthode renvoie un long représentant la
différence de temps entre le 1er Janvier 1970 à minuit et le temps système à l'exécution de l'instruction. Cette différence
s'exprime en fonction de l'unité de temps de l'OS (la milliseconde, voire quelques dizaines de milliseconde).

long start = System.currentTimeMillis();


// ... instructions à chronométrer
long duree = System.currentTimeMillis() - start;
System.out.println(duree);

- 149 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

System.nanoTime()

En utilisant la méthode statique nanoTime() de la classe System. Cette méthode n'est disponible que depuis le JDK 5.0.
Elle renvoie un long représentant la valeur du timer en nanosecondes.

long start = System.nanoTime();


// ... instructions à chronométrer
long duree = System.nanoTime() - start;
System.out.println(duree);

Ce temps n'est pas lié à un référentiel de temps universel, aussi on ne doit-on l'employer que pour mesurer une différence
de temps. La précision est de l'ordre de la nanoseconde.

Il faut aussi noter que ce n'est pas exactement le temps utilisée par votre application, mais le temps qui s'est écoulée
depuis le début à la fin de votre code. Pendant ce temps, d'autres applications tournent sur votre ordinateur et utilisent
ce qu'on appelle du temps CPU. Pour connaître exactement le temps CPU nécessaire, il faut utiliser la méthode
getCurrentThreadCpuTime() de l'interface java.lang.management.ThreadMXBean à la place de System.nanoTime()
ou currentTimeMillis() et vous aurez le temps CPU.

Comment connaitre la mémoire utilisée par notre application pendant son exécution ?
Auteurs : adiGuba ,
Avec Java 5.0, on peut utiliser la classe MemoryMXBean de la nouvelle API de management pour obtenir des
informations sur l'état de la mémoire. On récupère une instance de MemoryMXBean via le code suivant :

MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();

Ensuite, il suffit d'utiliser la méthode getHeapMemoryUsage() qui retournera un objet MemoryUsage contenant le
détail de la mémoire utilisé par votre application. Il contient ainsi les informations suivantes :

• init : La taille initiale de la mémoire utilisé par l'application (généralement 0, sauf si l'on a utilisé l'option -Xms
de la JVM).
• used : La quantité de mémoire qui est réellement utilisée par votre application.
• committed : La quantité de mémoire qui a été réservée auprès du système d'exploitation.
• max : La quantité maximale que la JVM est authorisée à réserver auprès du système d'exploitation (modifiable
avec l'option -Xmx de la JVM). Si l'application utilise plus de mémoire cela générera une OutOfMemoryError.

L'objet MemoryUsage possède bien entendu toutes les méthodes accésseurs pour accéder à ces éléments, mais également
une redéfinition de la méthode toString() afin de les afficher plus simplement. Ainsi le code suivant :

System.out.println( memoryBean.getHeapMemoryUsage() );

Donnera un résultat de le forme suivante :

init = 0(0K) used = 436912(426K) committed = 2031616(1984K) max = 530907136(518464K)

- 150 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

A noter également qu'il est possible de surveiller la mémoire utilisé pour la JVM elle-même (et non pas par votre
application) via la méthode getNonHeapMemoryUsage().

Pour les versions précédentes à Java 5.0, on peut utiliser la classe Runtime et ses méthodes maxMemory(),
totalMemory() et freeMemory() :

• maxMemory() représente la quantité maximale que la JVM est authorisée à réserver auprès du système
d'exploitation (équivalent de l'attribut max).
• totalMemory() représente la quantité de mémoire qui a été réservée auprès du système d'exploitation (équivalent
de l'attribut committed).
• freeMemory() représente la quantité de mémoire libre utilisable avant que la JVM n'alloue encore de la mémoire
auprès du système (équivalent à la différence entre les attributs committed et used)

Ainsi pour obtenir un résultat similaire, on peut utiliser le code suivant :

Runtime runtime = Runtime.getRuntime();


System.out.print( "used : " + ( runtime.totalMemory()-runtime.freeMemory() ) );
System.out.print( " committed : " + runtime.totalMemory() );
System.out.println( " max : " + runtime.maxMemory() );

Qui donnerait ceci :

used : 446256 committed : 2031616 max : 530907136

lien : Gestion du Garbage Collector


lien : MemoryMXBean
lien : Runtime

Pourquoi et comment redéfinir la méthode equals() ?


Auteurs : adiGuba ,
La méthode equals() permet d'indiquer qu'un objet est égal à un autre. L'implémentation par défaut hérité de Object
se contente de renvoyer true lorsqu'il s'agit du même objet en mémoire et ne vérifie pas les valeurs des attributs de la
classe (donc x.equals(y) équivaut à x==y).

Dès lors que l'on a besoin de tester l'égalité des instances d'une classe, il faut que cette dernière redéfinissent la méthode
equals(). C'est également une condition pour le bon fonctionnement de certaines méthodes des Collections de Java.

La méthode equals() doit donc renvoyer true lorsque deux objets sont identiques, et false dans le cas inverse. Enfin il
faut noter que cette méthode ne devraient pas renvoyer d'exception, même si son paramètre vaut null.

En général la méthode equals() se décompose en trois étapes :

• Vérification de l'égalité des références : il est inutile de comparer les valeurs si les références sont identiques.
• Vérification du type du paramètre : on ne peut pas comparer n'importe quel type.
• Vérification des valeurs des attributs utiles des deux objets (c'est à dire des attributs représentatifs de la valeur
de l'objet).

Ainsi, cela pourrait donner :

- 151 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

class TestClass {
private int attribut1;
private String attribut2;
private boolean visible; // Attribut non-représentatif et donc ignoré

@Override
public boolean equals(Object obj) {
// Vérification de l'égalité des références
if (obj==this) {
return true;
}

// Vérification du type du paramètre


if (obj instanceof TestClass) {
// Vérification des valeurs des attributs
TestClass other = (TestClass) obj;

// Pour les attributs de type primitif


// on compare directement les valeurs :
if (this.attribut1 != other.attribut1) {
return false; // les attributs sont différents
}

// Pour les attributs de type objets


// on compare dans un premier temps les références
if (this.attribut2 != other.attribut2) {
// Si les références ne sont pas identiques
// on doit en plus utiliser equals()
if (this.attribut2 == null || !this.attribut2.equals(other.attribut2)) {
return false; // les attributs sont différents
}
}

// Si on arrive ici c'est que tous les attributs sont égaux :


return true;
}

return false;
}
}

Il faut prendre en compte les règles suivantes lors de la redéfinition de la méthode equals() :

• Réflection : x.equals(x) devrait toujours retourner true.


• Symétrie : Si x.equals(y) retourne true, alors y.equals(x) retournera true.
• Transitivité : Si x.equals(y) retourne true et y.equals(z) retourne true, alors x.equals(z) retourne true.
• Consistance : Pour deux référence x et y, tous les appels à la méthode x.equals(y) devront toujours donner le
même résultat.

Toutefois ces règles peuvent être difficilement réalisable en cas d'héritage lorsque de nouveaux attributs sont pris en
compte.

Enfin, la librairie Jakarta Common Lang propose une classe EqualsBuilder qui facilite et simplifie l'écriture des
méthodes equals() en se chargeant de la comparaison des attributs, ce qui pourrait donner dans ce cas :

public boolean equals(Object obj) {


// Vérification de l'égalité des références
if (obj==this) {
return true;
}

// Vérification du type du paramètre

- 152 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

if (obj instanceof TestClass) {

// Vérification des valeurs des attributs


TestClass other = (TestClass) obj;

return new EqualsBuilder()


.append(this.attribut1, other.attribut1)
.append(this.attribut2, other.attribut2)
.isEquals();
}

return false;
}

Enfin, il faut noter qu'il est conseillé de redéfinir également la méthode hashCode() afin de respecter le contrat de cette
dernière (qui est fortement lié à equals()).

lien : Pourquoi et comment redéfinir la méthode hashCode() ?

Pourquoi et comment redéfinir la méthode hashCode() ?


Auteurs : adiGuba , mlny84 ,
La méthode hashCode() a pour objectif de fournir un code de hashage, afin d'optimiser le traitements des collections
de type Map, qui se basent sur ce hashCode pour classer les données. Il est ainsi nécessaire de redéfinir la méthode
hashCode() dès que l'on souhaire utiliser un objet en tant que clef d'une Map.

Mais plus généralement, il est souhaitable de redéfinir la méthode hashCode() lorsque l'on redéfinit la méthode equals(),
afin de conserver une certaine cohérence.

En effet, ces deux méthodes sont très liées, puisque les hashCode de deux objets égaux doivent être égaux, ainsi l'on
doit vérifier la condition suivante :

Si x.equals(y), alors x.hashCode() == y.hashCode()

Par contre l'inverse n'est pas forcément vrai. Ainsi deux objets différents peuvent avoir le même hashCode(). Toutefois
ceci est à éviter dans la mesure du possible, car cela peut détériorer les performances des Map.

Mais le calcul du hashCode() doit rester raisonnables et peu complexe, afin d'éviter des temps de calcul trop important.

La solution les plus courantes est de calculer un hashCode() selon la valeurs des attributs utilisés dans la méthode
equals() afin de conserver la cohérence entre les deux méthodes.

Pour le calcul du hashCode(), on peut raisonnablement suivre la règle suivante :

• On choisit deux nombres impairs différents de zéro. Un de ces nombres servira comme valeur de départ pour
le calcul du hashCode. Le second servira de "multiplieur" à chaque "ajout" du hashCode d'un attribut. Il est
préférable d'utiliser des nombres premiers par sécurité.

En effet, si à chaque clé x , correspond h(x) l'endroit où se trouve x dans la table de hachage. L'expression de la fonction
de Hachage est :

h(x)=[x(1)*B^(l-1) + x(2)*B^(l-2)....+x(l)] mod N

Prenons B = 128, et prenons une taille N égale a B, on obtient après calcul :

- 153 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

h(x)=x(l) mod N

car B mod N serait égale a 0

Une seule valeur a donc été rangée dans la table, voilà pourquoi il est très important de limiter au maximum les risques
de diviseur commun car certaines valeurs disparaîtraient alors des tables.

NB : le choix de B comme d'une puissance de deux au lieu d'un nombre premier peut s'avérer judicieux pour des raisons
de vitesse d'exécution. En effet une multiplication par deux est un simple décalage d'un bit à gauche pour l'ordinateur.
Malgré tout, cela augmente les risques de diviseur commun et donc de disparition de donnée.

• Calcul du hashCode de chaque attribut utile (ceux utilisés dans la méthode equals()), ce qui revient à faire (soit
'a' l'attribut) :

• Pour un boolean, renvoyer 0 ou 1 (a ? 0 : 1)


• Pour type entier (byte, char, short ou int) il suffit de prendre la valeur entière (avec un cast éventuel) :
(int)a;
• Pour un type long, le convertir en int en déplacant les bits : (int) (a^(a>>>32))
• Pour le type float, on le convertit en int avec la méthode Float.floatToIntBits(a).
• Pour le type double, on le convertit en long avec la méthode Double.doubleToLongBits(a), puis on effectue le
même traitement que pour les long.
• Pour les objets, on se contentera d'utiliser la méthode hashCode(), ou d'utiliser zéro si la référence est null :
(object==null ? 0, object.hashCode())
• Pour un tableau, on traitera tous les éléments de ce dernier en respectant les règles ci dessus.

Et enfin on ajoute chacun des hashCodes calculés au résultat, après l'avoir multiplié par le nombre "multiplieur".

Ce qui pourrait donner (pour la classe en exemple dans la question précédente) :

public int hashCode() {


// On choisit les deux nombres impairs
int result = 7;
final int multiplier = 17;

// Pour chaque attribut, on calcule le hashcode


// que l'on ajoute au résultat après l'avoir multiplié
// par le nombre "multiplieur" :
result = multiplier*result + attribut1;
result = multiplier*result + (attribut2==null ? 0 : attribut2.hashCode());

// On retourne le résultat :
return result;
}

Les nombres 7 et 17 ont été choisit de manière totalement arbitraire. Il est juste préférable de ne pas utiliser les mêmes
pour toutes les classes.

Enfin, la librairie Jakarta Common Lang propose également une classe HashCodeBuilder qui facilite et simplifie
l'écriture des méthodes hashCode() en se chargeant du calcul des hashCode des attributs selon leurs types, ce qui
pourrait donner dans ce cas :

public int hashCode() {


return new HashCodeBuilder(17, 37)
.append(this.attribut1)
.append(this.attribut2)
.toHashCode();

- 154 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

Pourquoi est-ce que mon application se bloque à l'éxécution d'un programme externe ?
Auteurs : le y@m's ,
Il faut consommer tous les flux dans des threads différents.

La JVM utilise deux (petit) buffer pour lire la sortie stdout et stderr du programme appellé, mais lorsque ces buffers
sont plein, le programme appellé reste bloqué sur la méthode d'écriture tant que le buffer de la JVM n'est pas vidé.

Voici un exemple complet :

Runtime runtime = Runtime.getRuntime();


final Process process = runtime.exec("monappli");

// Consommation de la sortie standard de l'application externe dans un Thread separe


new Thread() {
public void run() {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line = "";
try {
while((line = reader.readLine()) != null) {
// Traitement du flux de sortie de l'application si besoin est
}
} finally {
reader.close();
}
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
}.start();

// Consommation de la sortie d'erreur de l'application externe dans un Thread separe


new Thread() {
public void run() {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String line = "";
try {
while((line = reader.readLine()) != null) {
// Traitement du flux d'erreur de l'application si besoin est
}
} finally {
reader.close();
}
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
}.start();

lien : Comment exécuter une application externe ?

- 155 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

lien : Exécuter une application externe en Java

Comment intercepter tous les elements Throwable ?


Auteurs : adiGuba ,
Il suffit de positionner la propriété systeme sun.awt.exception.handler soit avec l'option -D de java soit avec un
System.setProperty().

Cette propriété doit contenir le nom complet d'une classe contenant une méthode :

public void handle (Throwable t);

A chaque exception non interceptée, une nouvelle instance de cette classe est créée (il faut un constructeur vide) et la
méthode handle() est appelée.

Attention : Cela ne fonctionne pas avec Java 1.5.


Dans le cadre de Java 1.5 on peut utiliser les UncaughtExceptionHandler avec la méthode
Thread.setDefaultUncaughtExceptionHandler() (voir avec setUncaughtExceptionHandler() afin de l'effectuer thread
par thread...)

Cette solution est nettement plus propre mais malheureusement elle neccessite une JVM 1.5.

Comment vérifier la validité d'une URL ?


Auteurs : romuluslepunk ,
Il faut se connecter à l'URL et vérifier le code de réponse. On voit ainsi si l'URL est valide.

import java.io.*;
import java.net.*;

publique boolean testUrl(String url) {


try {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
conn.connect();

return conn.getResponseCode() == HttpURLConnection.HTTP_OK;


} catch (MalformedURLException e) {
return false;
} catch (IOException e) {
return false;
}
}

Comment placer des commentaires javadoc ou des annotations au niveau du package ?


Auteurs : adiGuba ,
Pour définir les commentaires javadoc au niveau du package, il faut créer un fichier HTML nommé "package.html"
dans le répertoire du package. Ce fichier sera lu par l'outil javadoc pour générer la page de documentation du package,
et son contenu (entre les balises <body> et </body>) sera alors utilisé comme commentaire pour le package, par exemple :

- 156 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java

<HTML>
<BODY>
Documentation du package <b>com.masociete.monpack</b>.
@since 1.0
</BODY>
</HTML>

A partir de Java 5.0, le fichier "package.html" peut être remplacé par un fichier source java spécial nommé "package-
info.java". Ce fichier ne doit contenir que la ligne de déclaration du package, avec ses commentaires "javadoc" et
surtout ses éventuelles annotations. Par exemple :

/**
* Documentation du package <b>com.masociete.monpack</b>.
* @since 1.0
*/
@MonAnnotation
package com.masociete.monpack;

lien : The Java API Documentation Generator - Package Comment Files

Quelle est la liste des paramètres (options/arguments) de la JVM ?


Auteurs : adiGuba , Pierre Chauvin ,
La liste de toutes les options pour les versions 1.3.1 à 1.6.0 de la Java HotSpot VM (plateforme SPARC/Solaris) sont
disponibles sur le site de Sun Microsystems : A Collection of JVM Options

D'autres éléments relatifs aux options de la JVM sont disponibles aux adresses suivantes:

• Java HotSpot VM Options


• Java HotSpot Equivalents of Exact VM Flags

Il est à noter que cette liste d'options est utilisable avec la plupart des outils livrés avec le JDK tels que:

• %JAVA_HOME%\bin\javac.exe
• %JAVA_HOME%\bin\javap.exe
• %JAVA_HOME%\bin\jconsole.exe
• %JAVA_HOME%\bin\keytool.exe
• %JAVA_HOME%\bin\rmic.exe
• etc.

Il suffit pour cela d'utiliser l'option -J qui passera directement les paramètres à la Runtime Java sous-jacente.

Exemple:

C:\Program Files\Java\jdk1.6.0_02\bin>javadoc.exe -J-version


java version "1.6.0_02"
Java(TM) SE Runtime Environment (build 1.6.0_02-b06)
Java HotSpot(TM) Client VM (build 1.6.0_02-b06, mixed mode, sharing)

- 157 -
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.