B.6  Quelques classes de bibliothèque

• Package java.lang, bibliothèque « standard »
• Package java.io, entrées-sorties
• Package java.util : trucs utiles

En général une bibliothèque (library) est un regroupement de code suffisamment structuré et documenté pour que d’autres programmeurs puissent s’en servir. La bibliothèque associée à un langage de programmation est diffusée avec le compilateur, système d’exécution etc. La majeure partie de des programmes disponibles dans la bibliothèque d’un langage est normalement écrite dans ce langage lui-même.

La première source de documentation des classes de la bibliothèque de Java est bien entendu la documentation en ligne de cette dernière, ou comme on dit la Application Programmer Interface Specification. Nous donnons donc des extraits de cette documentation assortis de quelques commentaires personnels. Cette section entend surtout vous aider à prendre la bonne habitude de consulter la documentation du langage que vous utilisez. En particulier, la version web du polycopié comporte des liens vers la documentation en ligne.

On objectera que la bibliothèque est énorme. Mais en pratique on s’y retrouve assez vite :

• La documentation en ligne est organisée de façon systématique, La page d’accueil est une liste de liens vers les pages des packages, la page d’un package est une liste de liens vers les pages des classes, qui contiennent (au début) une liste de liens vers les champs, méthodes etc.
• Les classes que nous utilisons appartiennent à trois packages seulement.
• Les descriptions sont parfois un peu cryptiques (car elles sont complètes), mais on arrive vite à en extraire l’essentiel.

Il est vain d’objecter que la documentation est en anglais. C’est comme ça.

B.6.1  Package java.lang, bibliothèque « standard »

Ce package regroupe les fonctionnalités les plus basiques de la la bibliothèque. Il est importé par défaut (pas besoin de import java.lang.*).

B.6.1.1  Classes des scalaires

À chaque type scalaire (int, char etc.), correspond une classe (Integer, Character etc.) qui permet surtout de transformer les scalaires en objets. Une transformation que le compilateur sait automatiser (voir 2.2.3).

Prenons l’exemple de la classe Integer le pendant objet du type scalaire int. Deux méthodes permettent le passage d’un scalaire à un objet et réciproquement.

• La méthode valueOf transforme le scalaire en objet.
    public static Integer valueOf(int i)
• La méthode réciproque intValue extrait le int caché dans un objet Integer.
    public int intValue()

La classe Integer a bien d’autres méthodes, comme par exemple

• La méthode parseInt permet de « lire » un entier.
    public static int parseInt(String s) throws NumberFormatException
  Si la chaîne s contient la représentation décimale d’un entier, alors parseInt renvoie cet entier (comme un int). Si la chaîne s ne représente pas un int, alors l’exception NumberFormatException est lancée.

B.6.1.2  Un peu de maths

Les fonctions mathématiques usuelles sont définies dans la classe Math. Il n’y a pas d’objets Math. Cette classe ne sert qu’à la structuration. Elle offre des méthodes (statiques).

• La valeur absolue abs, disponible en quatre versions.
    public static int abs(int a)
    public static long abs(long a)
    public static float abs(float a)
    public static double abs(double a)
• Les fonctions maximum et minimum, max et min, également disponibles en quatre versions.
    public static int max(int a, int b)
    public static int min(int a, int b)
    ⋮
• Les divers arrondis des double, par défaut floor, par excès ceil et au plus proche round.
    public static double floor(double a)
    public static double ceil(double a)
    public static long round(double a)
  On note que floor et ceil renvoient un double. Tandis que round renvoie un long. Les méthodes existent aussi pour les float et round(float a) renvoie un int. Cela peut sembler logique si on considère que les valeurs double et long d’une part, et float et int d’autre part occupent le même nombres de bits (64 et 32). Mais en fait ça ne règle pas vraiment le problème des flottants trop grands pour être arrondis vers un entier (voir la documentation).
• Et bien d’autres méthodes, comme la racine carrée sqrt, l’exponentielle exp, le logarithme naturel log, etc.

B.6.1.3  Les chaînes

