FAQ JavaConsultez toutes les FAQ

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

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.

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 ?

L'accès au presse-papier se fait grâce à la classe java.awt.datatransfer.Clipboard disponible dans la boite à outils (java.awt.Toolkit).

/** 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 */
} 

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.

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

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

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

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 :

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

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

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

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.

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.

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

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/