Module 3: Les structures de données, de contrôle et d'itération en Java on INF 1220 - Introduction à la programmation

Java pas à pas

Mon, 01 Jan 0001 00:00:00 +0000

Java pas à pas #

Nous vous invitons maintenant à lire le chapitre Structures de contrôle (chapitre 3) du manuel Java pas à pas par Robert Godin et Daniel Lemire. Le chapitre comprend plusieurs exemples et exercices. Vous devez compléter les exercices du manuel. Vous pouvez aussi exécuter certains exemples du manuel sur cette page.

ExemplesString.java

public class ExemplesString {

public static void main(String args[]) {

String string1 = "abc";
 String string2 = "def";
 String string3 = "abcdef";
 String string4 = new String("abcdef");

// Tous les litéraux identiques (� la compilation) sont traduits
 // par une référence au même objet
 System.out.println(string3 == "abcdef"); // true
 System.out.println("abc" + "def" == "abcdef"); // true

// Par contre, si le litéral est calculé à l'exécution, ce n'est pas le cas
 System.out.println(string1 + string2 == "abcdef"); // false

// Le constructeur String produit toujours un objet différent de l'objet
 // correspondant au litéral
 System.out.println(string4 == "abcdef"); // false

// La méthode intern() de la classe String permet de convertir
 // la référence à l'objet correspondant au litéral
 System.out.println((string1 + string2).intern() == "abcdef"); // true
 System.out.println(string4.intern() == "abcdef"); // true

// La méthode equals() permet de comparer le contenu de l'objet plutôt que la référence
 System.out.println((string1 + string2).equals("abcdef")); // true
 System.out.println(string4.equals("abcdef")); // true
 }
}

Après la lecture du chapitre, répondez aux questions suivantes.

GitHub

Mon, 01 Jan 0001 00:00:00 +0000

GitHub (optionnel) #

GitHub est un site où les programmeurs partagent leur code et travaillent de manière collaborative sur des projets de programmation. Si vous créez un compte et apprenez à utiliser Git, vous pourrez y partager votre code, ou contribuer au code d’autres projets. C’est une excellente manière de développer un portfolio afin d’impressionner les employeurs potentiels. Vous trouverez le professeur responsable du cours sur GitHub. Encore une fois, tout s’y déroule en anglais, mais si vous ne maîtrisez pas l’anglais, vous aurez du mal à faire carrière en informatique.

Les structures de contrôle

Mon, 01 Jan 0001 00:00:00 +0000

Les structures de contrôle #

Les structures de contrôle sont des outils essentiels en programmation : elles permettent de prendre des décisions et de répéter des actions selon certaines conditions. En Java, les structures de contrôle principales sont if-else et switch-case pour le choix, ainsi que les boucles (qui seront vues plus loin).

Une structure de contrôle permet d’exécuter différentes instructions selon la valeur d’une variable ou le résultat d’une expression logique. Cela rend les programmes dynamiques et capables de s’adapter à différentes situations.

Les structures itératives

Mon, 01 Jan 0001 00:00:00 +0000

Les structures itératives #

Les structures itératives permettent d’itérer un certain nombre de fois, basé sur des variables de contrôle. Elles permettent par exemple de chercher une valeur dans une structure de données (ex. un tableau d’entier), de lire un flux de données caractère par caractère, etc. Elles sont l’implémentation des “tant que”, des “pour i de 1 à 10 faire”, etc. Dans le langage Java, il existe trois structures itératives : le while, le for et le do-while.

Les chaînes de caractères (String)

Mon, 01 Jan 0001 00:00:00 +0000

String #

En Java, le type String représente une séquence de caractères. Il est très utilisé pour manipuler du texte : noms, messages, fichiers, etc. Une particularité essentielle à comprendre est que les objets de type String sont immuables : une fois créés, ils ne peuvent pas être modifiés. Toute opération qui semble modifier une chaîne (comme la concaténation, le remplacement ou la suppression de caractères) crée en réalité un nouvel objet String en mémoire, sans changer l’original.

Les structures de données de base

Mon, 01 Jan 0001 00:00:00 +0000

Les structures de données de base #

Le langage Java possède toutes les stuctures de données nécessaires. Faisons-en rapidement le tour. En Java, les types de données sont organisés en deux grandes catégories : les types primitifs et les types référence. Les types primitifs, tels que int, double, float, long, short, byte, char et boolean, sont des types de base qui stockent directement des valeurs simples et ne sont pas des objets. Chaque type primitif possède une classe enveloppe correspondante (par exemple, Integer pour int, Double pour double) dans la catégorie des classes enveloppes. Ces classes permettent de représenter les primitifs sous forme d’objets, offrant des fonctionnalités supplémentaires comme l’utilisation dans des collections ou la conversion entre types.

Les valeurs aléatoires

Mon, 01 Jan 0001 00:00:00 +0000

Génération de valeurs aléatoires #

Vous n’avez pas à maîtriser la génération de valeurs aléatoires dans ce cours.

Pour tester des structures de données, il est utile de pouvoir générer des valeurs aléatoires. Le plus souvent en programmation logicielle, nous générons des valeurs pseudo-aléatoires. Une valeur pseudo-aléatoire semble aléatoire, mais elle est en réalité pré-déterminée. La classe Random en Java, située dans le paquetage java.util, permet de générer des nombres pseudo-aléatoires pour diverses applications, comme les simulations, les jeux ou les tests. Elle utilise un générateur de nombres pseudo-aléatoires basé sur une graine (seed), qui, si spécifiée, garantit la reproductibilité des séquences générées. Par défaut, Random utilise une graine dérivée de l’heure système pour produire des résultats différents à chaque exécution. La classe offre des méthodes comme nextInt(), nextDouble() ou nextBoolean() pour générer respectivement des entiers, des nombres à virgule flottante ou des booléens.