Les chaînes sont des objets de la classe String. Une chaîne est tout simplement une séquence finie de caractères. En Java les chaînes sont non-mutables : on ne peut pas changer les caractères d’une chaîne. Les chaînes sont des objets normaux, à un peu de syntaxe spécialisée près. Les constantes chaînes s’écrivent entre doubles quotes, par exemple "coucou". Si on veut mettre un double quote « " » dans une chaîne, il fait le citer en le précédant d’une barre oblique inverse (backslash). System.err.print("Je suis un double quote : \"") affiche Je suis un double quote : " sur la console. En outre, la concaténation de deux chaînes s₁ et s₂, s’écrit avec l’opérateur + comme s₁+s₂.

Les autres opérations classiques sur les chaînes sont des méthodes normales.

• La taille ou longueur d’une chaîne s, c’est-à-dire le nombre de caractères qu’elle contient s’obtient par s.length()
    public int length()
• Le caractère d’indice index s’extrait par la méthode charAt.
    public char charAt(int index)
  Comme pour les tableaux, les indices commencent à zéro.
• On extrait une sous-chaîne par la méthode substring.
    public String substring(int beginIndex, int endIndex)
  beginIndex est l’indice du premier caractère de la sous-chaîne, et endIndex est l’indice du caractère qui suit immédiatement la sous-chaîne. La longueur de la sous-chaîne extraite est donc endIndex-beginIndex. Si le couple d’indices ne désigne pas une sous-chaîne l’exception IndexOutOfBoundsException est lancée. Les règles de définition du couple d’indices désignant une sous-chaîne valide (voir la documentation) conduisent à la particularité bien sympathique que s.substring(s.length(), s.length()) renvoie la chaîne vide "".
• La méthode equals est l’égalité structurelle des chaînes, celle qui regarde le contenu des chaînes.
    public boolean equals(Object anObject)
  Il faut remarquer que l’argument de la méthode est un Object. Il faut juste le savoir, c’est tout. La classe String étant une sous-classe de Object (voir B.2.3), la méthode s’applique en particulier au seul cas utile d’un argument de classe String.
• La méthode compareTo permet de comparer les chaînes.
    public int compareTo(String anotherString)
  Compare la chaîne avec une autre selon l’ordre lexicographique (l’ordre du dictionnaire). L’appel « s₁.compareTo(s₂) » renvoie un entier r avec :
  • r < 0, si s₁ est strictement inférieure à s₂.
  • r = 0, si les deux chaînes sont les mêmes.
  • r > 0, si s₁ est strictement plus grande t s₂.
  L’ordre sur les chaînes est induit par l’ordre des codes des caractères, ce qui fait que l’on obtient l’ordre du dictionnaire stricto-sensu seulement pour les mots sans accents.
• Il y a beaucoup d’autres méthodes, par exemple toLowerCase et toUpperCase pour minusculer et majusculer.
    public String toLowerCase()
    public String toUpperCase()
  Cette fois-ci les caractères accentués sont respectés.

B.6.1.4  Les fabricants de chaînes

On ne peut pas changer une chaîne, par exemple changer un caractère individuellement. Or, on veut souvent construire une chaîne petit à petit, on peut le faire en utilisant la concaténation mais il y a alors un prix à payer, car une nouvelle chaîne est créée à chaque concaténation. En fait, lorsque l’on construit une chaîne de gauche vers la droite (pour affichage d’un tableau par ex.) on a besoin d’un autre type de structure de données : le StringBuilder (ou StringBuffer essentiellement équivalent). Un objet StringBuilder contient un tampon de caractère interne, qui peut changer de taille et dont les éléments peuvent être modifiés. Les membres les plus utiles de cette classe sont :

• Le constructeur sans argument.
  public StringBuilder ()
  Crée un nouveau fabricant dont le tampon a la capacité initiale par défaut (16 caractères).
