Exemples Java : Ragged Array – InformatiKKa

Je suis un ingénieur logiciel. Je travaille avec les technologies C++, MFC et .net depuis 15 ans. J’aime les jeux vidéo et lire des livres.

En Java, « ragged array » est un « tableau de tableaux ». Cela signifie que l’on peut créer un tableau de telle manière que chaque élément du tableau soit une référence à un autre tableau du même type. Par exemple, un tableau à deux dimensions de 3 x 2 fait référence à trois lignes et deux colonnes (c’est-à-dire que chaque ligne a deux colonnes). Nous appelons cela « tableau rectangulaire ». Dans le cas d’un tableau irrégulier, le nombre de colonnes peut ne pas être fixe.

Notez que « tableau irrégulier » et « tableau irrégulier » et « tableau dimensionnel irrégulier » font tous référence à la même chose.

1. Déclarer un tableau irrégulier

Le code ci-dessous (Liste 1) déclare un tableau irrégulier :

Liste 1

//Snippet 01: Declare an 2D Irregular Array
double[][] ir_array = new double [3][];

Seigneur, ir_array est un tableau irrégulier et la dimension sur le côté droit [3][] spécifie une dimension comme fixe et une autre dimension comme inconnue. Ici, dans le code ci-dessus, nous pouvons appeler ir_array en tant que tableau unidimensionnel ou tableau double. Comme celui-ci, on peut créer un « tableau irrégulier multidimensionnel ».

2. Définition des références de tableau

Maintenant, il est temps d’allouer de l’espace pour trois tableaux de type double et de définir sa référence dans la première dimension. Le code ci-dessous (Liste 2) montre la configuration de la dimension irrégulière :

Liste 2

//Snippet 02: Now declare three arrays
ir_array[0] = new double[5];
ir_array[1] = new double[3];
ir_array[2] = new double[2];

Ici, nous avons créé trois tableaux pour stocker le double et la taille du tableau est de 5,3.2. Chaque tableau est empilé dans le tableau ir_array. Par exemple, le premier tableau double de taille 5 est stocké dans le premier slot de ir_array, et de la même manière le second tableau de taille 3 est stocké dans le second slot de ir_array et ainsi de suite.

Dans le code ci-dessus, nous avions configuré notre tableau irrégulier. Les trois emplacements (disons ceci sous forme de rangée) forment une rangée de trois et chaque rangée représente un tableau. Par exemple, ir_array[2] est la troisième ligne et représente un tableau de taille 2, qui représente les colonnes pour celui-ci. OK, remplissons ce tableau maintenant.

3. Remplir le tableau irrégulier

Jetez un oeil au code ci-dessous, qui remplit le tableau irrégulier :

Liste 3

//Snippet 03: Initialize the arrays
for (int i = 0; i < 5; i++) {
    ir_array[0][i] = (i + 1) * 10;
}

for (int i = 0; i < 3; i++) {
    ir_array[1][i] = (i + 1) * 5;
}

for (int i = 0; i < 2; i++) {
    ir_array[2][i] = (i + 1) * 2;
}

Dans le code ci-dessus, le premier tableau de double est rempli avec la valeur, qui est un multiple de 10 et les valeurs des cinq éléments sont 10,20,30,40,50. Le deuxième tableau de double est rempli avec les valeurs, qui sont multiples de 5. Le troisième tableau est rempli avec la valeur, qui est multiple de 2. Après avoir rempli le tableau, le tableau se présentera comme indiqué ci-dessous :

Faites défiler pour continuer

4. Choisir un élément de tableau en lambeaux

Une fois que le tableau irrégulier est prêt, la valeur des éléments peut être choisie comme un tableau normal. Ici, dans notre exemple, nous avons configuré un tableau irrégulier à deux dimensions, et donc pour choisir un élément de ce tableau, nous devons localiser la cellule à travers sa ligne et sa colonne. Par exemple, considérons ir_array[0][4] et ici ir_array[0] indique le premier tableau de double avec une longueur de 5 et une deuxième dimension [4] dit de localiser le cinquième élément. Considérons maintenant le code ci-dessous (Liste 4):

