Opérateur modulo en Java

Introduction

L'opérateur modulo est un opérateur mathématique utilisé pour trouver le reste de la division de deux nombres. Cet opérateur est représenté par le symbole %. En Java, l'opérateur modulo renvoie le reste de la division du premier nombre par le second nombre. Ce laboratoire vous guidera à travers quelques cas d'utilisation de cet opérateur.

Skills Graph

Exemple d'opérateur modulo

Dans cette étape, nous verrons la syntaxe de base de l'opérateur modulo et comment il peut être utilisé sur des variables entières et à virgule flottante. Nous verrons également comment il gère les nombres négatifs.

1. Créez un nouveau fichier nommé ModuloOperatorDemo.java à l'aide de la commande touch.
2. Ouvrez le fichier dans un éditeur de texte tel que nano.
3. Ajoutez le code suivant au fichier :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        System.out.println("10 % 3 = " + 10 % 3);
        System.out.println("3 % 10 = " + 3 % 10);
        System.out.println("10.0 % 3.0 = " + 10.0 % 3.0);
        System.out.println("10.0 % 3 = " + 10.0 % 3);
        System.out.println("-10 % 3 = " + -10 % 3);
    }
}

4. Enregistrez le fichier et quittez l'éditeur de texte.
5. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
6. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
7. Le code devrait afficher ce qui suit :

10 % 3 = 1
3 % 10 = 3
10.0 % 3.0 = 1.0
10.0 % 3 = 1.0
-10 % 3 = -1

Nécessité de l'opérateur modulo

Dans cette étape, nous allons discuter de pourquoi l'opérateur modulo est nécessaire lorsqu'on utilise l'opérateur de division.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        int dividend = 10;
        int divisor = 3;
        int remainder = dividend - (divisor * (dividend/divisor));
        System.out.print("The remainder is: " + remainder);
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

The remainder is: 1

Lorsque le dividende ou le diviseur n'est pas un entier

Dans cette étape, nous verrons comment l'opérateur modulo peut gérer les nombres décimaux.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        double dividend = 10;
        int divisor = 3;
        double remainder = dividend - (divisor * (dividend/divisor));
        System.out.print("The remainder is: " + remainder);
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

The remainder is: 0.0

7. Modifiez le code dans le fichier comme suit :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        double dividend = 10;
        int divisor = 3;
        double remainder = dividend % divisor;
        System.out.print("The remainder is: " + remainder);
    }
}

8. Enregistrez le fichier et quittez l'éditeur de texte.
9. Recompilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
10. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
11. Le code devrait maintenant afficher ce qui suit :

The remainder is: 1.0

Exception ArithmeticException par l'opérateur modulo

Dans cette étape, nous verrons comment l'opérateur modulo lance une exception si le diviseur est égal à zéro.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        System.out.print("The remainder is: " + 10 % 0);
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait lever une ArithmeticException comme suit :

Exception in thread "main" java.lang.ArithmeticException: / by zero
        at ModuloOperatorDemo.main(ModuloOperatorDemo.java:3)

Trouver les nombres pairs

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour vérifier si un nombre est pair ou impair.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        int[] arr = {7, 5, 2, 4, 6, 19, 18, 25, 22};
        for(int i=0; i<arr.length; i++)
        {
            int num = arr[i];
            if((num % 2) == 0)
                System.out.println(num + " est pair.");
            else
                System.out.println(num + " n'est PAS pair.");
        }
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

7 n'est PAS pair.
5 n'est PAS pair.
2 est pair.
4 est pair.
6 est pair.
19 n'est PAS pair.
18 est pair.
25 n'est PAS pair.
22 est pair.

Convertir les secondes en minutes et secondes

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour convertir les secondes en minutes et secondes.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        int seconds = 401;
        int minutes = seconds / 60;
        int remainingSeconds = seconds % 60;
        System.out.print(seconds + " secondes est égal à " + minutes + " minutes " + remainingSeconds + " secondes");
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

401 seconds is equal to 6 minutes 41 seconds

Extraction des chiffres individuels d'un entier

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour extraire les chiffres individuels d'un nombre.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        int num = 7912064;
        while(num > 0)
        {
            int lastDigit = num % 10;
            num = num / 10;
            System.out.print(lastDigit + " ");
        }
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

4 6 0 2 1 9 7

Répéter quelque chose à chaque n-ième fois

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour répéter une action à chaque n-ième fois.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        for(int i = 1; i <= 30; i++)
        {
            if(i % 5 == 0)
                System.out.println("Faire quelque chose");
        }
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

Faire quelque chose
Faire quelque chose
Faire quelque chose
Faire quelque chose
Faire quelque chose
Faire quelque chose

Restreindre un nombre à une plage donnée

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour limiter un nombre à une plage donnée.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        String[] dayNames = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
        int dayOfTheMonth1 = 21;
        String dayName1 = dayNames[(dayOfTheMonth1 - 1) % 7];
        int dayOfTheMonth2 = 12;
        String dayName2 = dayNames[(dayOfTheMonth2 - 1) % 7];

        System.out.println(dayOfTheMonth1 + " se produit le " + dayName1);
        System.out.println(dayOfTheMonth2 + " se produit le " + dayName2);
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

21 occurs on Sunday
12 occurs on Friday

Rendre un nombre complètement divisible par un autre nombre

Dans cette étape, nous verrons comment l'opérateur modulo peut être utilisé pour rendre un nombre complètement divisible par un autre nombre.

1. Ouvrez le fichier ModuloOperatorDemo.java dans un éditeur de texte.
2. Supprimez le code existant et remplacez-le par le code suivant :

public class ModuloOperatorDemo
{
    public static void main(String[] args)
    {
        int X = 291;
        int Y = 17;

        int remainder = X % Y;
        X = X - remainder;
        System.out.println("Le nombre minimum à soustraire est : " + remainder);
        System.out.println("Le nombre après soustraction est : " + X);
    }
}

3. Enregistrez le fichier et quittez l'éditeur de texte.
4. Compilez le code à l'aide de la commande javac ModuloOperatorDemo.java.
5. Exécutez le code à l'aide de la commande java ModuloOperatorDemo.
6. Le code devrait afficher ce qui suit :

The minimum number to subtract is: 2
The number after subtraction is: 289

Sommaire

L'opérateur modulo est un opérateur mathématique utilisé pour trouver le reste de la division de deux nombres. Dans ce laboratoire, nous avons abordé divers cas d'utilisation de l'opérateur modulo, tels que vérifier si un nombre est pair, convertir des secondes en minutes et secondes, extraire les chiffres individuels, répéter une action à chaque n-ième fois, limiter un nombre à une plage donnée et rendre un nombre complètement divisible par un autre nombre. Gardez à l'esprit que lorsqu'on utilise l'opérateur modulo, le diviseur ne peut pas être égal à zéro car cela entraînera une ArithmeticException.