• Les méthodes append surchargées. Il y en a treize, six pour les scalaires, et les autres pour divers objets.
  public StringBuilder append(int i)
  public StringBuilder append(String str)
  public StringBuilder append(Object obj)
  Toutes ces méthodes ajoutent la représentation sous forme de chaîne de leur argument à la fin du tampon interne, dont la capacité est augmenté silencieusement si nécessaire. Dans le cas de l’argument objet quelconque (le dernier), c’est la chaîne obtenue par obj.toString() qui est ajoutée, ou "null" si obj est null. Les autres méthodes sont là, soit pour des raisons d’efficacité (cas de String), soit pour les tableaux dont le toString() est inutilisable, soit parce que l’argument est de type scalaire (cas de int). Toutes les méthodes append renvoient l’objet StringBuilder dont on appelle la méthode, ce qui est absurde, cet objet restant le même. Je crois qu’il en est ainsi afin d’autoriser par exemple l’écriture sb.append(i).append(':') ; au lieu de sb.append(i) ; sb.append(':') ; (où i est une variable par exemple de type int).
• Et bien évidemment, une méthode toString redéfinie.
  public String toString()
  Copie le contenu du tampon interne dans une nouvelle chaîne. Contrairement aux tampons de fichier, le tampon n’est pas vidé. Pour vider le tampon, on peut avoir recours à la méthode setLength avec l’argument zéro.

On trouvera un exemple d’utilisation classique d’un objet StringBuilder en 1.2.1 : une création, des tas de append(…), et un toString() final.

B.6.1.5  La classe System

Cette classe System est un peu fourre-tout. Elle posssède trois champs et quelques méthodes assez utiles.

• Les trois flux standards.
    public static final InputStream in
    public static final PrintStream out
    public static final PrintStream err
  Ces trois flux sont des flux d’octets (voir la section sur les entrées-sorties B.5). Notez que les champs sont déclarés final, on ne peut donc pas les changer (bizarrement il existe quand même des méthode pour changer les trois flux standard). Les deux flux de sortie offrent des sorties formatées par une méthode print bien pratique, car elle est surchargée et fonctionne pour toutes les valeurs.

  La sortie out est la sortie normale du programme, tandis que la sortie err est la sortie d’erreur. En fonctionnement normal ces deux flux semblent confondus car aboutissant tous deux dans la même fenêtre. Mais on peut rediriger la sortie out, par exemple vers un fichier (>fichier). Les messages d’erreurs s’affichent alors au lieu de se mélanger avec la sortie normale du programme dans fichier.

• Une méthode pour arrêter imédiatement le programme.
    public static void exit(int status)
  L’entier status est le code de retour qui vaut conventionellement zéro dans le cas d’une exécution normale, et autre chose pour une exécution qui s’est mal passée, En Unix, le code est accessible juste après l’exécution comme $status ou $?, selon les shells.
• Deux méthodes donnent accès à un temps absolu. La seconce permet de mesurer le temps d’exécution par une soustractions.
    public static long currentTimeMillis()
    public static long nanoTime()
  La méthode currentTimeMillis renvoie les milisecondes écoulées depuis le 1^er janvier 1970. Il s’agit donc du temps ordinaire. La méthode nanoTime() renvoie les nanosecondes (10⁻⁹) depuis une date arbitraire. Il s’agit du temps passé dans le code du programme, ce qui est différent du temps ordinaire — surtout dans un système d’exploitation multi-tâches comme Unix.

B.6.2  Package java.io, entrées-sorties

Ce package regroupe s’attaque principalement à la communication avec le système de fichiers de la machine. Nous ne passons en revue ici que les flux de caractères, qui correspondent aux fichiers texte (voir B.5).

B.6.2.1  Classe des lecteurs

Les objets de la classe Reader sont des flux de caractères ouverts en lecture. Un tel flux est simplement une séquence de caractères que l’on lit les un après les autres, et qui finit par se terminer.

• La méthode la plus significative est donc celle qui permet de lire le caractère suivant du flux.
  public int read() throws IOException
  Cette méthode renvoie un int qui est le caractère en attente dans le flux d’entrée, ou −1, si le flux est terminé. On notera que read renvoie un int et non pas un char précisément pour pouvoir identifier la fin du flux facilement. En outre et comme annoncé par sa déclaration elle peut lever l’exception IOException en cas d’erreur (possible dès que l’on s’intéresse au fichiers).
