Comment vérifier si un tableau ne contient que des nombres positifs en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un tableau (array) ne contient que des nombres positifs en Java. Nous explorerons différentes approches pour y parvenir, en commençant par une méthode de base utilisant une boucle pour parcourir le tableau et vérifier chaque élément individuellement.

Après la méthode de base utilisant une boucle, nous plongerons dans l'utilisation de l'API Stream de Java, une façon plus moderne et souvent plus concise de traiter les collections. Enfin, nous discuterons de la façon de gérer les zéros et les nombres négatifs dans le contexte de la détermination de si un tableau ne contient que des valeurs positives. Ce laboratoire vous offrira des compétences pratiques en manipulation de tableaux et en logique conditionnelle en Java.

Parcourir le tableau pour vérifier les nombres positifs

Dans cette étape, nous apprendrons à parcourir un tableau (array) de nombres en Java et à vérifier si chaque nombre est positif. Il s'agit d'une opération fondamentale en programmation, qui nous permet de traiter des collections de données.

Tout d'abord, créons un nouveau fichier Java nommé PositiveCheck.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant PositiveCheck.java.

Maintenant, ouvrez le fichier PositiveCheck.java dans l'éditeur et ajoutez le code suivant :

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Loop through the array
        for (int i = 0; i < numbers.length; i++) {
            // Get the current number
            int currentNumber = numbers[i];

            // Check if the number is positive
            if (currentNumber > 0) {
                System.out.println(currentNumber + " is a positive number.");
            }
        }
    }
}

Décortiquons ce code :

public class PositiveCheck : Cela déclare notre classe, qui correspond au nom du fichier.
public static void main(String[] args) : C'est la méthode principale où l'exécution de notre programme commence.
int[] numbers = {10, -5, 20, 0, 15, -8}; : Cette ligne déclare un tableau d'entiers nommé numbers et l'initialise avec certaines valeurs. Un tableau est une collection d'éléments du même type de données.
for (int i = 0; i < numbers.length; i++) : Il s'agit d'une boucle for. C'est une structure de contrôle qui nous permet de répéter un bloc de code plusieurs fois.
- int i = 0 : Cela initialise une variable compteur i à 0.
- i < numbers.length : C'est la condition qui est vérifiée avant chaque itération. La boucle continue tant que i est inférieur à la longueur du tableau numbers. numbers.length nous donne le nombre d'éléments dans le tableau.
- i++ : Cela incrémente le compteur i de 1 après chaque itération.
int currentNumber = numbers[i]; : À l'intérieur de la boucle, cette ligne accède à l'élément à l'index actuel i du tableau numbers et le stocke dans une variable appelée currentNumber. Les index des tableaux commencent à 0.
if (currentNumber > 0) : Il s'agit d'une instruction if. Elle vérifie si le currentNumber est supérieur à 0.
System.out.println(currentNumber + " is a positive number."); : Cette ligne est exécutée uniquement si la condition if est vraie (c'est-à-dire si le nombre est positif). Elle affiche le nombre positif suivi du texte " is a positive number.".

Enregistrez le fichier PositiveCheck.java (Ctrl+S ou Cmd+S).

Maintenant, compilons et exécutons ce programme dans le terminal. Assurez-vous d'être dans le répertoire ~/project.

Compilez le code :

javac PositiveCheck.java

S'il n'y a pas d'erreurs, un fichier PositiveCheck.class sera créé.

Maintenant, exécutez le code compilé :

java PositiveCheck

Vous devriez voir la sortie affichant uniquement les nombres positifs du tableau.

10 is a positive number.
20 is a positive number.
15 is a positive number.

Cela démontre comment utiliser une boucle for pour parcourir un tableau et appliquer une condition à chaque élément. Dans l'étape suivante, nous explorerons une façon plus moderne d'obtenir un résultat similaire en utilisant l'API Stream de Java.

Utiliser l'API Stream pour les nombres positifs

Dans cette étape, nous explorerons une façon plus moderne et souvent plus concise de traiter les collections en Java : l'API Stream. Introduite dans Java 8, les flux (Streams) offrent un moyen puissant d'effectuer des opérations telles que le filtrage, le mappage et la réduction sur des collections de données.

Nous allons modifier notre exemple précédent pour utiliser les flux (Streams) afin de trouver les nombres positifs dans le tableau.

Ouvrez à nouveau le fichier PositiveCheck.java dans l'éditeur. Remplacez le code existant par le suivant :

import java.util.Arrays;

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Use Stream API to filter and print positive numbers
        Arrays.stream(numbers) // 1. Create a stream from the array
              .filter(number -> number > 0) // 2. Filter for positive numbers
              .forEach(number -> System.out.println(number + " is a positive number (Stream).")); // 3. Process each positive number
    }
}

Examinons les nouvelles parties de ce code :

