Java 1.5 - Tiger 5.0 et supérieur

Chapitres traités    Classe Scanner Importation statique Nouveauté sur la boucle for Exemple récapitulatif Enveloppe d'objets et autoboxing Mise en forme de l'affichage - printf() Méthodes ayant un nombre variable de paramètres

Dans cette étude, nous allons voir quelques nouveautés qu'apporte la nouvelle version du langage Java, dénommée Tiger. La particularité de cette version, c'est qu'elle apporte des nouveautés au niveau du langage lui-même, et également, comme d'habitude, propose de nouvelles classes intéressantes. Dans ce chapitre, nous allons voir quelques unes de ces nouveautés qui vont nous simplifier la tâche de façon appréciable.

Classe Scanner

Nous avons pu constater combien il est facile d'afficher des informations sur l'unité de "sortie standard - System.out" (par défaut, la fenêtre de la console) en appelant System.out.println(). Bizarrement, avant le JDK 5.0 (ou 1.5), il n'existait aucune méthode commode pour lire des entrées depuis la fenêtre de la console. Heureusement, cette situation vient d'être rectifiée.

La lecture d'une entrée au clavier s'effectue en construisant un Scanner attaché sur l'unité "entrée standard - System.in" :

Scanner clavier = new Scanner(System.in);

Les diverses méthodes de la classe Scanner permettent ensuite de lire les entrées. Par exemple, la méthode nextLine() permet de lire une ligne de saisie complète :

System.out.print("Quel est ton nom ? ");
String nom = clavier.nextLine();

Ici, nous utilisons la méthode nextLine() car la saisie pourrait contenir des espaces. Pour lire un seul mot (délimité par des espaces), appelez :

System.out.print("Quel est ton prénom ? ");
String prénom = clavier.next();

Pour lire un entier, utilisez la méthode nextInt() :

System.out.print("Quel est ton âge ? ");
int âge = clavier.nextInt();

Penser à importer le paquetage java.util.* ; ou java.util.Scanner ;
.

package clavier;

import java.util.*;
import static java.lang.System.*;

public class Clavier {
   public static void main(String[] args) {
      Scanner saisie = new Scanner(in);
      out.print("Entier : ");
      int entier = saisie.nextInt();
      saisie.useLocale(Locale.US);
      out.println("Réel : ");
      double réel = saisie.nextDouble();
      out.println("Entier = "+entier);
      out.println("Réel = "+réel);
  }
}

Attention pour la saisie des nombres réels. En france, nous devons taper par exemple "12,5" au lien de "12.5". Si vous désirez effectuer la saisie avec le point comme séparateur de la partie entière avec la partie décimale, vous devez changer de localité afin que cela soit considéré comme nombre réel écrit sous la forme US (USA). Utilisez pour cela la méthode useLocale() en spécifiant l'argument Locale.US (par défaut : Locale.FRENCH).

Importation statique

Depuis le jdk 5.0 l'importation import a été amélioré de manière à permettre l'importation de méthodes et de champs statiques, et non plus simplement des classes.

Par exemple, si vous ajoutez la directive :

import static java.lang.System.*;

en haut de votre fichier source, vous pouvez utiliser les méthodes et les champs statiques de la classe System, sans préfixe du nom de classe :

out.print("Quel est ton âge ? "); // c'est-à-dire System.out.print()
exit(0); // c'est-à-dire System.exit

Vous pouvez également importer une méthode ou un champ spécifique :

import static java.lang.System.out;
print("Quel est ton âge ? "); // c'est-à-dire System.out.print()

Dans la pratique, il semble douteux que de nombreux programmeurs souhaitent abréger System.out ou System.exit. Le résultat peut être moins clair. Mais il existe des utilisations pratiques des imports statiques.

Par exemple, si vous utilisez un import statique pour la classe Math, vous pouvez utiliser des fonctions mathématiques d'une manière plus naturelle. Par exemple :

sqrt(pow(x, 2) + pow(y, 2))

