Tableaux

images/whitebelt.png

Un tableau est un objet dont le type est créé dynamiquement par le système. Les variables membres sont toutes du même type (type des composants du tableau) et sont accédées par un index (au lieu d'être accédées par un nom).

La taille du tableau ne fait pas partie du type. Chaque instance a sa taille propre taille (immuable) qui est déterminée au moment de l’allocation en mémoire. Une taille de zéro est possible.

Declarations, allocations et utilisations de tableaux. 

   char[] charTab ; //declarations
   String[] strings ;

   charTab = new char[20] ; // allocations
   strings = new String[3] ;

   // initialisations : index commence à  0
   charTab[0] = 'A'; charTab[1] = 'B' ; // ... ainsi de suite
   strings[0] = "Klaatu" ;
   strings[1] = "barada" ;
   strings[2] = "nikto" ;

On peut déclarer des tableaux de scalaires (tous les membres sont du même type) ou des tableaux d’objets. Physiquement ces derniers sont des tableaux de références

Les index doivent être des valeurs entières (int) ou des valeurs affectables à des ints. Au moment de l’allocation un index négatif déclenche une erreur (exception) NegativeArraySizeException; au run-time un index situé hors de la plage des valeurs possibles déclenche une ArrayIndexOutOfBoundsException.

Littéraux de type tableau. 

   double[] valeurs = { 10.3, Math.PI, Double.MAX_VALUE  } ;

   String[] message = {
      "festina",
      "lente" ,
   } ;

   Versement[] paiements = {
      new Versement(7.,"EUR"),
      new Versement(6.9 , "GBP")
   } ;

   Personnage[] acte2scene2 = { romeo, juliette} ;
   // romeo et juliette sont des instances de la classe Personnage

Dans cette notation on peut avoir ou non une virgule après le dernier élément du tableau.

Allocation des tableaux en mémoire:

schema: tableaux en mémoire

[Note]

La notation littérale qui réalise une déclaration/allocation/initialisation ne peut être ventilée sur plusieurs instructions :

int[] tb ;
// ....
tb = {1, 2, 3 } ; // ILLEGAL

on peut toutefois écrire :

tb = new int[] {1, 2, 3} ;

Cette notation est en fait utilisée pour passer des paramètres:

char charA, charB, charC ;
// ...
String st = new String(new char[] { charA, charbB, charC }) ;

Accès aux membres d’un tableau. 

   Versement transfert = paiements[0] ; // lecture
   paiement[0] = transfert2 ; //écriture
   paiement[1] = null ; // légal
   // la longueur du tableau
   int nombreDeMots = message.length ; // immuable

On ne peut pas changer la taille d’un tableau en mémoire (mais on peut changer sa référence en la faisant désigner un autre tableau du même type).

   valeurs = java.util.Arrays.copyOf(valeurs,10) ; // crée un nouveau tableau en mémoire
   String vals = java.util.Arrays.toString(valeurs) ;

La classe java.util.Arrays fournit un ensemble de services (statiques) sur les tableaux et, en particulier, des opérations qui sont ventilées sur les membres: equals, toString, hashCode

Tableaux de tableaux

images/bluebelt.png

Il est possible de définir des tableaux de tableaux:

   String[][] tabProps = new String[7][2];
   String[] ligne1 = tabProps[1] ; // dimension 2
   Object[][] listRessource = {
      { "err" , new ImageIcon("erreur.gif")} ,
      { "ERR" , new ImageIcon("terreur.gif")} ,
   } ;
   int[][] tbInt = {
      { 1, 2 ,3 } ,
      { 4 } ,
      { 5, 6 } ,
   }; // non rectangulaire!
   int taille = tbInt[1].length ; // -> 1

   int[][] tb = {
      { 1, 2 ,3 } ,
      {  } ,
      { 5, 6 } ,
   }; //  un élément de dimension 0
   int nb = tb[1].length ; // -> 0

Ces tableaux "à plusieurs dimensions" ne sont pas nécessairement rectangulaires puisqu’il s’agir en fait de tableaux de tableaux. L’allocation peut d’ailleurs être partielle :

int[][][] tb = new int[3][2][] ; // deux dimensions allouées

Le nombre maximum de dimensions dépend de l’implantation (en général 255).

Les services de java.util.Arrays s’appliquent en général sur une seule dimension mais on peut utiliser des méthodes qui travaillent "en profondeur" : deepHashCode, deepEquals, deepToString

[Note]Détail

images/brownbelt.png

Bien que non recommandée une notation historique inspirée du langage C est reconnue:

int tbInt[] ;

Cela peut conduire à des notations mixtes particulièrement exotiques! (et à éviter absolument).

int[] tb, tbInt, tb2Dims[] ; // tb2Dims est à deux dimensions

Compatibilités entre types tableaux

images/whitebelt.png

Bien qu’un int soit affectable à un double on ne peut pas affecter un tableau de int à un tableau de double.

Nous verrons ultérieurement le cas de compatibilités de tableaux d’objets.

--exercices--