Skip to content

Latest commit

 

History

History
481 lines (276 loc) · 23.6 KB

tableaux_initialisation.rst

File metadata and controls

481 lines (276 loc) · 23.6 KB
.. author::

    Marie-Marie van der Beek, Pablo Gonzalez Alvarez, Antoine Habran

Les Tableaux

Initialiser un tableau

Un tableau est une structure de données que l'on peut représenter par un nombre de cases. Chaque case peut contenir une donnée de type primitif (boolean, int, ...) ou un objet (vous verrez plus en détails les objets dans une section ultérieure). Par exemple on peut stocker des entiers dans un tableau de int.

Un tableau est caractérisée par sa taille, qui est le nombre de cases pouvant contenir chacune une donnée et par le type de données qu'elles contiennent. La taille d'un tableau A est donnée par A.length. Cette taille ne pourra plus être changée après que le tableau est créé. En Java, un tableau contient que des éléments du même type.

Représentation d'un tableau

Voici la syntaxe pour initialiser un tableau vide contenant des données de type TYPE et ayant une taille TAILLE :

TYPE[] nom = new TYPE[TAILLE];  // (1)

On peut aussi écrire l'initialisation comme :

TYPE nom[] = new TYPE[TAILLE]; // (2)

Par simplicité, on utilisera par la suite la syntaxe en (1).

Pour remplir ce tableau de données, on utilise l'indice de la case que l'on veut remplir. L'indice d'une donnée est le numéro de la case du tableau qui contient cette donnée. L'indice commence à 0 et va jusqu'à TAILLE-1, c'est-à-dire que la première case est à l'indice 0, la deuxième à l'indice 1, ..., et la dernière à l'indice TAILLE-1.

nom[INDICE] = VALEUR;

Il est également possible d'initialiser un tableau non-vide de taille n contenant un ensemble d'éléments de type TYPE E0, E1, ..., En :

TYPE[] nom = {E0, E1, ..., En};

Les deux exemples suivants sont donc équivalents :

int[] tab = {11, 12, 13}; // le tableau tab est un tableau de 3 éléments, le premier est 11, le deuxième est 12, le troisième est 13
int[] tab = new int[3];
tab[0] = 11; // le premier élément du tableau tab devient 11
tab[1] = 12; // le deuxième élément du tableau tab devient 12
tab[3] = 13; // le troisième élément du tableau tab devient 13

Modifie le code suivant pour créer un tableau vide de taille 10 :

/*
 * Un programme qui initialise un tableau vide de 5 entiers
 */
 public class Tableau {
     public static void main (String[] args) {
         // affiche à l’écran
         int[] tab = new int[5];
     } // fin de main
 } // fin de la classe Tableau

Par défaut, si aucune valeur n'est assignée au cases d'un tableau, Java initialise les valeurs du tableau en fonction du type de données. On dira que le tableau est vide. Voici un tableau des valeurs par défaut en fonction de quelques type de données :

Tableaux de Valeurs par défaut
int 0
float 0.0f
boolean false
char '\u0000'
String null

Pour plus de détails, se référer à la Javadoc [1].

[1]https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.5

QCM

Question 1 - Définition d'un tableau Java

Un tableau Java est :

  • Une structure de données indexée

Good job!

  • Un tableau blanc sur lequel on dessine des cases au feutre

Donner une définition plus précise.

  • Un tableau noir sur lequel on dessine des cases à la craie

Donner une définition plus précise.

Question 2 - Initialiser un tableau Java

Cocher les cases correctes :

  • int[] tab = new int[100];

    Good job!

  • int tab[] = new int[100];

    Good job!

  • int[] tab = new int[100]

    il manque un ``;``

  • int[] tab = int[100];

    il manque le mot-clef ``new``

  • int tab = int[100];

    il manque des crochets

  • int []tab = new int[100];

    Les crochets sont mal placés

  • int tab[] = new int[100]

    il manque un ``;``

  • int tab[] = int[100];

    il manque le mot-clef ``new``

Question 3 - Index dans un tableau Java

On initialise le tableau suivant :

String tab[] = {1, 2, 3}

Quelle elle la valeur de tab[0]?

  • Aucune des autres valeurs proposées