semble plus clair que :

Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))

Nouveauté sur la boucle for

Le JDK 5.0 a introduit une construction de boucle performante qui vous permet de parcourir chaque élément d'un tableau (ainsi que d'autres collections d'éléments) sans avoir à vous préoccuper des valeurs d'indice.

La boucle for améliorée :

for (variable : collection) instruction

définit la variable donnée sur chaque élément de la collection, puis exécute l'instruction (qui, bien sûr, peut être un bloc). L'expression collection doit être un tableau ou un objet d'une classe qui implémente l'interface Iterable, comme ArrayList. Par exemple :

int[] tableau = new int[10];
for (int élément : tableau) System.out.println(élément); // affiche chaque élément du tableau sur une ligne séparée.

Il est conseillé de lire cette boucle sous la forme "pour chaque élément dans tableau".

Les concepteurs du langage Java ont envisager d'utiliser des mots clés comme foreach et in. Mais cette boucle a été ajoutée avec un peu de retard au langage Java et , au final, personne n'a voulu casser un ancien code qui contenait déjà des méthodes et des variables avec les mêmes nom (comme System.in).

Bien entendu, vous pourriez obtenir le même effet avec la boucle for traditionnelle :

int[] tableau = new int[10];
for (int élément=0; élément<10; élément++) System.out.println(tableau[élément]);

Toutefois, la boucle "for each" est plus concise et moins sujette à erreur (vous n'avez pas à vous inquiéter des valeurs d'indice de début et de fin, qui sont souvent pénibles).

La variable loop de la boucle "for each" parcourt les éléments d'un tableau, et non les valeurs d'indice.
.

La boucle "for each" est une amélioration agréable de la boucle traditionnelle si vous devez traiter tous les éléments d'une collection. Il y a toutefois de nombreuses opportunités d'utiliser la boucle for traditionnelle. Vous ne voudrez pas, par exemple, parcourir la totalité de la collection ou pourriez avoir besoin de la valeur d'indice à l'intérieur de la boucle.

Exemple récapitulatif

Nous allons mettre en oeuvre un exemple très simple qui permet de montrer l'intérêt de ces trois nouveautés. Il s'agit de construire un tableau d'entier dont la taille est déterminé par l'opérateur, et nous lui demandons ensuite de compléter chacune des cases du tableau avec les valeurs de son choix. Une fois que tableau est rempli, nous proposons juste un affichage récapitulatif :

Voici le codage correspondant :

 1 package testclavier;
 2 
 3 import static java.lang.System.*;
 4 import java.util.Scanner;
 5 
 6 public class Main {
 7    public static void main(String[] args) {
 8       Scanner clavier = new Scanner(in);
 9       out.print("Nombre de cases de votre tableau : ");
10       int nombre = clavier.nextInt();
11       int[] tableau = new int[nombre];
12       for (int indice=0; indice<nombre; indice++) {
13          out.print("tableau["+indice+"] = ");
14          tableau[indice] = clavier.nextInt();
15       }
16       out.println("Récapitulatif de votre saisie :");    
17       for (int élément : tableau) out.println(élément);
18    }
19 }
20

Enveloppe d'objets et autoboxing

Il est parfois nécessaire de convertir un type primitif - comme int - en un objet. Tous les types primitifs ont une contrepartie sous forme de classe. Par exemple, il existe une classe Integer correspondant au type primitif int. Une classe de cette catégorie est généralement appelée classe enveloppe (object wrapper). Les classes enveloppes portent des noms correspondant aux types : Integer, Long, Float, Short, Byte, Character, Void et Boolean (les six premières héritent de la super classe Number). Les classes enveloppes sont inaltérables : vous ne pouvez pas modifier une valeur enveloppée, une fois l'enveloppe construite. Elles sont aussi final, vous ne pouvez donc pas en faire des sous-classes.

