Manipulez vos données en Java
Dans ce chapitre, nous allons explorer des concepts fondamentaux de la programmation : les
structures conditionnelles et les structures itératives. Ces outils vous permettront de
manipuler et d’organiser vos données efficacement tout en augmentant la puissance de vos
fonctions.
Introduction
Ce que vous savez déjà :
• Déclarer et initialiser des variables ;
• Afficher du contenu dans la console ;
• Appeler des fonctions.
Ces bases sont essentielles, mais elles ne suffisent pas encore à créer des programmes
réellement dynamiques. Pour aller plus loin, nous allons apprendre à prendre des décisions
(via les conditions) et à répéter des actions (via les boucles).
Pourquoi est-ce important ?
Imaginez une chaîne de montage dans une usine :
• Vous avez des machines (vos fonctions).
• Ces machines reçoivent des éléments (les paramètres d’entrée) et produisent un
résultat (la valeur de retour).
Cependant, sans logique conditionnelle et itérative, vos machines ne peuvent réagir à des
situations différentes ni traiter plusieurs éléments en série. En Java, cela est possible grâce
aux conditions et boucles.
1. Vérifiez une condition : Les structures conditionnelles
L’instruction if
Le mot-clé if signifie "si". Il permet d’exécuter un bloc de code seulement si une condition
est vraie.
Exemple simple :
if (condition) {
// Instructions exécutées si la condition est vraie
}
Exemple pratique :
public static void verifierNombre(int valeur) {
if (valeur == 0) {
System.out.println("Le nombre est zéro.");
} else {
System.out.println("Le nombre est différent de zéro.");
}
}
Ajoutez un else
Le mot-clé else permet de définir une alternative si la condition initiale est fausse.
Exemple :
public static void meteo(boolean beauTemps) {
if (beauTemps) {
System.out.println("Je vais à la plage !");
} else {
System.out.println("Je vais au cinéma.");
}
}
Combinez plusieurs scénarios avec else if
Pour gérer plusieurs conditions successives, utilisez else if :
if (condition1) {
// Bloc exécuté si condition1 est vraie
} else if (condition2) {
// Bloc exécuté si condition2 est vraie
} else {
// Bloc exécuté si aucune condition n’est vraie
}
Exemple :
public static void choixActivite(String meteo) {
if (meteo.equals("soleil")) {
System.out.println("Je vais à la plage.");
} else if (meteo.equals("nuage")) {
System.out.println("Je vais me promener.");
} else {
System.out.println("Je reste à la maison.");
}
}
La structure switch
Lorsque vous avez de nombreuses possibilités à vérifier, la structure switch peut simplifier
votre code.
Exemple pratique :
public static void commenteLaMeteo(String meteo) {
switch (meteo) {
case "soleil" -> System.out.println("Beau temps.");
case "nuage" -> System.out.println("Temps couvert.");
case "pluie" -> System.out.println("Mauvais temps.");
default -> System.out.println("Je ne sais pas.");
}
}
2. Itérez vos données : Les structures itératives
Les boucles
Les boucles permettent de répéter un bloc d’instructions un certain nombre de fois. Il existe
deux grandes catégories :
1. Tant que (while) : répéter tant qu'une condition est vraie.
2. Pour (for) : répéter un nombre défini de fois ou pour chaque élément d’un ensemble.
La boucle while
Cette boucle exécute un bloc d’instructions tant qu’une condition reste vraie.
Exemple :
public static void affiche() {
int chiffre = 0;
while (chiffre < 5) {
System.out.println(chiffre);
chiffre++;
}
}
À noter : Si la condition est fausse dès le départ, le code à l’intérieur de la boucle ne sera
jamais exécuté.
La boucle do-while
À l’inverse de while, la boucle do-while garantit que le code sera exécuté au moins une fois.
public static void affiche() {
int chiffre = 0;
do {
System.out.println(chiffre);
chiffre++;
} while (chiffre < 5);
}
La boucle for
La boucle for est idéale pour parcourir un nombre connu d’éléments.
public static void compteJusquaDix() {
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
La boucle for-each
Cette boucle permet de parcourir directement les éléments d’une liste ou d’un tableau.
public static void afficheLangages() {
List<String> langages = Arrays.asList("Java", "Python", "C++");
for (String langage : langages) {
System.out.println(langage);
}
}
3. À vous de jouer : Exercice pratique
Consigne :
1. Déclarez un tableau contenant 7 entiers.
2. Parcourez chaque élément du tableau avec une boucle.
3. Si une valeur est égale à 0, incrémentez une variable cpt.
4. Affichez la valeur de cpt après la boucle.
Solution :
public static void main(String[] args) {
int[] tableau = {26, 10, 1985, 0, 12, 11, 1955};
int cpt = 0;
for (int valeur : tableau) {
if (valeur == 0) {
cpt++;
}
}
System.out.println("Nombre de zéros dans le tableau : " + cpt);
}
Conclusion
Dans ce chapitre, nous avons vu :
1. Comment prendre des décisions avec des conditions (if, else, switch).
2. Comment répéter des actions avec des boucles (while, do-while, for, for-each).
Ces outils sont les piliers de la programmation structurée et vous permettent d’écrire des
programmes plus dynamiques et puissants. Maintenant, passez à la pratique pour maîtriser
ces concepts !
