Programmation Java/Tableaux

Un livre de Wikilivres.
Aller à : navigation, rechercher


Wikiversity-logo.svg

La Wikiversité propose un module sur « Java/Tableaux ».

Un tableau est un ensemble indexé de données d'un même type. L'utilisation d'un tableau se décompose en trois parties :

  • Création du tableau
  • Remplissage du tableau
  • Lecture du tableau

Création d'un tableau[modifier | modifier le wikitexte]

Un tableau se déclare et s'instancie comme une classe :

int monTableau[ ] = new int[10];

ou

int [ ] monTableau = new int[10];

L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.

Dans l'instruction précédente, nous déclarons un tableau d'entiers (int, integer) de taille 10, c'est-à-dire que nous pourrons stocker 10 entiers dans ce tableau.

Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de la variable, seule celle-ci est un tableau :

int [] premierTableau, deuxiemeTableau;
float troisiemeTableau[], variable;

Dans ces quatre déclarations, seule variable n'est pas un tableau.

Remplissage d'un tableau[modifier | modifier le wikitexte]

Une fois le tableau déclaré et instancié, nous pouvons le remplir :

int [] monTableau = new int[10];
 
monTableau[5] = 23;

L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la numérotation va de 0 à N-1.

Dans l'exemple ci-dessus, la 6ème case contient donc la valeur 23.

Nous pouvons également créer un tableau en énumérant son contenu :

int [] monTableau = {5,8,6,0,7};

Ce tableau contient 5 éléments.

Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant l'opérateur new :

monTableau = new int[]{11,13,17,19,23,29};

Lecture d'un tableau[modifier | modifier le wikitexte]

Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du nom du tableau :

int [] monTableau = {2,3,5,7,11,23,17};
int nb;
 
monTableau[5] = 23;  // ->  2 3 5 7 11 23 17
nb = monTableau[4];  // 11

L'indice 0 désigne le premier élément du tableau.

L'attribut length d'un tableau donne sa longueur (le nombre d'éléments). Donc pour un tableau nommé monTableau l'indice du dernier élément est monTableau.length-1.

Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.

for (int i = 0; i < monTableau.length; i++) {
    int element = monTableau[i];
    // traitement
}

Les tableaux en Java 5[modifier | modifier le wikitexte]

Java 5 fournit un moyen plus court de parcourir un tableau.

L'exemple suivant réalise le traitement sur monTableau :

for (int element : monTableau){
   // traitement
}

Attention néanmoins, la variable element contient une copie de monTableau[i]. Avec des tableaux contenant des variables primitives, toute modification de element n'aura aucun effet sur le contenu du tableau.

// Vaine tentative de remplir tous les éléments du tableau avec la valeur 10
for(int element : monTableau){
    element=10;
}
 
// La bonne méthode :
for(int i=0; i < monTableau.length; i++){
    monTableau[i]=10;
}

Tableaux à plusieurs dimensions[modifier | modifier le wikitexte]

En Java, les tableaux à plusieurs dimensions sont en fait des tableaux de tableaux.

Exemple, pour allouer une matrice de 5 lignes de 6 colonnes :

int[][] matrice=new int[5][];
for (int i=0 ; i<matrice.length; i++)
    matrice[i]=new int[6];

Java permet de résumer l'opération précédente en :

int[][] matrice=new int[5][6];

La première version montre qu'il est possible de créer un tableau de tableaux n'ayant pas forcément tous la même dimension.

On peut également remplir le tableau à la déclaration et laisser le compilateur déterminer les dimensions des tableaux, en imbriquant les accolades :

int[][] matrice =
    {
        { 0, 1, 4, 3 } , // tableau [0] de int
        { 5, 7, 9, 11, 13, 15, 17 } // tableau [1] de int
    };

Pour déterminer la longueur des tableaux, on utilise également l'attribut length :

matrice.length     //  2
matrice[0].length  //  4
matrice[1].length  //  7

De la même manière que précédement, on peut facilement parcourir tous les éléments d'un tableau :

int i, j;
for(i=0; i<matrice.length; i++) {
	for(j=0; j<matrice[i].length; j++) {
		//Action sur matrice[i][j]
	}
}

La classe Arrays[modifier | modifier le wikitexte]

La classe Arrays du package java.util possède plusieurs méthodes de gestion des tableaux de types de base, et d'objets :

  • la méthode asList convertit un tableau en liste,
  • la méthode binarySearch effectue la recherche binaire d'une valeur dans un tableau,
  • la méthode equals compare deux tableaux (longueur et contenu),
  • la méthode fill remplit un tableau avec la valeur donnée,
  • la méthode sort trie un tableau dans l'ordre croissant de ses éléments.

Exemple de source :

import java.util.*;
 
public class ArrayExample {
 
  static Scanner input = new Scanner(System.in);
 
  public static void main(String[] args) {
    int numNoms = getInt("Nombre d'entrées du tableau ?");
    String[] noms = new String[numNoms];
    for (int i = 0; i < noms.length; i++) {
      noms[i] = getString("Entrée n°" + (i+1));
    }
    for (int i = 0; i < noms.length; ++i) {
      System.out.println(noms[i]);
    }
  }
 
  public static int getInt(String prompt) {
    System.out.print(prompt + " ");
    int entier = input.nextInt();
    input.nextLine(); // Get rid of this line
    // so that getString won't read it
    return entier;
  }
 
  public static String getString(String prompt) {
    System.out.print(prompt + " ");
    return input.nextLine();
  }
}

Copie d'un tableau[modifier | modifier le wikitexte]

La copie d'un tableau implique la copie de ses éléments dans un autre tableau. Dans le cas d'un tableau d'objets, seules les références à ces objets sont copiées, aucun nouvel objet n'est créé.

La méthode arraycopy de la classe System permet de copier tout ou partie d'un tableau vers un autre tableau déjà alloué.

Comme toutes les classes, les tableaux dérivent de la classe java.lang.Object. Les méthodes de la classe Object sont donc utilisables :

int[] premiers = { 2, 3, 5, 7, 11 };
System.out.println( premiers.toString() ); // Par défaut <type>@<hashcode>, exemple : [I@a108298c

La copie intégrale d'un tableau dans un nouveau tableau peut donc se faire en utilisant la méthode clone(). La valeur retournée par cette méthode étant de type Object, il faut la convertir dans le type concerné.

Exemple:

int[] nombres = { 2, 3, 5, 7, 11 };
int[] copie = (int[]) nombres.clone();
nombres[1]=4; // nombres contient 2 4 5 7 11
// tandis que copie contient toujours 2 3 5 7 11