Supposons que nous voulions travailler sur une liste d'entiers. Nous pensons, tout de suite, utiliser la collection ArrayList<int>. Malheureusement, le paramètre de type entre les signes <> ne peut pas être un type primitif, c'est obligatoirement un objet. C'est à ce niveau là que la classe enveloppe devient intéressante. Vous pouvez ainsi déclarer une liste de tableau d'objet Integer :

ArrayList<Integer> liste = new ArrayList<Integer>() ;

Attention : un ArrayList<Integer> est bien moins efficace qu'un tableau int[] car chaque valeur est enveloppée séparément dans un objet. Vous ne devriez utiliser cette construction que pour les petites collections lorsque la commodité du programmeur est plus importante que l'efficacité.

Autoboxing

Une autre innovation du JDK 5.0 facilite l'ajout et la récupération d'éléments de tableau. L'appel :

liste.add(3);

est automatiquement traduit en :

liste.add(new Integer(3));

Cette conversion est appelée autoboxing.

Unboxing

A l'inverse, lorsque vous attribuez un objet Integer à une valeur int, il est automatiquement déballé (unboxing). En fait, le compilateur traduit :

int n = liste.get(i) ;

en

int n = liste.get(i).intValue() ;

Autoboxing et Unboxing

Les opérations d'autoboxing et d'unboxing fonctionne même avec les expressions arithmétiques. Vous pouvez, par exemple, appliquer l'opération d'incrémentation en une référence d'enveloppe :

Integer n = 3;
n++ ;

Le compilateur insère automatiquement des instructions pour déballer l'objet, augmenter la valeur du résultat et le remballer.

Dans la plupart des cas, vous avez l'illusion que les types primitifs et leurs enveloppes ne sont qu'un seul et même élément. Ils ne diffèrent considérablement qu'en un seul point : l'identité.

Enveloppes de nombres et chaînes de caractères

Vous verrez souvent les enveloppes de nombres pour une autre raison. Les concepteurs Java ont découvert que les enveloppes constituent un endroit pratique pour y stocker certaines méthodes de base, comme celles qui permettent de convertir des chaînes de chiffres en nombres.

Pour transformer une chaîne en entier, vous devez utiliser l'instruction suivante :

int x = Integer.parseInt(s) ;

Ceci n'a rien à voir avec les objets Integer ; parseInt() est une méthode statique. Mais la classe Integer constitue un bon endroit pour l'y placer. Pour transformer un entier en une chaîne représentant la suite des chiffres du nombre entier, utilisez la méthode toString() :

String chiffres = Integer.toString(324) ; // chiffres <-- "324"

Voici un exemple :

package test;

import java.util.Scanner;
import static java.lang.System.*;

public class Test {
   public static void main(String[] args) {
       Scanner clavier = new Scanner(in);
       out.print("Introduisez votre nombre entier : ");
       String chaîne = clavier.next();          
       Integer  X  = new Integer(chaîne) ;   
       int x = X;                              // ou plus rapidement : int x = clavier.nextInt();
       out.println("Valeur entière : "+x);
       out.println("Chaîne de caractère équivalente : "+X);  // équivalent à Integer.toString(x);
       out.println("Valeur binaire correspondante : "+Integer.toBinaryString(x));
   }
}

A titre d'exemple, voici la description de la classe enveloppe Integer

Mise en forme de l'affichage - printf()

public class TestPrintF {
   public static void main(String[] args) {
      Personne moi = 
   new Personne("REMY","Emmanuel", 46);
      System.out.println(moi);
      System.out.printf("%s", moi);
   }
}

class Personne {
   private String nom, prénom;
   private int âge;
   
   public Personne(String nom, 
                         String prénom, int âge) {
      this.nom = nom;
      this.prénom = prénom;
      this.âge = âge;
   }
   public String toString() {
      return prénom +' '+nom;
   }
}

L'instruction System.out.print(x) permet d'afficher un nombre x à la console. Cette instruction affichera x avec le maximum de chiffres différents de zéro (pour le type donné). Cela pose un problème si vous désirez afficher, par exemple, des €uros et des centimes.

