Programmation Java/Tableaux

Un livre de Wikibooks.

Programmation

Java

Sommaire

Introduction La notion de machine virtuelle Bases du langage Premier programme Types de base Opérateurs Commentaires Conditions Itérations Tableaux Collections Objets comparables et clés Énumérations Les classes en Java Modificateur d'accès Membres Instanciation et cycle de vie "this" Encapsulation Interfaces Héritage Polymorphisme Classes abstraites Classes internes Transtypage Types génériques Extensions/Packages Exceptions Méta-données Threads et synchronisation Classes de base Sujets connexes Conclusion

IHM avec SWING

Un premier exemple Calculer la somme de 2 entiers Calculer la distance entre 2 points

Annexes

Liste des mots réservés

Modifier ce modèle

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

[modifier] Création d'un tableau

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.

[modifier] Remplissage d'un tableau

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};

[modifier] Lecture d'un tableau

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
}

[modifier] Les tableaux en Java 5

La section précédente montre comment parcourir un tableau. Java 5 fournit un moyen plus simple.

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;
}

[modifier] Tableaux à plusieurs dimensions

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]
	}
}

[modifier] La classe Arrays

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.io.*;
public class ArrayExample 
{
    static BufferedReader kbRead = new BufferedReader(new InputStreamReader(System.in));
    public static void main(String[] args) [[Programmation Java Exceptions|throws IOException]] 
    {
        int numNames = getInt("Number of names? ");
        String[] names = new String[numNames];
        for (int i = 0; i < names.length; i++) 
        {
            names[i] = getString("Enter name #" + i);
        }
        for (int i = 0; i < names.length; ++i) 
        {
            System.out.println(names[i]);
        }
    }
    public static int getInt(String prompt) throws IOException 
    {
        System.out.print(prompt + " ");
        return Integer.parseInt(kbRead.readLine());
    }
    public static String getString(String prompt) throws IOException 
    {
        System.out.print(prompt + " ");
        return kbRead.readLine();
    }
}

[modifier] Copie d'un tableau

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 Object. 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