Les FAQs Java :
FAQ JAVA FAQ Java EE FAQ Java ME FAQ Java XML FAQ JavaFX FAQ Java GUI FAQ Struts FAQ JSF FAQ JDBC JDO FAQ Hibernate FAQ Spring FAQ Eclipse FAQ NetBeans FAQ JCreator FAQ Maven 2

FAQ JavaConsultez toutes les FAQ

Nombre d'auteurs : 53, nombre de questions : 231, dernière mise à jour : 26 janvier 2014 

 
OuvrirSommaireSystème

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 :

 
Sélectionnez

String name = System.getProperty ( "os.name" );
String version = System.getProperty ( "os.version" );
Créé le 1er mars 2003  par Clément Cunin

Lien : Comment accéder aux valeurs des variables d'environnement ?

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

java.util.Enumeration liste = System.getProperties().propertyNames();
String cle;
while( liste.hasMoreElements() ) {
        cle = (String)liste.nextElement();
        System.out.println( cle + " = " + System.getProperty(cle) );
} 
Mis à jour le 3 mai 2002  par 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.

 
Sélectionnez

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.
Mis à jour le 6 mai 2002  par 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

 
Sélectionnez
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 ?

Créé le 6 août 2002  par Clément Cunin

Lien : Comment créer un jar exécutable ?

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 :

 
Sélectionnez

/** Lecture du contenu : */
Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
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 :

 
Sélectionnez

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.

Mis à jour le 20 décembre 2009  par Clément Cunin

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 :

 
Sélectionnez

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

Pour un exemple d'utilisation regardez le fichier ci-dessous.

Mis à jour le 1er mai 2008  par Ioan Calapodescu

Lien : Comment lire/écrire du texte dans le presse-papier ?

Voici une méthode permettant de récuperer la mémoire disponible (en Mo) pour la carte graphique :

 
Sélectionnez

 
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;
}
Créé le 8 septembre 2004  par Seigne David


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 :

 
Sélectionnez

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 :

 
Sélectionnez

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

Mis à jour le 12 janvier 2008  par Baptiste Wicht, adiGuba

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


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 :

 
Sélectionnez

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 :

 
Sélectionnez

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

Mis à jour le 12 janvier 2008  par Baptiste Wicht, adiGuba

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


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

Créé le 12 janvier 2008  par adiGuba

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

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:

 
Sélectionnez

    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.

Mis à jour le 29 octobre 2008  par 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).

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.

Créé le 12 octobre 2006  par bulbo

Lien : Téléchargez JavaService

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:

 
Sélectionnez
int nbProc = Runtime.getRuntime().availableProcessors();
Créé le 16 décembre 2006  par NiCo5130

Les versions antérieures des JDK, JRE, JEE et plus encores sont disponibles sur le site de SUN à l'adresse suivante :

http://www.oracle.com/technetwork/java/archive-139210.html

Créé le 16 décembre 2006  par elitost
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 © 2014 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peut 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.