Calcul factoriel en Java

1. Vue d'ensemble

Étant donné un entier non négatif n , factorielle est le produit de tous les nombres entiers positifs inférieurs ou égaux à n .

Dans ce rapide tutoriel, nous explorerons différentes manières de calculer factoriel pour un nombre donné en Java .

2. Factorielle pour les nombres jusqu'à 20

2.1. Factorielle utilisant une boucle for

Voyons un algorithme factoriel de base utilisant une boucle for :

public long factorialUsingForLoop(int n) { long fact = 1; for (int i = 2; i <= n; i++) { fact = fact * i; } return fact; }

La solution ci-dessus fonctionnera bien pour les nombres jusqu'à 20 . Mais, si nous essayons quelque chose de plus grand que 20, cela échouera car les résultats seraient trop grands pour être intégrés dans un long , provoquant un débordement.

Voyons un peu plus, notant que chacun d'entre eux ne fonctionnera que pour de petits nombres.

2.2. Factorielle à l'aide de flux Java 8

Nous pouvons également utiliser l' API Java 8 Stream pour calculer les factorielles assez facilement:

public long factorialUsingStreams(int n) { return LongStream.rangeClosed(1, n) .reduce(1, (long x, long y) -> x * y); }

Dans ce programme, nous utilisons d'abord LongStream pour parcourir les nombres entre 1 et n . Nous avons ensuite utilisé réduire () , qui utilise une valeur d'identité et une fonction d'accumulateur pour l'étape de réduction.

2.3. Factorielle utilisant la récursivité

Et voyons un autre exemple de programme factoriel, cette fois utilisant la récursivité:

public long factorialUsingRecursion(int n) { if (n <= 2) { return n; } return n * factorialUsingRecursion(n - 1); }

2.4. Factorielle utilisant Apache Commons Math

Apache Commons Math a une classe CombinatoricsUtils avec une méthode factorielle statique que nous pouvons utiliser pour calculer la factorielle.

Pour inclure Apache Commons Math, nous allons ajouter la dépendance commons-math3 dans notre pom :

 org.apache.commons commons-math3 3.6.1 

Voyons un exemple utilisant la classe CombinatoricsUtils :

public long factorialUsingApacheCommons(int n) { return CombinatoricsUtils.factorial(n); }

Notez que son type de retour est long , tout comme nos solutions locales.

Cela signifie ici que si la valeur calculée dépasse Long.MAX_VALUE , une MathArithmeticException est lancée.

Pour agrandir, nous allons avoir besoin d'un type de retour différent.

3. Factorielle pour les nombres supérieurs à 20

3.1. Factorielle utilisant BigInteger

Comme indiqué précédemment, le type de données long ne peut être utilisé pour les factorielles que pour n <= 20 .

Pour les plus grandes valeurs de n , nous pouvons utiliser la BigInteger classe du java.math package qui peut contenir des valeurs jusqu'à 2 ^ Integer.MAX_VALUE :

public BigInteger factorialHavingLargeResult(int n) { BigInteger result = BigInteger.ONE; for (int i = 2; i <= n; i++) result = result.multiply(BigInteger.valueOf(i)); return result; }

3.2. Factorielle utilisant la goyave

La bibliothèque Guava de Google fournit également une méthode utilitaire pour calculer les factorielles pour de plus grands nombres.

Pour inclure la bibliothèque, nous pouvons ajouter sa dépendance goyave à notre pom :

 com.google.guava guava 25.1-jre 

Maintenant, nous pouvons utiliser la méthode factorielle statique de la classe BigIntegerMath pour calculer la factorielle d'un nombre donné:

public BigInteger factorialUsingGuava(int n) { return BigIntegerMath.factorial(n); }

4. Conclusion

Dans cet article, nous avons vu quelques façons de calculer des factorielles en utilisant Java de base ainsi que quelques bibliothèques externes.

Nous avons d'abord vu des solutions utilisant le type de données long pour calculer les factorielles des nombres jusqu'à 20 . Ensuite, nous avons vu plusieurs façons d'utiliser BigInteger pour les nombres supérieurs à 20.

Le code présenté dans cet article est disponible à l'adresse over sur Github.