La programmation fonctionnelle en Java

Mon, 01 Jan 0001 00:00:00 +0000

La programmation fonctionnelle en Java #

La programmation fonctionnelle tire ses origines des mathématiques, en particulier du calcul lambda développé par Alonzo Church dans les années 1930. Ce formalisme a posé les bases théoriques pour décrire les calculs comme des fonctions pures, sans effets de bord. Dans les années 1950, John McCarthy a créé Lisp, le premier langage explicitement inspiré de ces idées, introduisant des concepts comme les fonctions de première classe. Les années 1980 ont vu l’émergence de langages comme Haskell, qui a mis l’accent sur les fonctions pures et l’évaluation paresseuse. L’évaluation paresseuse est une stratégie en programmation fonctionnelle où l’évaluation d’une expression est retardée jusqu’à ce que sa valeur soit réellement nécessaire. Cela permet d’optimiser les performances en évitant les calculs inutiles et de supporter des structures de données potentiellement infinies. Depuis, la programmation fonctionnelle a influencé de nombreux langages modernes (Scala, Clojure, F#) et a été intégrée dans des langages impératifs comme Python, JavaScript et Java, en réponse à la nécessité de parallélisme et de code plus robuste.

Exercices sur les structures de contrôle, les structures de données, les structures itératives

Mon, 01 Jan 0001 00:00:00 +0000

Exercices sur les structures de contrôle, les structures de données, les structures itératives #

Questions/Réponses #

Veuillez répondre mentalement, sur papier ou bien en créant le code nécessaire pour répondre à ces questions avant de regarder la réponse. Certaines questions sont difficiles, et il est normal de ne pas toutes les réussir.

N’oubliez pas d’utiliser notre pense-bête Java au besoin. Pour les mathématiques, vous pouvez faire référence à notre rappel sur les principales notions mathématiques du cours.

Les exceptions

Mon, 01 Jan 0001 00:00:00 +0000

Les exceptions #

En programmation, il est essentiel de pouvoir gérer les erreurs qui peuvent survenir lors de l’exécution d’un programme. Java propose un mécanisme puissant et structuré : les exceptions. Plutôt que de laisser le programme s’arrêter brutalement en cas de problème (comme une division par zéro ou l’ouverture d’un fichier inexistant), Java permet de « lancer » une exception. Cette exception peut alors être capturée et traitée, ce qui rend le code plus robuste, plus lisible et plus facile à maintenir.

La récursivité

Mon, 01 Jan 0001 00:00:00 +0000

La récursivité #

La récursivité est une technique fondamentale en informatique qui consiste pour une fonction à s’appeler elle-même afin de résoudre un problème en le divisant en sous-problèmes plus simples. Cette approche permet d’exprimer élégamment des solutions à des problèmes complexes, comme le calcul de suites, la recherche dans des structures arborescentes ou la résolution de certains algorithmes mathématiques. Comprendre la récursivité est essentiel pour progresser en algorithmique et en programmation.

Exercices sur les exceptions et la récursivité

Mon, 01 Jan 0001 00:00:00 +0000

Exercices sur les exceptions et la récursivité #

Questions/Réponses #

N’oubliez pas d’utiliser notre pense-bête Java au besoin. Pour les mathématiques, vous pouvez faire référence à notre rappel sur les principales notions mathématiques du cours.

Exemple : modèle de langue

Mon, 01 Jan 0001 00:00:00 +0000

Exemple : modèle de langue #

Ce exemple est une application des notions du module. Il s’agit de matériel optionnel.

Pour illustrer l’utilisation des tableaux, considérons l’exemple suivant. Le code implémente un modèle de langue simple en Java qui calcule les probabilités de transition entre caractères ASCII dans une chaîne donnée, puis génère une séquence de 100 caractères à partir d’un caractère initial. Il utilise un tableau à deux dimensions double[][] transitions de taille 128x128 pour stocker les probabilités qu’un caractère ASCII (0-127) soit suivi d’un autre. Dans calculerTransitions, le programme compte les occurrences des paires de caractères consécutifs dans le texte d’entrée et normalise ces comptes pour obtenir des probabilités, stockées dans transitions[i][j], où i est le caractère courant et j le suivant. Lors de la génération dans genererCaractereSuivant, ce tableau est utilisé pour sélectionner aléatoirement le caractère suivant en fonction des probabilités associées au caractère courant. Cette application des tableaux à deux dimensions permet de modéliser efficacement les relations entre caractères, chaque cellule représentant une probabilité de transition, et facilite la génération de texte en s’appuyant sur une structure matricielle claire et organisée.

Recommandations

Mon, 01 Jan 0001 00:00:00 +0000

Recommandations #

Pour aborder un problème algorithmique, adoptez une démarche structurée. Analysez d’abord le problème en le décomposant en étapes simples. Avant de coder, rédigez un pseudocode ou un plan pour clarifier la logique. Cette préparation limite les erreurs et facilite la maintenance.

Privilégiez un code lisible avec des noms de variables explicites. Testez chaque étape avec des cas simples avant d’explorer des scénarios complexes. Cette validation progressive permet de repérer rapidement les anomalies et de garantir la robustesse de la solution.