• Quand la fin d’un flux est atteinte, il faut fermer le flux.
  public void close() throws IOException
  Cette opération libère les ressources mobilisées lors de la création d’un flux d’entrée (numéros divers liées au système de fichiers, tampons internes). Si on ne ferme pas les fluxs dont on ne sert plus, on risque de ne pas pouvoir en ouvrir d’autres, en raison de l’épuisement de ces ressources.

La classe Reader sert seulement à décrire une fonctionnalité et il n’existe pas à proprement parler d’objets de cette classe.

En revanche, il existe diverses sous-classes (voir B.2.3) de Reader qui permettent de construire concrètement des objets, qui peuvent se faire passer pour des Reader. Il s’agit par entre autres des classes StringReader (lecteur sur une chaîne), InputStreamReader (lecteur sur un flux d’octets) et FileReader (lecteur sur un fichier). On peut donc par exemple obtenir un Reader ouvert sur un fichier /usr/share/dict/french par

et un Reader sur l’entrée standard par

B.6.2.2  Lecteur avec tampon

Un objet BufferedReader est d’abord un Reader qui groupe les appels au flux sous-jacent et stocke les caractères lus dans un tampon, afin d’améliorer les performances (voir B.5.4). Mais un BufferedReader offre quelques fonctionnalités en plus de celles des Reader.

• Le constructeur le plus simple prend un Reader en argument.
  public BufferedReader(Reader in)
  Construit un flux d’entrée bufferisé à partir d’un lecteur quelconque.
• La classe BufferedReader est une sous-classe de la classe Reader de sorte qu’un objet BufferedReader possède une méthode read.
    public int read() throws IOException
  Cette méthode n’est pas héritée mais redéfinie, afin de gérer le tampon interne.
• La lecture d’une ligne se fait par une nouvelle méthode, que les Reader ne possèdent pas.
  public String readLine() throws IOException
  Renvoie une ligne de texte ou null en fin de flux. La méthode fonctionne pour les trois conventions de fin de ligne ('\n', '\r' ou '\r' suivi de '\n') et le ou les caractères « fin de ligne » ne sont pas renvoyés. La méthode fonctionne encore pour la dernière ligne d’un flux qui ne serait pas terminée par une fin de ligne explicite.

B.6.3  Package java.util : trucs utiles

B.6.3.1  Les sources pseudo-aléatoires

Une source pseudo-aléatoire est une suite de nombres qui ont l’air d’être tirés au hasard. Ce qui veut dire que les nombres de la suite obéissent à des critères statistiques censés exprimer le hasard (et en particulier l’uniformité, mais aussi un aspect chaotique pas évident à spécifier précisément). Une fois la source construite (un objet de la classe Random), diverses méthodes permettent d’obtenir divers scalaires (int, double, etc.) que l’on peut considérer comme tirés au hasard. On a besoin de tels nombres « tirés au hasard » par exemple pour réaliser des simulations (voir 2.1.1) ou produire des exemples destiner à tester des programmes.

• Les constructeurs.
    public Random()
    public Random(long seed)
  La version avec argument permet de donner une semence de la source pseudo-aléatoire, deux sources qui ont la même semence se comportant à l’identique. La version sans argument laisse la bibliothèque choisir une semence comme elle l’entend. La semence choisie change à chaque appel du constructeur et on suppose qu’elle est choisie de façon la plus arbitraire et non-reproductible possible (par exemple à partir de l’heure qu’il est).
• Les nombres pseudo-aléatoires sont produits par diverses méthodes « next ». Distinguons particulièrement,
  • Un entier entre zéro (inclus) et n (exclu).
      public int nextInt(int n)
    Cette méthode est pratique pour tirer un entier au pseudo-hasard sur un intervalle [a…b[, par a + rand.nextInt(b-a).
  • Un flottant entre 0.0 (inclus) et 1.0 (exclu).
      public float nextFloat()
      public double nextDouble()
    Ces méthodes sont pratiques pour décider selon une probabilité quelconque. Du style rand.nextDouble() < 0.75 vaut true avec une probabilité de 75 %.