Exercices sur les exceptions et la récursivité #

La récursivité est une technique où une fonction s'appelle elle-même pour résoudre un problème en le divisant en sous-problèmes plus simples. Exemple :

int factorielle(int n) {
    if (n <= 1) return 1;
    else return n * factorielle(n - 1);
}

Une exception est un mécanisme qui permet de gérer les erreurs ou situations inattendues lors de l'exécution d'un programme. Exemple :

try {
    int x = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Division par zéro !");
}

Oui, le bloc finally s'exécutera toujours, même si un return est exécuté dans le bloc try ou catch. Exemple :

public int exemple() {
    try {
        return 1;
    } catch (Exception e) {
        return 2;
    } finally {
        System.out.println("Bloc finally exécuté");
    }
}

Le message du bloc finally sera affiché avant que la méthode ne retourne sa valeur.

La fonction s'appellera elle-même indéfiniment, ce qui provoquera une erreur de type StackOverflowError (dépassement de pile) en Java.

Les exceptions vérifiées (checked) doivent être déclarées dans la signature de la méthode ou capturées avec un bloc try/catch. Elles héritent de Exception (sauf RuntimeException). Les exceptions non vérifiées (unchecked) héritent de RuntimeException et ne nécessitent pas d’être déclarées ni capturées explicitement.

Si une exception n’est pas capturée, elle remonte la pile d’appels jusqu’à ce qu’un bloc catch la capture. Si aucune méthode ne la capture, le programme se termine avec un message d’erreur (stack trace).

On crée une classe qui hérite de Exception (pour une exception vérifiée) ou de RuntimeException (pour une non vérifiée). Exemple :

class MonException extends Exception {
    public MonException(String message) {
        super(message);
    }
}

Le mot-clé throw permet de lancer explicitement une exception. Exemple :

if (x < 0) {
    throw new IllegalArgumentException("x doit être positif");
}

Les blocs catch sont évalués dans l’ordre d’apparition. Le premier bloc dont le type correspond à l’exception levée sera exécuté ; les autres seront ignorés. Il faut placer les exceptions les plus spécifiques avant les plus générales.

Le ramasse-miettes (garbage collector) est un mécanisme automatique de la machine virtuelle Java (JVM) qui libère la mémoire occupée par les objets qui ne sont plus utilisés (inaccessibles). Il permet d’éviter les fuites de mémoire et les erreurs de libération (comme les doubles libérations en C), ce qui rend la gestion de la mémoire plus sûre et plus simple pour le programmeur.

Avantages : simplifie la programmation, réduit les risques d’erreurs, améliore la robustesse et la sécurité des programmes.

Inconvénients : le développeur a moins de contrôle sur le moment précis où la mémoire est libérée, et le ramasse-miettes peut provoquer des pauses imprévisibles dans l’exécution du programme, ce qui peut être gênant pour les applications temps réel ou très sensibles aux performances.

Pour limiter le surcoût du ramasse-miettes, il est conseillé de :

• Réduire la création d’objets temporaires inutiles (par exemple, réutiliser les objets ou utiliser des types primitifs quand c’est possible).
• Privilégier les structures de données adaptées à l’usage (par exemple, préférer StringBuilder à la concaténation répétée de String).
• Limiter la taille des objets et des collections pour éviter une consommation excessive de mémoire.
• Pour les applications critiques, ajuster les paramètres de la JVM (options de tuning du garbage collector) selon le profil d’utilisation.

En appliquant ces bonnes pratiques, on réduit la pression sur le ramasse-miettes et on améliore la réactivité et la performance globale de l’application.

L’UTF-16 est un encodage qui permet de représenter tous les caractères Unicode à l’aide de séquences de 16 bits (un ou deux char). Java utilise l’UTF-16 pour garantir la compatibilité avec l’ensemble des caractères internationaux, y compris les symboles, emojis et alphabets non latins. Cela permet de manipuler du texte multilingue de façon uniforme, mais implique que certains caractères occupent deux char au lieu d’un seul.

En UTF-16, certains caractères Unicode (comme les emojis ou des symboles rares) sont codés sur deux char (une paire de substitution). La méthode charAt retourne un seul char à l’index donné, qui peut ne représenter qu’une partie d’un caractère complet. Par exemple :

String s = "A😊B";
System.out.println(s.charAt(1)); // Retourne un char de la paire, pas le smiley complet

Pour parcourir tous les caractères Unicode (code points) d’une chaîne, il faut utiliser les méthodes codePoints() ou codePointAt() de la classe String, ou la classe Character. Par exemple :

String s = "A😊B";
s.codePoints().forEach(cp -> System.out.println(Character.toChars(cp)));

Cette approche permet de traiter chaque caractère Unicode comme une entité logique, même s’il est codé sur deux char.

En Java, chaque élément du tableau interne d’une String occupe 2 octets (16 bits), car il s’agit d’un char en UTF-16. Pour la plupart des caractères courants (latin, accentués, etc.), un caractère occupe donc 2 octets. Cependant, certains caractères Unicode (comme les emojis ou des symboles rares) nécessitent deux char (soit 4 octets) pour être représentés, car ils sont codés sur une paire de substitution (surrogate pair). Ainsi, la mémoire utilisée par caractère visible peut varier selon le caractère.

import java.util.Scanner;

public class AfficheCodes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Entrez une chaîne : ");
        String s = sc.nextLine();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            System.out.println("Caractère : '" + c + "' | Code Unicode : " + (int) c);
        }
    }
}

Ce programme lit une chaîne au clavier et affiche, pour chaque char, sa valeur numérique (code Unicode en décimal).

Un stream est une séquence d’éléments sur laquelle on peut effectuer des opérations de traitement en chaîne (filter, map, etc.). Il permet de manipuler des collections de façon déclarative et fonctionnelle, souvent en une seule ligne de code.

filter permet de ne conserver que les éléments qui satisfont une condition (prédicat). Exemple :

List<Integer> l = List.of(1, 2, 3, 4);
l.stream().filter(x -> x % 2 == 0).forEach(System.out::println); // Affiche 2, 4

map applique une fonction à chaque élément du stream et retourne un nouveau stream avec les résultats. Exemple :

List<String> noms = List.of("alice", "bob");
noms.stream().map(String::toUpperCase).forEach(System.out::println); // ALICE, BOB

limit permet de ne traiter qu’un nombre maximum d’éléments du stream. Exemple :

Stream.iterate(0, n -> n + 1).limit(5).forEach(System.out::println); // 0 1 2 3 4

distinct supprime les doublons du stream (en utilisant equals). Exemple :

List<Integer> l = List.of(1, 2, 2, 3);
l.stream().distinct().forEach(System.out::println); // 1 2 3

sorted trie les éléments du stream selon l’ordre naturel ou un comparateur fourni. Exemple :

List<String> noms = List.of("bob", "alice");
noms.stream().sorted().forEach(System.out::println); // alice, bob

collect permet de rassembler les éléments du stream dans une collection ou une autre structure de données. Exemple :

List<Integer> pairs = List.of(1, 2, 3, 4).stream()
    .filter(x -> x % 2 == 0)
    .collect(Collectors.toList());
System.out.println(pairs); // [2, 4]

Une collection (List, Set, etc.) stocke des données en mémoire et permet d’y accéder plusieurs fois. Un stream est une vue temporaire sur ces données, qui permet de les traiter de façon déclarative : il ne stocke pas les données et ne peut être consommé qu’une seule fois.