Exercice Java corrigé: Opération sur les tableaux Java

Exercice Java opération sur les tableaux, tutoriel comprendre les tableaux Java.

Le programme Operations.java vous permettra d’exercer vos connaissances des tableaux de type int[] et des méthodes auxiliaires. Etudiez le fonctionnement du programme et complétez-le comme demandé ci-après.

Un tableau tab est construit et rempli de 10 valeurs. Le tableau est ensuite envoyé en paramètre à la méthode auxiliaire operations qui, à son tour, appelle 6 méthodes auxiliaires en leur envoyant le même tableau en paramètre. La première méthode, afficher, affiche les éléments du tableau sur une ligne. La deuxième méthode, operation1, calcule et affiche le nombre d’éléments de valeur 9. Les trois autres méthodes ne font rien pour l’instant, c’est à vous de les compléter.
Un deuxième tableau tab1 est construit par l’intermédiaire de la méthode auxiliaire remplir1. Les éléments sont initialisés en ordre croissant de 0 à 4. Ensuite, la méthode auxiliaire operations est appelée pour effectuer les mêmes opérations sur ce deuxième tableau.

Compléter les méthodes restantes comme suit:

remplir2: remplissage du tableau en ordre croissant à partir de 5.
remplir3: remplissage du tableau en ordre décroissant de nb à 1 où nb est le nombre d’éléments du tableau.
operation2: affichage du nombre d’éléments qui sont plus grands que 4 ou plus petits que 2.
operation3: affichage de la somme de tous les éléments du tableau.
operation4: affichage de la moyenne arithmétique de tous les d’éléments du tableau. La moyenne arithmétique est la somme de tous les éléments divisé par le nombre d’éléments. Faites attention à afficher le résultat sous forme de double.
operation5: affichage du plus grand élément du tableau.

Exemple d’exécution du programme:

3  7  1  9  2  8  9  1  2  5  
Il y a 2 éléments de valeur 9 dans le tableau
Il y a 7 éléments plus grand que 4 ou plus petit que 2
La somme des éléments est 47
La moyenne arithmétique des éléments est 4.7
Le plus grand élément vaut: 9
0  1  2  3  4  
Il y a 0 éléments de valeur 9 dans le tableau
Il y a 2 éléments plus grand que 4 ou plus petit que 2
La somme des éléments est 10
La moyenne arithmétique des éléments est 2.0
Le plus grand élément vaut: 4
5  6  7  8  9  10  11  12  13  14  
Il y a 1 éléments de valeur 9 dans le tableau
Il y a 10 éléments plus grand que 4 ou plus petit que 2
La somme des éléments est 95
La moyenne arithmétique des éléments est 9.5
Le plus grand élément vaut: 14
5  4  3  2  1  
Il y a 0 éléments de valeur 9 dans le tableau
Il y a 2 éléments plus grand que 4 ou plus petit que 2
La somme des éléments est 15
La moyenne arithmétique des éléments est 3.0
Le plus grand élément vaut: 5

Code donné:

class Operations {
    public static void main(String args[]) {
        // Construction d'un tableau:
        int[] tab = {3, 7, 1, 9, 2, 8, 9, 1, 2, 5};
        // Opérations sur le tableau:
        operations(tab);

        // La même chose pour d'autres tableaux:
        int[] tab1 = remplir1(5);
        operations(tab1);

        int[] tab2 = remplir2(10);
        operations(tab2);

        int[] tab3 = remplir3(5);
        operations(tab3);
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant de 0 à nb-1.
     * @param nb
     * @return
     */
    static int[] remplir1(int nb) {
        int[] tab = new int[nb];
        for (int i = 0; i < nb; i++) {
            tab[i] = i;
        }
        return tab;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant à partir de 5.
     * @param nb
     * @return
     */
    static int[] remplir2(int nb) {
        int[] tab = new int[nb];
        // A compléter
        return tab;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre décroissant de nb à 1.
     * @param nb
     * @return
     */
    static int[] remplir3(int nb) {
        int[] tab = new int[nb];
        // A compléter
        return tab;
    }

    static void operations(int[] tab) {
        afficher(tab);
        operation1(tab);
        operation2(tab);
        operation3(tab);
        operation4(tab);
        operation5(tab);
    }

    /**
     * Cette méthode affiche tous les éléments du tableau reçu en
     * paramètre sur une même ligne. Les éléments sont séparés par
     * deux espaces.
     * @param tab
     */
    static void afficher(int[] tab) {
        for (int i = 0; i < tab.length; i++) {
            System.out.print(tab[i]);
            System.out.print("  ");
        }
        System.out.println();    // Saut de ligne à la fin de l'affichage
    }

    /**
     * Cette méthode calcule et affiche le nombre d'éléments de valeur
     * 9 dans le tableau. La variable nb sert à compter les éléments
     * trouvés. Elle est initialisée à 0 et incrémentée dans la boucle
     * qui parcourt le tableau chaque fois que l'on trouve un 9.
     * @param tab
     */
    static void operation1(int[] tab) {
        int nb = 0;
        for (int i = 0; i < tab.length; i++) {
            if (tab[i] == 9)
                nb++;
        }
        System.out.println("Il y a " + nb + " éléments de valeur 9 dans le tableau");
    }

    /**
     * Cette méthode calcule et affiche le nombre d'éléments qui sont
     * plus grand que 4 OU plus petit que 2.
     * @param tab
     */
    static void operation2(int[] tab) {
        // A compléter
    }

    /**
     * Cette méthode calcule et affiche le somme de tous les éléments du tableau.
     * @param tab
     */
    static void operation3(int[] tab) {
        // A compléter
    }

    /**
     * Cette méthode calcule et affiche la moyenne arithmétique de
     * tous les éléments du tableau.
     * @param tab
     */
    static void operation4(int[] tab) {
        // A compléter
    }

    /**
     * Cette méthode calcule et affiche le plus grand élément du tableau.
     * @param tab
     */
    static void operation5(int[] tab) {
        // A compléter
    }
}

La correction exercices Java (voir page 2 en bas)

Pages 1 2