0Pricing
Java Academy · Leçon

Arithmétique entière et dépassement de capacité

Comprenez la division entière, le modulo, le comportement en cas de dépassement de capacité et la manière de le détecter.

Arithmétique entière et dépassement de capacité est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Arithmétique entière et dépassement de capacité

Les entiers Java ont des tailles fixes. Lorsqu’un calcul dépasse la valeur maximale ou minimale, il reboucle silencieusement : aucune exception n’est levée. Comprendre ce comportement permet d’éviter des problèmes difficiles à détecter.

Plages des entiers

Chaque type entier possède une plage limitée, déterminée par sa largeur en bits :

  • byte : -128 à 127
  • short : -32 768 à 32 767
  • int : -2 147 483 648 à 2 147 483 647
  • long : -9,2 × 10^18 à 9,2 × 10^18
System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Long.MAX_VALUE);    // 9223372036854775807
System.out.println(Byte.MAX_VALUE);    // 127

Dépassement : rebouclage silencieux

Ajouter 1 à Integer.MAX_VALUE fait reboucler la valeur vers Integer.MIN_VALUE. Il s’agit d’une arithmétique en complément à deux : Java ne fournit aucune garantie et ne lève aucune exception.

int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648 (overflow!)

byte b = 127;
b++;  // wraps to -128
System.out.println(b); // -128

// Real bug: counting votes in a large election with int
int votes = Integer.MAX_VALUE;
votes += 100; // silently wrong
System.out.println(votes); // negative number!

Détecter les dépassements avec Math.addExact

Java 8+ a introduit Math.addExact(), multiplyExact() et subtractExact(), qui lèvent ArithmeticException en cas de dépassement au lieu de reboucler silencieusement.

try {
    int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!"); // prints this
}

try {
    long safe = Math.multiplyExact(100_000L, 100_000L);
    System.out.println(safe); // 10000000000
} catch (ArithmeticException e) {
    System.out.println("Multiply overflow");
}

Division entière et modulo

La division entière tronque vers zéro. L’opérateur % renvoie le reste avec le signe du dividende. Faites attention à la division par zéro : elle lève ArithmeticException.

System.out.println(10 / 3);    // 3 (not 3.33)
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1 (sign follows dividend)
System.out.println(-10 % -3);  // -1

try {
    int x = 5 / 0; // ArithmeticException: / by zero
} catch (ArithmeticException e) {
    System.out.println(e.getMessage()); // / by zero
}

// Float division by zero gives Infinity, not exception
System.out.println(5.0 / 0); // Infinity

Arithmétique long pour les grands nombres

Utilisez long lorsque les valeurs peuvent dépasser la plage de int. Ajoutez toujours L aux littéraux long afin d’éviter un dépassement avant l’affectation.

// Bug: multiplication done as int, then widened
long wrong = 1_000_000 * 1_000_000;   // overflows int!
System.out.println(wrong); // -727379968 (wrong!)

// Fix: one operand is long
long correct = 1_000_000L * 1_000_000L;
System.out.println(correct); // 1000000000000

// Or cast first
long alsOk = (long) 1_000_000 * 1_000_000;
System.out.println(alsOk); // 1000000000000

Opérateurs de décalage de bits

Les opérateurs de décalage de bits permettent rapidement de multiplier ou de diviser par des puissances de 2 :

  • n << k — décalage à gauche : multiplication par 2^k
  • n >> k — décalage à droite signé : division par 2^k
  • n >>> k — décalage à droite non signé : remplissage par des 0
int n = 8;
System.out.println(n << 1);  // 16 (8 * 2)
System.out.println(n << 2);  // 32 (8 * 4)
System.out.println(n >> 1);  // 4  (8 / 2)
System.out.println(n >> 2);  // 2  (8 / 4)

// Check if number is power of 2
boolean isPow2 = n > 0 && (n & (n - 1)) == 0;
System.out.println(isPow2); // true