Liste 4

//Snippet 04: Now let us randomly take some value
// and print it.
System.out.println("ir_array[0][4] = " + ir_array[0][4]);
System.out.println("ir_array[1][2] = " + ir_array[1][2]);
System.out.println("ir_array[2][1] = " + ir_array[2][1]);

Dans l'exemple de code ci-dessus, nous avons sélectionné trois éléments du tableau en escalier et les avons affichés dans la fenêtre de sortie de la console. Les éléments sélectionnés sont présentés dans l'image ci-dessous :

5. Itérer dynamiquement tous les éléments de Ragged Array

La propriété length du tableau est utile pour itérer dynamiquement le tableau en escalier. Ici, dans le code ci-dessous, ir_array désigne le "tableau de double tableau" et sa longueur est prise et itérée en premier. Lorsque nous fournissons un index à ir-array, il représente le double tableau car dans cet index nous stockons la référence du double tableau. Lorsque nous lisons la propriété length (par exemple, ir_array[0].length), il donne la longueur du tableau double qui est itéré comme une boucle imbriquée.

Dans l'extrait de code ci-dessous, nous avons parcouru tous les éléments du tableau et imprimé le résultat dans la fenêtre de sortie de la console :

Liste 5

//Snippet 05: Iterate through the Jagged Array
System.out.println("");
System.out.println("Iterating Through the Jagged Array");
for (int arrayofArrayIndex = 0;
     arrayofArrayIndex < ir_array.length;
     arrayofArrayIndex++) {

    for (int ArrayOfDoubleIndex = 0;
         ArrayOfDoubleIndex < ir_array[arrayofArrayIndex].length;
         ArrayOfDoubleIndex++) {
        System.out.print(
                ir_array[arrayofArrayIndex][ArrayOfDoubleIndex] + " ");
    }
    System.out.println("");
}

L'exemple complet et sa sortie sont donnés ci-dessous :

package com.JavaHub;

public class Main {

    public static void main(String[] args) {
        //Snippet 01: Declare an 2D Irregular Array
        double[][] ir_array = new double [3][];

        //Snippet 02: Now declare three arrays
        ir_array[0] = new double[5];
        ir_array[1] = new double[3];
        ir_array[2] = new double[2];

        //Snippet 03: Initialize the arrays
        for (int i = 0; i < 5; i++) {
            ir_array[0][i] = (i + 1) * 10;
        }

        for (int i = 0; i < 3; i++) {
            ir_array[1][i] = (i + 1) * 5;
        }

        for (int i = 0; i < 2; i++) {
            ir_array[2][i] = (i + 1) * 2;
        }

        //Snippet 04: Now let us randomly take some value
        // and print it.
        System.out.println("ir_array[0][4] = " + ir_array[0][4]);
        System.out.println("ir_array[1][2] = " + ir_array[1][2]);
        System.out.println("ir_array[2][1] = " + ir_array[2][1]);

        //Snippet 05: Iterate through the Jagged Array
        System.out.println("");
        System.out.println("Iterating Through the Jagged Array");
        for (int arrayofArrayIndex = 0;
             arrayofArrayIndex < ir_array.length;
             arrayofArrayIndex++) {

            for (int ArrayOfDoubleIndex = 0;
                 ArrayOfDoubleIndex < ir_array[arrayofArrayIndex].length;
                 ArrayOfDoubleIndex++) {
                System.out.print(
                        ir_array[arrayofArrayIndex][ArrayOfDoubleIndex]
                                + " ");
            }
            System.out.println("");
        }
    }
}

Cet article est exact et fidèle au meilleur de la connaissance de l'auteur. Le contenu est uniquement à des fins d'information ou de divertissement et ne remplace pas un conseil personnel ou un conseil professionnel en matière commerciale, financière, juridique ou technique.

© 2018 sirama