# Tout savoir sur la classe Java Math Avec Java `Math`, vous pouvez effectuer des calculs simples. Les méthodes sont nombreuses et couvrent également les logarithmes et la trigonométrie. La syntaxe est relativement simple et donc facile à apprendre. ## Qu’est-ce que Java Math ? Si vous souhaitez effectuer des opérations avec des calculs numériques simples, le langage de programmation connaît pour cela le standard `Math`. Cette classe Java ne doit pas être importée séparément et dispose de nombreuses méthodes que nous allons encore énumérer et expliquer plus en détail au cours de cet article. La classe `Math` n’est **pas instanciée et toutes ses méthodes sont utilisées de manière statique**. Même les deux constantes de la classe sont statiques : le nombre d’Euler (approximativement e = 2,7182818284590) comme base pour le logarithme naturel et la fonction exponentielle naturelle, ainsi que le nombre circulaire Pi (approximativement π = 3,1415926535). La classe `Math` est contenue dans le paquet java.lang. Le type de résultat des calculs est généralement « double ». ## Déterminer la valeur absolue Le fonctionnement et la syntaxe de la classe Java `Math` peuvent être mieux illustrés par des exemples et **en relation avec les différentes méthodes**. Si vous souhaitez déterminer la valeur absolue d’un paramètre, vous pouvez utiliser `abs()`. Par valeur absolue, on entend la distance entre un nombre et 0 ou un nombre sans signe. Le résultat sera donc toujours positif. Les types autorisés pour cette méthode sont *double*, *float*, *int* et *long*. C’est ainsi que `Math.abs` fonctionne avec un nombre positif. Pour la sortie, nous utilisons ici et dans les exemples suivants la commande Java `System.out.println`. ```java public class Main { public static void main(String args[]) { int nombre = +7; System.out.println("Le nombre d'origine est : " + nombre); System.out.println("La valeur absolue est : Math.abs(" + nombre + ") = " + Math.abs(nombre)); } } ``` La sortie correspondante ressemble à ceci : ```java Le nombre d'origine est : 7 La valeur absolue est : Math.abs(7) = 7 ``` Vous pouvez aussi utiliser une valeur initiale négative. Le résultat restera tout de même positif. Si l’on reprend le même exemple que précédemment : ```java public class Main { public static void main(String args[]) { int nombre = -7; System.out.println("Le nombre d'origine est : " + nombre); System.out.println("La valeur absolue est : Math.abs(" + nombre + ") = " + Math.abs(nombre));} } ``` La sortie est globalement la même que dans l’exemple précédent : ```java Le nombre d'origine est : -7 La valeur absolue est : Math.abs(-7) = 7 ``` La méthode ignore donc le signe du nombre entier négatif (-7) et renvoie donc également « 7 » comme résultat. ## Afficher la plus grande valeur La méthode `max()` permet de déterminer la plus grande valeur de deux entrées. Cela ressemble à ceci : ```java public class Main { public static void main(String args[]) { double nombre = Math.max(3, 9); System.out.println("Le nombre le plus grand est : " + nombre); } } ``` La sortie correspondante est celle-ci : ```java Le nombre le plus grand est : 9.0 ``` ## Déterminer la plus petite valeur La classe `Math` en Java fonctionne de manière très similaire si vous souhaitez déterminer la plus petite valeur. La méthode appropriée est `min()` : ```java public class Main { public static void main(String args[]) { double nombre = Math.min(3, 9); System.out.println("Le nombre le plus petit est : " + nombre); } } ``` Vous obtenez alors la sortie suivante : ```java Le nombre le plus petit est : 3.0 ``` ## Calculer une puissance Alors que les exemples précédents étaient encore assez simples, il y a aussi des calculs plus sophistiqués que la classe Java `Math` peut prendre en charge pour vous. La méthode pour le calcul de puissance s’appelle par exemple `pow()`. Pour cela, nous définissons d’abord une base et un exposant et laissons ensuite le calcul s’effectuer. ```java public class Main { public static void main(String args[]) { double base = 4; double exposant = 2; double puissance = Math.pow(base, exposant); System.out.println("Le résultat est : " + puissance); } } ``` Voici à quoi ressemble notre sortie : ```java Le résultat est : 16.0 ``` ## Tirer la racine carrée La classe peut aussi être utilisée pour le calcul des racines carrées avec la méthode `sqrt()`. Dans l’exemple suivant, nous calculons la racine carrée de 64 : ```java public class Main { public static void main(String args[]) { double nombre = 64; double racine = Math.sqrt(nombre); System.out.println("Le résultat est : " + racine); } } ``` Nous obtenons ainsi cette sortie : ```java Le résultat est : 8.0 ``` ## Déterminer des nombres aléatoires Avec la méthode `random()`, vous obtenez un nombre aléatoire qui se situe soit entre 0.0 et 1.0, soit dans une plage que vous définissez vous-même. Nous vous montrons les deux possibilités : ```java public class Main { public static void main(String args[]) { double nombreAleatoire; nombreAleatoire = Math.random(); System.out.println(nombreAleatoire); } } ``` Une sortie possible serait alors par exemple celle-ci : ```java 0.7488711506123137 ``` Vous pouvez également limiter les résultats possibles et n’autoriser que les nombres entiers compris entre 0 et 100. Pour cela, utilisez le code suivant : ```java public class Main { public static void main(String args[]) { int nombreAleatoire = (int) (Math.random() * 101); System.out.println(nombreAleatoire); } } ``` Cela permet d’obtenir des résultats aléatoires comme celui-ci : ```java 27 ``` ## Liste des méthodes les plus importantes Il existe de nombreuses méthodes que vous pouvez utiliser avec la classe Java `Math`. Voici les plus importantes :
Méthode Fonction
`abs()` Retourne la valeur absolue d’un argument.
`max()` Rend la plus grande de deux valeurs.
`min()` Rend la plus petite des deux valeurs.
`pow()` Rend la valeur de la puissance.
`sqrt()` Calcule la racine carrée.
`random()` Rend une valeur double aléatoire.
`cbrt()` Calcule la racine cubique.
`log()` Rend le logarithme naturel d’une valeur double.
`sin()` Calcule le sinus d’une valeur double.
`cos()` Calcule le cosinus d’une valeur double.
`tan()` Calcule la valeur de la tangente d’une valeur double.
`round()` Arrondit une valeur double à un entier supérieur ou inférieur.
`negateExact()` Indique la valeur opposée d’un argument.
`floor()` Arrondit la plus grande valeur de double qui est inférieure ou égale à l’argument donné.
This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-math/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-math/) for AI/LLM consumption.