AND, OR et XOR bit à bit

Les opérateurs bit à bit agissent sur chaque bit et sont utilisés pour les permissions, les indicateurs et les protocoles de bas niveau.

int a = 0b1010; // 10
int b = 0b1100; // 12

System.out.println(Integer.toBinaryString(a & b)); // 1000 (AND = 8)
System.out.println(Integer.toBinaryString(a | b)); // 1110 (OR  = 14)
System.out.println(Integer.toBinaryString(a ^ b)); // 0110 (XOR = 6)
System.out.println(Integer.toBinaryString(~a));    // ...11110101 (NOT)

// Permission flags example
int READ  = 0b001;
int WRITE = 0b010;
int EXEC  = 0b100;
int perms = READ | WRITE; // user has read+write
System.out.println((perms & EXEC) != 0); // false — no exec

Traits de soulignement dans les littéraux numériques

Java 7+ autorise les traits de soulignement dans les littéraux numériques afin d’améliorer leur lisibilité. Le compilateur les ignore.

int million = 1_000_000;
long creditCard = 4_111_1111_1111_1111L;
double pi = 3.141_592_653_589_793;
int hex = 0xFF_EC_D1_2E;
int binary = 0b0001_0101_0110;

System.out.println(million);   // 1000000
System.out.println(creditCard); // 4111111111111111

BigInteger pour une précision arbitraire

Lorsque les valeurs dépassent la capacité de long, utilisez BigInteger. Ce type ne connaît pas de dépassement, mais il est plus lent que les types primitifs. Utilisez-le pour les clés cryptographiques, les factorielles et les nombres astronomiques.

import java.math.BigInteger;

BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
System.out.println(factorial100.toString().length() + " digits"); // 158 digits

BigInteger a = new BigInteger("999999999999999999999999999999");
BigInteger b = new BigInteger("1");
System.out.println(a.add(b)); // 1000000000000000000000000000000

Pratique : compteur protégé contre le dépassement

Un modèle pour implémenter un compteur qui gère les dépassements en toute sécurité en utilisant Math.addExact et en se repliant sur Long.MAX_VALUE.

class SafeCounter {
    private long count = 0;

    public void increment() {
        try {
            count = Math.addExact(count, 1L);
        } catch (ArithmeticException e) {
            count = Long.MAX_VALUE; // cap at max
        }
    }

    public long get() { return count; }
}

SafeCounter sc = new SafeCounter();
sc.increment();
sc.increment();
System.out.println(sc.get()); // 2

Vérification rapide

Quelle est la valeur de l'expression suivante ?

long result = 1_000_000 * 1_000_000;
System.out.println(result);

Récapitulatif : arithmétique entière et dépassement

Points essentiels :

  • Le dépassement des entiers boucle silencieusement : aucune exception par défaut
  • Utilisez Math.addExact/multiplyExact/subtractExact pour détecter les dépassements
  • La division entière tronque vers zéro ; le signe de % suit celui du dividende
  • Utilisez des littéraux long (suffixe L) lorsque les résultats intermédiaires risquent de dépasser la capacité de int
  • BigInteger gère des valeurs arbitrairement grandes sans dépassement
  • Les opérateurs de décalage de bits constituent des solutions rapides pour multiplier ou diviser par une puissance de 2

Questions Fréquemment Posées

La leçon « Arithmétique entière et dépassement de capacité » est-elle gratuite ?

Oui — le texte complet de « Arithmétique entière et dépassement de capacité » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Arithmétique entière et dépassement de capacité » ?

Comprenez la division entière, le modulo, le comportement en cas de dépassement de capacité et la manière de le détecter. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Arithmétique entière et dépassement de capacité » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Les notions essentielles de la classe Math
  2. Arithmétique entière et dépassement de capacité
  3. BigDecimal pour les calculs financiers
  4. NumberFormat et printf
← Retour à Java Academy