import java.util.Arrays; : Nous devons importer la classe Arrays pour utiliser sa méthode stream().
Arrays.stream(numbers) : Cette ligne convertit notre tableau d'entiers (int) en un IntStream. Un flux (Stream) n'est pas une structure de données en soi, mais plutôt une séquence d'éléments qui peut être traitée.
.filter(number -> number > 0) : Il s'agit d'une opération intermédiaire sur le flux. La méthode filter() prend un Predicate (une fonction qui renvoie vrai ou faux) et ne garde que les éléments pour lesquels le prédicat est vrai. Ici, number -> number > 0 est une expression lambda, qui est une façon concise d'écrire une fonction. Elle vérifie si chaque number dans le flux est supérieur à 0.
.forEach(number -> System.out.println(number + " is a positive number (Stream).")); : Il s'agit d'une opération terminale. Les opérations terminales consomment le flux et produisent un résultat. La méthode forEach() effectue une action pour chaque élément du flux. Ici, elle affiche chaque nombre positif accompagné d'un message.

Enregistrez le fichier PositiveCheck.java.

Maintenant, compilez et exécutez le programme modifié dans le terminal :

javac PositiveCheck.java

java PositiveCheck

Vous devriez voir la même sortie qu'avant, mais avec le message mis à jour :

10 is a positive number (Stream).
20 is a positive number (Stream).
15 is a positive number (Stream).

Cela démontre comment l'API Stream peut être utilisée pour obtenir le même résultat qu'une boucle for traditionnelle, souvent avec un code plus lisible et plus expressif, en particulier pour des opérations plus complexes.

Gérer les nombres nuls et négatifs

Dans les étapes précédentes, nous nous sommes concentrés sur l'identification des nombres positifs. Maintenant, développons notre programme pour identifier également les nombres nuls et négatifs. Cela nous donnera une vision plus complète des nombres dans notre tableau.

Nous allons modifier à nouveau le fichier PositiveCheck.java pour inclure des vérifications pour les nombres nuls et négatifs en utilisant d'abord l'approche de la boucle for traditionnelle, car il est souvent plus facile de comprendre la logique conditionnelle avec les instructions if-else if-else.

Ouvrez le fichier PositiveCheck.java dans l'éditeur. Remplacez le code existant par le suivant :

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Loop through the array
        for (int i = 0; i < numbers.length; i++) {
            // Get the current number
            int currentNumber = numbers[i];

            // Check if the number is positive, negative, or zero
            if (currentNumber > 0) {
                System.out.println(currentNumber + " is a positive number.");
            } else if (currentNumber < 0) {
                System.out.println(currentNumber + " is a negative number.");
            } else {
                System.out.println(currentNumber + " is zero.");
            }
        }
    }
}

Voici ce qui est nouveau :

else if (currentNumber < 0) : Il s'agit d'une instruction else if. Elle vérifie si le currentNumber est inférieur à 0, mais seulement si la condition if précédente (currentNumber > 0) était fausse.
else : Il s'agit d'une instruction else. Le code à l'intérieur du bloc else est exécuté si aucune des conditions if ou else if précédentes n'est vraie. Dans ce cas, si le nombre n'est pas supérieur à 0 et n'est pas inférieur à 0, il doit être égal à 0.

Enregistrez le fichier PositiveCheck.java.

Maintenant, compilez et exécutez le programme modifié dans le terminal :

javac PositiveCheck.java

java PositiveCheck

Vous devriez maintenant voir une sortie qui catégorise chaque nombre dans le tableau :

10 is a positive number.
-5 is a negative number.
20 is a positive number.
0 is zero.
15 is a positive number.
-8 is a negative number.

Cela démontre comment utiliser les instructions if-else if-else pour gérer plusieurs conditions dans une boucle. C'est un modèle fondamental pour la prise de décision en programmation.

Vous pouvez également obtenir des résultats similaires en utilisant l'API Stream avec des techniques plus avancées telles que partitioningBy ou plusieurs opérations filter, mais la boucle for avec if-else if-else est une approche claire et directe pour cette tâche spécifique, en particulier pour les débutants.

Résumé

Dans ce laboratoire (LabEx), nous avons appris à vérifier si un tableau ne contient que des nombres positifs en Java. Nous avons exploré deux méthodes principales : parcourir le tableau à l'aide d'une boucle for et utiliser l'API Stream de Java.

Nous avons commencé par créer une classe Java et en utilisant une boucle for pour examiner chaque élément d'un tableau d'entiers. Nous avons mis en œuvre une vérification conditionnelle (if (currentNumber > 0)) pour identifier et afficher les nombres positifs. Cette approche fondamentale a démontré comment accéder et traiter les éléments individuels d'un tableau. Bien que le contenu fourni n'ait détaillé que la méthode de boucle, la structure du laboratoire indique que les étapes suivantes couvriraient l'API Stream et la gestion des nombres nuls/négatifs, offrant ainsi une compréhension complète des différentes techniques pour cette tâche de programmation courante.