Good job!

  • 0
  • 1
  • 2
  • 3

Il manque un ;

Question 4 - Déclaration de tableaux

Parmi les déclarations suivantes, quelle est celle qui permet de déclarer correctement un tableau dont la référence est dénommée tab et qui peut contenir 5 nombres entiers ?

  • int[] tab = new int[5];

    C'est la déclaration la plus courante pour un tableau d'entiers. Notez que cette ligne combine une déclaration (int[] tab et la création du tableau correspondant permettant de stocker 5 éléments de type int.

  • int[] tab;
tab = new int[5];

    La première ligne déclare que tab est une référence vers un tableau d'entiers. La deuxième ligne associe cette référence à un tableau permettant de stocker 5 entiers.

  • tab = int [5];

    Cette ligne est incorrecte. tab n'a pas été déclaré préalablement et il faut utiliser le mot clé new pour initialiser un tableau.

  • tab = new int[5];

    Cette ligne est incorrecte. tab n'a pas été déclaré préalablement. Il faut faire précéder cette ligne d'une déclaration de tab.

  • int[] tab = new int[];

    Cette ligne est incorrecte. Lorsque l'on initialise un tableau, il faut spécifier le nombre d'éléments du tableau entre [] dans le membre de droite. En Java, les tableaux ont une taille fixe qui est définie à leur création.

  • int[5] tab = new int[];

    Cette ligne est incorrecte. Lorsque l'on initialise un tableau, il faut spécifier le nombre d'éléments du tableau entre [] dans le membre de droite. En Java, les tableaux ont une taille fixe qui est définie à leur création.

  • int tab[5] = new int[];

    Cette ligne est incorrecte. Lorsque l'on initialise un tableau, il faut spécifier le nombre d'éléments du tableau entre [] dans le membre de droite.

Question 5 - Initialisation de tableaux

Laquelle des lignes ci-dessous déclare un tableau contenant trois nombres réels et l'initialise avec les valeurs -1.0, 0.0 et 1.0.

  • double[] t = new double[] {-1.0, 0.0, 1.0};

    Cette ligne est correcte. Le livre la préfère à la ligne double[] t = { -1.0, 0.0, 1.0}; même si les deux sont équivalentes pour Java.

  • double[] t = {-1.0, 0.0, 1.0};

    Cette ligne est correcte. Le livre préfère la ligne double[] t = new double[] { -1.0, 0.0, 1.0}; qui est plus explicite même si les deux sont équivalentes pour Java.

  • double[3] t = {-1.0, 0.0, 1.0};

    En Java, il n'existe pas de type double[3] pouvant être mis dans une déclaration.

  • double t = {-1.0, 0.0, 1.0};

    En Java, double t déclare un réel et non un tableau de réels.

  • double[] t = new double[-1.0, 0.0,1.0];

    Cette ligne n'est pas syntaxiquement correct.

  • double[] t = new double{-1.0,0.0,1.0};

    Cette ligne n'est pas syntaxiquement correcte.

  • double[] t = [-1.0, 0.0, 1.0];

    Cette ligne n'est pas syntaxiquement correcte. Ne confondez pas { et [.

Question 6 - Initialisation de tableaux

Une fois qu'un tableau a été déclaré et initialisé, il faut parfois pouvoir connaître le nombre d'éléments se trouvant dans le tableau. Lequel des codes ci-dessous affiche-t-il le nombre d'entiers dans le tableau tab déclaré via int[] tab = new int[]{1,2,7,9,3,99,-12,78,119} ?

  • System.out.println(tab.length);
  • System.out.println(tab.length());

    En Java, la syntaxe tab.length() correspond à l'exécution de la méthode length() sur l'objet dont la référence est tab. Les tableaux Java ne sont pas des objets ayant des méthodes que l'on peut appeler.

  • System.out.println(tab.size);

    tab.size n'existe pas.

  • System.out.println(tab[0]);

    tab[0] est le premier élément du tableau tab et non le nombre d'éléments présents dans le tableau.

  • System.out.println(tab.[length]);

    Cette ligne est syntaxiquement incorrecte.

Vérifiez vos réponses

.. author::

    Marie-Marie van der Beek, Pablo Gonzalez Alvarez