Avant le JDK 5.0, l'affichage des nombres posait quelques problèmes. Heureusement cette nouvelle version a rapatriée la vénérable méthode printf() de la bibliothèque C. Il est possible de fournir plusieurs paramètres à la méthode printf(). En voici un exemple ci-dessous :

System.out.printf("Salut, %s. Cette année vous aurez %d ", nom, âge) ;

Chaque spécificateur de format qui commence pa le caractère % est remplacé par l'argument correspondant. Le caractère de conversion qui termine un spécificateur de format indique le type la valeur à mettre en forme : f est un nombre à virgule flottante, s une chaîne et d'une valeur décimale.

Conversion pour printf()

Voici les caractères de conversion à spécifier afin d'obtenir le résultat désiré :

Drapeaux

Vous pouvez également spécifier des drapeaux qui contrôleront l'apparence des résultats mis en forme.

Formatage de la date

Dans cette rubrique, nous allons voir brievement les options de mise en forme de la date et de l'heure au moyen de la méthode printf(). Exceptionnellement, nous utilisons un format à deux lettres commençant par t et se terminant par l'une des lettres suivantes :

Méthodes ayant un nombre variable de paramètres

Avant le JDK 5.0, chaque méthode Java disposait d'un nombre fixe de paramètres. Il est toutefois maintenant possible de fournir des méthodes qui peuvent être appelées avec un nombre variable de paramètres (quelquefois appelés méthodes "varargs").

Analyse à l'aide de la méthode printf()

Dans le chapitre précédent, nous avons déjà utilisé une telle méthode, la méthode printf(). Par exemple, les appels :

System.out.printf("Salut, %s. Cette année vous aurez %d ", nom, âge) ;

et :

System.out.printf("%,.2f", 1000.0 / 3.0) ;

appelent tous deux la même méthode, même si l'un a trois paramètres et l'autre deux. La méthode printf() est définie comme ceci :

public class PrintStream {
   public PrintStream printf(String fmt, Object... args) {
      return format(fmt, args);
   }
}

Ici, l'ellipse (...) fait partie du code Java. Elle montre que la méthode peut recevoir un nombre arbitraire d'objets (en plus du paramètre fmt).
.

La méthode printf() reçoit en fait deux paramètres, la chaîne format() est un tableau Object[] qui contient tous les autres paramètres (si l'appelant fournit des entiers ou autres valeurs de type primitif, l'autoboxing les transforme en objets). Elle dispose maintenant de la tâche non enviable d'analyser la chaîne fmt et de se conformer au spécificateur de format ith avec la valeur args[i].

Autrement dit, pour l'implémenteur de printf(), le type de paramètre Object... est exactement le même que Object[].
.

Le compilateur doit transformer chaque appel à printf(), en regroupant les paramètres dans un tableau et en procédant à l'autoboxing en fonction des besoins. Ainsi, en utilisant la méthode printf() comme ci-dessous :

System.out.printf("%d %s", n, "Bonjour" ) ;

Le compilateur transforme cet appel de la façon suivante :

System.out.printf("%d %s", new Object[] { new Integer(n), "Bonjour"}) ;

Définition de nos propres méthodes avec un nombre variable de paramètres

Vous pouvez définir vos propres méthodes avec des paramètres variables et spécifier tout type pour les paramètres, même un type primitif. Voici justement un exemple simple : une méthode max() qui calcule le maximum d'un nombre variable de valeurs réelles :

public class Calcul {
   public static void main(String[] args) {
      double m = max(3.1, 40.4, -5);
      System.out.println("Valeur maximale : "+m);
   }
   public static double max(double... valeurs) {
      double plusGrande = Double.MIN_VALUE;
      for (double v : valeurs) 
         if (v>plusGrande) 
            plusGrande = v;
      return plusGrande;
   }
}

Le compilateur transfère un nouveau double[] {3.1, 40.4, -5} à la méthode max().
.