Limiter le nombre de décimales d'un double

 L'exercice qui suit permet de travailler sur les chaînes de caractères.

Il s'agit de définir une méthode permettant de limiter le nombre de décimales d'un double, c'est-à-dire de tronquer la chaîne de caractères représentant le double si le nombre de décimales est supérieure à une valeur donnée.

Pour cela, on définira une classe contenant une méthode statique, la méthode tronque, ayant deux paramètres : un param&eagrave;tre de type String représentant un double x et un entier nbDecimales. La méthode devra retourner une chaîne de caractères donnant le double x éventuellement tronqué de façon à avoir au plus nbDecimales décimales. On ne cherchera pas à "arrondir au plus proche", on enlèvera simplement les décimales excédentaires, que x soit positif ou négatif.

La valeur de x et celle de nbDecimales seront transmis par la ligne de commande.

Voici quelques exemples d'exécution.

java EcritDouble 98.7689 2
98.76

java EcritDouble -0.765 1
-0.7

java EcritDouble -4.765 0
-4

Les méthode suivantes de la classe String pourraient vous servir :


charAt(int i) retourne le caractère de la chaîne concernée se trouvant en position i, la premier caractère de la chaîne étant considéré comme en position 0.
substring(int debut, int fin) : retourne la sous-chaîne constituée des caractères qui se trouvent de la position debut jusquà la position fin-1 incluse (i.e. fin excluse).
On pourra utiliser une instance de la clase java.util.StringTokenizer pour découper la chaîne représentant initialement le double en la partie qui précède le "." est celle qui le suit.
L'instruction StringTokenizer st = new StringTokenizer(chaine,"."); construt l'objet st qui permettra de découper la chaîne reçue en paramètre selon les '.' ;
L'instruction st.nextToken(); donnera au premier appel la partie de la chaîne qui précède le premier '.', au second appel la partie de la chaîne qui suit le premier '.' (et éventuellement précède le second '.'...).
L'instruction st.hasMoreTokens()) indique si la chaîne est terminée ou bien s'il reste une partie à découper.
Voici un corrigé EcritDouble.java.
/

import java.util.StringTokenizer;
public class EcritDouble
{
  static String tronque(String chaine, int nbDecimales) {
      String avant;
      String apres;

      StringTokenizer st = new StringTokenizer(chaine,"."); 
      avant = st.nextToken(); 
      if (st.hasMoreTokens()) apres = st.nextToken(); 
      else return avant;
      
     if (apres.length() <= nbDecimales) return chaine;
      return chaine.substring(0, chaine.length() - 
         apres.length() + nbDecimales);
    }

  public static void main(String[] arg) {
      if (arg.length != 2) {
   System.out.println("Il faut deux parametres");
   System.exit(0);
 }
      try {
   int nbDecimales = Integer.parseInt(arg[1]);
   if (nbDecimales < 0) throw new NumberFormatException();
   System.out.println(tronque(arg[0], nbDecimales));
 }
      catch(NumberFormatException exc) {
   System.out.println("erreur d'ecriture ; le premier parametre " + 
        "doit etre un double et le second parametre " + 
        "un entier positif ou nul");
 }
    
    }
}

/

Remarque
Le programme suivant permet aussi, en s'appuyant sur l'API, d'appprocher l'objectif de notre exercice de deux manières différentes : en utilisant la classe java.text.DecimalFormat ou, encore plus simple, en utilisant la méthode printf.

import java.text.DecimalFormat;

class Essai {
    public static void main(String[] arg) {
double d = 4.123456789;


DecimalFormat f = new DecimalFormat();
f.setMaximumFractionDigits(2);

System.out.println(d + " avec deux decimales : " + f.format(d));

System.out.printf("et aussi\n%f avec deux decimales : %.2f\n", d, d);
    }
}
La sortie est :
4.123456789 avec deux decimales : 4.12
et aussi 4.123457 avec deux decimales : 4.12