1

Introduction à Java
Table des matières
Qu'est-ce que Java ? ...............................................................................................................................3
Prérequis essentiels pour le développement Java ................................................................................3
Premier Exemple ......................................................................................................................................4
Règles de nommages en java .................................................................................................................4
Instructions en java ................................................................................................................................5
Affichage sur l'écran ..................................................................................................................... 5
Commentaires .........................................................................................................................................5
Commentaire sur une seule ligne ......................................................................................................5
Commentaire sur une plusieurs lignes ..............................................................................................5
Variables en Java....................................................................................................................................5
Déclarer une variable .........................................................................................................................6
Principaux types primitifs en Java :....................................................................................................6
Opérations sur les variables numériques en Java :............................................................................7
Les "wrappers" (emballages) des types primitifs ..............................................................................7
Chaine de caracteres ..............................................................................................................................9
Lecture au clavier .................................................................................................................................14
Structures conditionnelles en Java......................................................................................................16
Instruction if.................................................................................................................................... 16
Imbrication des instructions if ........................................................................................................ 17
Instruction switch ........................................................................................................................... 17
Structure répétitive ..............................................................................................................................19
while................................................................................................................................................ 19
do while .......................................................................................................................................... 19
for.................................................................................................................................................... 20
Opérateurs de comparaison ................................................................................................................20
Opérateurs logiques .............................................................................................................................21
Les Constantes en Java ........................................................................................................................24
Déclaration de Constantes .............................................................................................................. 24
Avantages des Constantes .............................................................................................................. 24
Utilisation des Constantes .............................................................................................................. 25
Conventions de Nommage ............................................................................................................. 25
Méthodes statiques ...............................................................................................................................25
Variables statiques ...............................................................................................................................28
Tableaux ................................................................................................................................................30
Déclaration de Variables de Tableau : ............................................................................................ 30
Création de Tableaux : .................................................................................................................... 31
Les boucles foreach :....................................................................................................................... 32
2

Tableaux à plusieurs dimensions en Java ....................................................................................... 33

Introduction à la classe java.util.Arrays ............................................................................................34
Méthode sort()................................................................................................................................ 34
Méthode binarySearch() ................................................................................................................. 35
Méthode equals() ........................................................................................................................... 35
Méthode fill() .................................................................................................................................. 35

Qu'est-ce que Java ?

Java est un langage de programmation polyvalent et puissant, souvent utilisé pour développer une
large gamme d'applications, des applications mobiles aux applications d'entreprise en passant par les
jeux vidéo. Il est célèbre pour sa portabilité, sa sécurité et sa facilité d'utilisation.
Contrairement à de nombreux langages de programmation, Java est conçu pour être "write once, run
anywhere" (écrire une fois, exécuter partout). Cela signifie que le code Java peut être écrit une fois et
ensuite exécuté sur n'importe quelle plate-forme qui prend en charge Java, qu'il s'agisse de Windows,
Mac OS, Linux ou même de dispositifs mobiles.
Java est également connu pour sa capacité à créer des applications hautement sécurisées grâce à son
système de gestion de la mémoire, qui empêche les bugs courants tels que les fuites de mémoire et les
violations de l'accès à la mémoire.
3

Prérequis essentiels pour le développement Java

Pour entamer le développement d'applications en Java, vous devez vous assurer de disposer des
éléments suivants :

1. JDK (Java Development Kit) : Le JDK représente l'ensemble d'outils

indispensable pour la création d'applications Java. Il comprend plusieurs composants
primordiaux pour le développement Java :
a. Compilateur Java (javac) : Cet outil convertit le code source Java en code bytecode
Java compilé. Sa fonction principale est de transformer les fichiers .java en fichiers
.class.
b. JRE (Java Runtime Environment) : Le JDK intègre une version du JRE nécessaire
à l'exécution des applications Java. Le JRE englobe la machine virtuelle Java (JVM)
ainsi que les bibliothèques de classes Java requises pour le fonctionnement des
applications.
c. Bibliothèques de classes Java : Le JDK embarque un ensemble exhaustif de
bibliothèques de classes Java standards qui fournissent des fonctionnalités prêtes à
être utilisées pour le développement d'applications Java. Ces bibliothèques incluent
des packages pour la manipulation de chaînes, les opérations d'entrée/sortie, les
collections, le traitement de données, les interfaces graphiques utilisateur (GUI), et
bien d'autres encore.
d. Outils de développement supplémentaires : Outre le compilateur Java, le JDK
comporte divers outils de développement complémentaires tels que javadoc (pour
générer une documentation à partir du code source Java), jdb (pour le débogage Java
en ligne de commande), jar (pour la création de fichiers JAR), et jconsole (pour la
surveillance et la gestion des applications Java en cours d'exécution).
2. Environnement de développement intégré (IDE) : Bien qu'il soit
possible de programmer en Java à l'aide d'un éditeur de texte basique et de la ligne de
commande, il est fortement conseillé d'utiliser un environnement de développement intégré
(EDI) pour optimiser votre efficacité. Des EDI renommés tels qu'Eclipse, IntelliJ IDEA, et
NetBeans, ainsi que des environnements plus légers tels que Visual Studio Code (VSCode),
proposent des fonctionnalités avancées telles que l'auto-complétion du code, le débogage, la
gestion de projet, et bien d'autres encore.

Premier Exemple
- Pour commencer, installez le JDK sur votre système.
- Ensuite, créez un fichier nommé Test.java et ajoutez-y un code simple, par exemple :
public class Test {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}

- Placez-vous dans le dossier où se trouve votre fichier Test.java et ouvrez un terminal.

- Pour compiler votre programme Java, utilisez la commande suivante :
4

javac Test.java
- Si plusieurs versions du JDK sont installées sur votre machine, spécifiez la version en utilisant :
javac -target 8 -version 8 Test.java
- Enfin, pour exécuter le programme et afficher "Hello, world!" dans la console, utilisez la commande
: java Test

Règles de nommages en java

● Pour les classes et les fichiers : Adoptez la convention PascalCase, où le premier caractère de
chaque mot est en majuscule. Par exemple : MyClass, MyFirstProgram.java.
● Pour les variables, les objets et les méthodes : Suivez la convention camelCase, où le premier
mot commence par une minuscule et chaque mot suivant commence par une majuscule. Par
exemple : myVariable, myMethod(), myObject.
● Pour les constantes : Utilisez la convention ScreamingSnakeCase, où tous les caractères sont
en majuscule et séparés par des underscores (_). Par exemple : MAX_SIZE,
DEFAULT_VALUE.
● Pour les noms de projets : Optez pour la convention kebab-case, où les mots sont en
minuscules et séparés par des tirets (-). Par exemple : my-project, java-tutorial.

Instructions en java
● Toute instruction en Java est se termine par un point-virgule (;).
● Bien qu'il soit possible d'écrire plusieurs instructions sur une même ligne, cette pratique est
déconseillée en raison de son impact sur la lisibilité et la maintenance du code.

Affichage sur l'écran

● Pour afficher un message à l'écran, vous devez utiliser la classe System.
5

● La classe System dispose de deux objets pour les opérations d'entrée/sortie (in/out).
● L'objet out propose différentes méthodes d'affichage comme print() et println().

public class AffichageEcran {

public static void main(String[] args) {
// Utilisation de System.out.println pour afficher un message
System.out.println("Bonjour ! Ceci est un message affiché à l'écran.");

// Utilisation de System.out.print pour afficher un message sans saut de ligne

System.out.print("Ceci est ");
System.out.print("une autre ligne ");
System.out.println("de texte affichée sur la même ligne.");
}
}

Commentaires
Commentaire sur une seule ligne
// commentaire

Commentaire sur une plusieurs lignes

/* le commentaire
la suite
et encore la suite
*/

Variables en Java
Une variable est un élément crucial en programmation Java. Elle agit comme un pointeur vers une
zone de mémoire où l'on peut stocker une ou plusieurs données. Ces données peuvent varier en
fonction du type de variable déclarée.
Java étant un langage de programmation fortement typé, il est impératif de spécifier le type de chaque
variable lors de sa déclaration. Une fois déclarée, une variable peut prendre différentes valeurs, mais
elle ne peut pas changer de type tout au long du programme.
Les règles de nommage des variables en Java sont cruciales pour assurer la clarté et la cohérence du
code. Voici les principales directives à suivre :
● Utilisez le CamelCase pour nommer vos variables.
● Le premier caractère doit être une lettre (ni un chiffre ni un $).
● Les espaces ne sont pas autorisés dans les noms de variable.
● Depuis Java 9, l'utilisation de l'underscore (_) comme nom de variable n'est plus autorisée.
● Il est recommandé de choisir des noms de variables en rapport avec le contexte de leur
utilisation.
● Évitez de choisir des mots-clés du langage Java ou d'anciens mots-clés obsolètes tels que
"goto" ou "const". Une liste complète des mots-clés du langage Java est disponible
[ici](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html).
6

● Les noms de variables sont sensibles à la casse, ce qui signifie que "variable" et "Variable"
sont considérés comme deux noms de variables différents.

Déclarer une variable

type nomVariable;
Déclarer une variable en Java consiste à spécifier son type suivi de son nom. Il existe deux options
pour définir le type des variables :
● Pour les types simples (primitifs), le nom du type commence par une lettre minuscule.
● Pour les types objets, le nom du type commence par une lettre majuscule.

Principaux types primitifs en Java :

● byte : représente un entier codé sur 1 octet, pouvant prendre des valeurs entre -128 et 127.
● short : représente un entier codé sur 2 octets, pouvant prendre des valeurs entre -32 768 et 32
767.
● int : représente un entier codé sur 4 octets, pouvant prendre des valeurs entre -2 147 483 648
et 2 147 483 647.
● long : représente un entier codé sur 8 octets, pouvant prendre des valeurs entre -9 223 372 036
854 775 808 et +9 223 372 036 854 775 807.
● float : représente un nombre à virgule codé sur 4 octets.
● double : représente un nombre à virgule codé sur 8 octets.
● boolean : représente une valeur booléenne, soit true soit false (1 octet).
● char : représente un caractère codé sur 2 octets, situé entre deux apostrophes (').

Il n'existe pas de type primitif pour les chaînes de caractères en Java.

Exemple
int x;
Déclarer et initialiser une variable
int x = 5;

Pour les variables numériques (int, float...), voici les opérations disponibles :
● = : utilisé pour l'affectation de valeur à une variable.
● + : utilisé pour l'addition.
- : utilisé pour la soustraction.
● : utilisé pour la multiplication.
● / : utilisé pour la division.
● % : utilisé pour obtenir le reste de la division (modulo).
Quelques raccourcis
● i = i + 1 ⇒ i++;
● i = i - 1 ⇒ i--;
● i = i + 2 ⇒ i += 2;
7

● i = i - 2 ⇒ i -= 2

Exemple de post-incrémentation
int i = 2;
int j = i++;
System.out.println(i); // affiche 3
System.out.println(j); // affiche 2
Exemple de pre-incrémentation
int i = 2;
int j = ++i;
System.out.println(i); // affiche 3
System.out.println(j); // affiche 3

Opérations sur les variables numériques en Java :

Pour convertir le contenu d'une variable (effectuer un cast pour les types compatibles) :
int x = 100;
byte z = (byte) x;
System.out.println(z); // affiche 100
Attention aux valeurs qui dépassent l'intervalle :
int x = 200;
byte z = (byte) x;
System.out.println(z); // affiche -56

Les "wrappers" (emballages) des types primitifs

Les "wrappers" (emballages) des types primitifs (types objets) en Java :
● Byte pour byte
● Short pour short
● Long pour long
● Integer pour int
● Float pour float
● Double pour double
● Boolean pour boolean
● Character pour char
Il existe également d'autres types d'objets tels que String, Date.
Pourquoi utiliser à la fois des types primitifs et des types objets ?
8

Les types primitifs consomment moins de mémoire, tandis que les types objets fournissent un éventail
de méthodes pour manipuler les valeurs : conversion, comptage du nombre de caractères, etc.
Chaque classe wrapper inclut une méthode (TypeObjet.parseTypeSimple(string)) permettant de
convertir une chaîne de caractères en un type primitif de cette classe.
public class Main {
public static void main(String[] args) {
// Exemple avec Integer.parseInt() pour convertir une chaîne en entier
String strNumber = "123";
int number = Integer.parseInt(strNumber);
System.out.println("Le nombre converti en entier est : " + number);

// Exemple avec Double.parseDouble() pour convertir une chaîne en nombre à virgule flottante
String strDouble = "3.14";
double doubleValue = Double.parseDouble(strDouble);
System.out.println("Le nombre converti en double est : " + doubleValue);
}
}

Il n'est pas nécessaire de convertir d'un type simple vers son wrapper (ou inversement) :
Integer j = 2;
int k = j;
System.out.println(k); // affiche 2
int l = 3;
Integer m = l;
System.out.println(m); // affiche 3

Pour déterminer la valeur maximale autorisée par un type numérique :

public class MaxValues {
public static void main(String[] args) {
// Affichage des valeurs maximales pour différents types primitifs
System.out.println("Valeur maximale pour byte : " + Byte.MAX_VALUE);
System.out.println("Valeur maximale pour short : " + Short.MAX_VALUE);
System.out.println("Valeur maximale pour int : " + Integer.MAX_VALUE);
System.out.println("Valeur maximale pour long : " + Long.MAX_VALUE);
System.out.println("Valeur maximale pour float : " + Float.MAX_VALUE);
System.out.println("Valeur maximale pour double : " + Double.MAX_VALUE);
}
}

Voici le code pour la valeur minimale :

public class MinValues {
public static void main(String[] args) {
// Affichage des valeurs minimales pour différents types primitifs
System.out.println("Valeur minimale pour byte : " + Byte.MIN_VALUE);
System.out.println("Valeur minimale pour short : " + Short.MIN_VALUE);
System.out.println("Valeur minimale pour int : " + Integer.MIN_VALUE);
System.out.println("Valeur minimale pour long : " + Long.MIN_VALUE);
System.out.println("Valeur minimale pour float : " + Float.MIN_VALUE);
System.out.println("Valeur minimale pour double : " + Double.MIN_VALUE);
9

}
}

Chaine de caracteres
Une chaîne de caractères, en programmation, est une séquence de caractères regroupés ensemble. En
Java, une chaîne de caractères est représentée par le type de données String et est utilisée pour stocker
et manipuler du texte. Les caractères dans une chaîne de caractères peuvent être des lettres, des
chiffres, des symboles ou des espaces. Les chaînes de caractères sont souvent utilisées pour
représenter des données textuelles telles que des noms, des messages, des descriptions, etc.
Un exemple d'utilisation d'une chaîne de caractères serait de déclarer une variable string de type
String, puis de lui assigner la valeur "bonjour". Ensuite, en utilisant la méthode println de l'objet
System.out, on peut afficher la valeur de la chaîne, qui dans ce cas sera "bonjour".
Il est également possible d'initialiser une chaîne de caractères lors de sa déclaration en utilisant le
constructeur de la classe String. Par exemple, en écrivant String string = new String("bonjour"); ,
nous obtenons le même résultat : la chaîne "bonjour" est affectée à la variable string et affichée ensuite
avec la méthode println.
Une autre manière de créer et d'afficher une chaîne de caractères est de l'initialiser directement lors de
sa déclaration, sans utiliser explicitement le constructeur. Par exemple, String string = "bonjour";
crée une chaîne de caractères contenant "bonjour", qui est ensuite affichée de la même manière avec
println.
Il est à noter que toute chaîne de caractères doit être délimitée par des guillemets ("contenu").
Manipulation des chaînes de caractères avec l'opérateur + en Java
Pour concaténer deux chaînes de caractères, nous utilisons l'opérateur +. Par exemple, si nous avons
deux variables string et string2 contenant respectivement "bon" et "jour", en écrivant
`System.out.println(string + string2);`, nous obtiendrons "bonjour" affiché à l'écran, car les deux
chaînes sont concaténées.
public class Main {
public static void main(String[] args) {
// Exemple d'utilisation d'une chaîne de caractères
String string = new String();
string = "bonjour";
System.out.println(string); // affiche bonjour

// Initialisation d'une chaîne de caractères avec le constructeur

String string2 = new String("bonjour");
System.out.println(string2); // affiche bonjour

// Initialisation d'une chaîne de caractères lors de la déclaration

String string3 = "bonjour";
System.out.println(string3); // affiche bonjour

// Concaténation de deux chaînes de caractères avec l'opérateur +

String string4 = "bon";
String string5 = "jour";
System.out.println(string4 + string5); // affiche bonjour
}
}
10

Voici quelques méthodes de la classe String :

● La méthode length() renvoie le nombre de caractères présents dans la chaîne.
● La méthode indexOf(x) retourne l'indice de la première occurrence de la valeur de x dans la
chaîne, et -1 sinon.
● La méthode contains() renvoie true si la chaîne contient x, sinon false.
● La méthode charAt(i) renvoie le caractère situé à l'indice i dans la chaîne.
● La méthode substring(i, j) permet d'extraire une sous-chaîne de la chaîne à partir de l'indice i
jusqu'à l'indice j - 1.
● La méthode equals(str) compare la chaîne à str et renvoie true en cas d'égalité, sinon false.
● La méthode replace(old, new) permet de remplacer chaque occurrence de la chaîne old dans
la chaîne courante par new, et renvoie la nouvelle chaîne."

public class StringMethodsExample {

public static void main(String[] args) {
// Déclaration et initialisation d'une chaîne de caractères
String str = "Hello, world!";

// Utilisation de la méthode length() pour obtenir la longueur de la chaîne

int length = str.length();
System.out.println("Longueur de la chaîne : " + length);

// Utilisation de la méthode indexOf(x) pour trouver l'indice de la première occurrence de 'o'

int indexOfO = str.indexOf('o');
System.out.println("Indice de la première occurrence de 'o' : " + indexOfO);

// Utilisation de la méthode contains() pour vérifier si la chaîne contient 'world'

boolean containsWorld = str.contains("world");
System.out.println("La chaîne contient 'world' : " + containsWorld);

// Utilisation de la méthode charAt(i) pour obtenir le caractère à l'indice 7

char charAt7 = str.charAt(7);
System.out.println("Caractère à l'indice 7 : " + charAt7);

// Utilisation de la méthode substring(i, j) pour extraire une sous-chaîne de l'indice 7 à l'indice 12

String substring = str.substring(7, 12);
System.out.println("Sous-chaîne de l'indice 7 à l'indice 12 : " + substring);

// Utilisation de la méthode equals(str) pour comparer deux chaînes

String str2 = "Hello, world!";
boolean isEqual = str.equals(str2);
System.out.println("Les chaînes sont égales : " + isEqual);

// Utilisation de la méthode replace(old, new) pour remplacer 'world' par 'Java'

String replacedString = str.replace("world", "Java");
System.out.println("Chaîne après remplacement : " + replacedString);
}
}

Pour convertir une chaîne de caractères en majuscule :

- Vous pouvez utiliser la méthode toUpperCase() de la classe String. Par exemple :

System.out.println("bonjour".toUpperCase()); // affiche BONJOUR

11

Pour convertir un caractère en majuscule :

- Utilisez la méthode toUpperCase() de la classe Character. Par exemple :

System.out.println(Character.toUpperCase('a')); // affiche A

Exemple d'utilisation de replace(old, new) :

- Vous pouvez remplacer une sous-chaîne par une autre dans une chaîne donnée en utilisant la
méthode replace(). Par exemple :

String string = "bonjour les bons jours";

String string2 = string.replace("jour", "soir");
System.out.println(string2); // bonsoir les bons soirs

Exemple d'utilisation de indexOf(str, fromIndex) :

- Pour trouver l'indice de la première occurrence d'une sous-chaîne à partir d'un index spécifique,
utilisez la méthode indexOf(). Par exemple :

String string = "bonjour les bons jours";

int pos = string.indexOf("bon", 5);
System.out.println(pos); // affiche 12

Exemple d'utilisation de split(regex) :

- Pour diviser une chaîne en sous-chaînes en utilisant un motif (regex) comme délimiteur, utilisez la
méthode split(). Par exemple :

String string = "bonjour les bons jours";

System.out.println(Arrays.toString(string.split(" "))); // affiche [bonjour, les, bons, jours]

Quatre méthodes pour convertir un entier en une chaîne de caractères :

- Vous pouvez utiliser l'une des méthodes suivantes pour convertir un entier en une chaîne de
caractères. Par exemple :

int y = 3;
String chaine = ((Integer) y).toString();
System.out.println(chaine); // affiche 3

int z = 4;
String str = Integer.toString(z);
System.out.println(str); // affiche 4

int t = 5;
String s = String.valueOf(t);
System.out.println(s); // affiche 5

int u = 6;
String s = "" + u;
System.out.println(s); // affiche 6

import java.util.Arrays;
12

public class StringMethodsExample {

public static void main(String[] args) {
// Convertir une chaîne de caractères en majuscule
System.out.println("Convertir une chaîne de caractères en majuscule :");
System.out.println("bonjour".toUpperCase()); // affiche BONJOUR
System.out.println();

// Convertir un caractère en majuscule

System.out.println("Convertir un caractère en majuscule :");
System.out.println(Character.toUpperCase('a')); // affiche A
System.out.println();

// Exemple d'utilisation de replace(old, new)

System.out.println("Exemple d'utilisation de replace(old, new) :");
String string = "bonjour les bons jours";
String string2 = string.replace("jour", "soir");
System.out.println(string2); // bonsoir les bons soirs
System.out.println();

// Exemple d'utilisation de indexOf(str, fromIndex)

System.out.println("Exemple d'utilisation de indexOf(str, fromIndex) :");
int pos = string.indexOf("bon", 5);
System.out.println(pos); // affiche 12
System.out.println();

// Exemple d'utilisation de split(regex)

System.out.println("Exemple d'utilisation de split(regex) :");
System.out.println(Arrays.toString(string.split(" "))); // [bonjour, les, bons, jours]
System.out.println();

// Quatre méthodes pour convertir un entier en une chaîne de caractères

System.out.println("Quatre méthodes pour convertir un entier en une chaîne de caractères :");
int y = 3;
String chaine = ((Integer) y).toString();
System.out.println(chaine); // affiche 3

int z = 4;
String str = Integer.toString(z);
System.out.println(str); // affiche 4

int t = 5;
String s = String.valueOf(t);
System.out.println(s); // affiche 5

int u = 6;
String s2 = "" + u;
System.out.println(s2); // affiche 6
}
}

Il est également possible d'utiliser les méthodes statiques de la classe Math pour effectuer des
opérations mathématiques courantes :

● Math.abs(x) : Retourne la valeur absolue de x.

● Math.pow(x, y) : Retourne x élevé à la puissance y.
● Math.max(x, y) : Retourne le plus grand des deux nombres x et y.
● Math.min(x, y) : Retourne le plus petit des deux nombres x et y.
● Math.sqrt(x) : Retourne la racine carrée de x.
13

● Math.floor(x), Math.ceil(x) et Math.round(x) : Retournent l'arrondi de x à l'entier le plus

proche.

public class MathMethodsExample {

public static void main(String[] args) {
// Utilisation des méthodes statiques de la classe Math
System.out.println("Exemples avec les méthodes statiques de la classe Math :");
System.out.println("Valeur absolue de -5 : " + Math.abs(-5)); // affiche 5
System.out.println("2 puissance 3 : " + Math.pow(2, 3)); // affiche 8.0
System.out.println("Max entre 5 et 8 : " + Math.max(5, 8)); // affiche 8
System.out.println("Min entre 5 et 8 : " + Math.min(5, 8)); // affiche 5
System.out.println("Racine carrée de 16 : " + Math.sqrt(16)); // affiche 4.0

// Exemples d'arrondis
System.out.println("\nExemples d'arrondis :");
System.out.println("Arrondi de 1.9 : " + Math.round(1.9)); // affiche 2
System.out.println("Arrondi de 1.5 : " + Math.round(1.5)); // affiche 2
System.out.println("Arrondi de 1.4 : " + Math.round(1.4)); // affiche 1
System.out.println("Plafond de 1.9 : " + Math.ceil(1.9)); // affiche 2.0
System.out.println("Plafond de 1.5 : " + Math.ceil(1.5)); // affiche 2.0
System.out.println("Plafond de 1.4 : " + Math.ceil(1.4)); // affiche 2.0
System.out.println("Plancher de 1.9 : " + Math.floor(1.9)); // affiche 1.0
System.out.println("Plancher de 1.5 : " + Math.floor(1.5)); // affiche 1.0
System.out.println("Plancher de 1.4 : " + Math.floor(1.4)); // affiche 1.0
}
}

Depuis Java 1.5, il est possible d'importer statiquement la classe Math pour utiliser ses méthodes sans préfixe :

import static java.lang.Math.*;

public class MathOperations {

public static void main(String[] args) {
System.out.println(round(1.9)); // affiche 2
System.out.println(round(1.5)); // affiche 2
System.out.println(round(1.4)); // affiche 1
System.out.println(ceil(1.9)); // affiche 2
System.out.println(ceil(1.5)); // affiche 2
System.out.println(ceil(1.4)); // affiche 2
System.out.println(floor(1.9)); // affiche 1
System.out.println(floor(1.5)); // affiche 1
System.out.println(floor(1.4)); // affiche 1
}
}

Cela permet d'utiliser directement les méthodes de la classe Math sans spécifier le préfixe "Math.".

Lecture au clavier

Pour lire une valeur saisie par l'utilisateur dans la console, on utilise la classe Scanner. Il est nécessaire
de spécifier le type de la valeur à récupérer.
Pour instancier la classe Scanner, on crée une nouvelle instance de Scanner en utilisant System.in
comme argument :
14

Scanner scanner = new Scanner(System.in);

Si la classe Scanner est signalée en rouge, cela indique qu'elle doit être importée. On l'importe en
ajoutant la déclaration :
import java.util.Scanner;
Un exemple de lecture d'un entier peut être réalisé ainsi :
int i = scanner.nextInt();
Il est important de fermer le scanner une fois que l'on a fini de l'utiliser pour libérer les ressources :
scanner.close();
Remarques :
● Pour lire une chaîne de caractères, on utilise la méthode next() ou nextLine().
● Pour lire un nombre réel, on utilise la méthode nextFloat().
Exemple avec next() :
Scanner scanner = new Scanner(System.in);
// Si on saisit "bonjour tout le monde"
String string = scanner.next();
System.out.println(string);
// Affiche bonjour

Exemple avec nextLine() :

Scanner scanner = new Scanner(System.in);
// Si on saisit "bonjour tout le monde"
String string = scanner.nextLine();
System.out.println(string);
// Affiche bonjour tout le monde

À chaque appel à next(), on récupère le prochain token :

Scanner scanner = new Scanner(System.in);
// Si on saisit "bonjour tout le monde"
String string = scanner.next();
String s = scanner.next();
System.out.println(s);
// Affiche tout
15

Le code suivant déclenche une exception car on ne peut pas affecter la chaîne "tout" à un entier :
Scanner scanner = new Scanner(System.in);
// Si on saisit "bonjour tout le monde"
String string = scanner.next();
int v = scanner.nextInt();
System.out.println(v);

Il n'existe pas de méthode spécifique pour les caractères, mais on peut faire :
Scanner scanner = new Scanner(System.in);
String string = scanner.next();
char c = scanner.next().charAt(0);
System.out.println(c);

import java.util.Scanner;

public class LectureSaisie {

public static void main(String[] args) {
// Lecture d'une chaîne de caractères avec next()
Scanner scanner = new Scanner(System.in);
System.out.print("Saisissez une chaîne de caractères : ");
String string = scanner.next();
System.out.println("Vous avez saisi : " + string);

// Lecture d'une chaîne de caractères avec nextLine()

System.out.print("Saisissez une autre chaîne de caractères : ");
scanner.nextLine(); // Pour consommer le retour à la ligne
String string2 = scanner.nextLine();
System.out.println("Vous avez saisi : " + string2);

// Lecture d'un nombre réel avec nextFloat()

System.out.print("Saisissez un nombre réel : ");
float floatValue = scanner.nextFloat();
System.out.println("Vous avez saisi : " + floatValue);

// Lecture d'un caractère avec next().charAt(0)

System.out.print("Saisissez un caractère : ");
char charValue = scanner.next().charAt(0);
System.out.println("Vous avez saisi : " + charValue);

// Fermeture du scanner
scanner.close();
}
}

Structures conditionnelles en Java

Une structure de contrôle est tout mécanisme qui s'écarte de l'exécution linéaire par défaut :
16

● sélection
• instructions if
• instructions switch
● itération
• boucles while (non bornées)
• boucles for
• itération sur des collections
● autres
• appel/retour
• exceptions
• continuations

Un bloc d’instructions est une suite d’instructions délimitées par des accolades {}.

{
/* suite d’instructions en tout genre */
}

Remarque : Un bloc d’instructions peut remplacer une instruction simple.

Instruction if
if (expression)
{
/* bloc d’instructions 1 */
}
else
{
/* bloc d’instructions 2 */
}
Si l'expression est vraie, le bloc d’instructions 1 est exécuté, sinon le bloc d’instructions 2 est exécuté.
import java.util.Scanner;

public class Max {

public static void main(String[] args) {
float x, y;
Scanner scanner = new Scanner(System.in);

System.out.println("Entrez deux nombres flottants : ");

x = scanner.nextFloat();
17

y = scanner.nextFloat();

if (x < y)
System.out.println("max = " + y);
else
System.out.println("max = " + x);

scanner.close(); // Fermer le scanner pour éviter les fuites de ressources

}
}

Imbrication des instructions if

Le programme suivant affiche le mot 'ordonné' si trois nombres, a, b et c, sont ordonnés de manière
croissante ou égale. Sinon, il affiche 'non ordonné'.

public class OrdreNumerique {

public static void main(String[] args) {
int a = 5;
int b = 7;
int c = 10;

if (a <= b) {
if (b <= c) {
System.out.println("ordonné");
} else {
System.out.println("non ordonné");
}
} else {
System.out.println("non ordonné");
}
}
}
Ce code vérifie d'abord si a est inférieur ou égal à b. Si c'est le cas, il vérifie ensuite si b est inférieur
ou égal à c. Si ces conditions sont toutes deux vraies, il affiche "ordonné". Sinon, il affiche "non
ordonné".

Instruction switch
Le switch est une structure multibranchement dans laquelle une valeur est comparée à plusieurs
constantes.
switch (expression) {
case exp1:
BlocInstruction1;
break;
case exp2:
BlocInstruction2;
break;
18

.
.
.
case expN:
BlocInstructionN;
break;
default:
BlocInstruction;
}

Remarques :
- L’instruction break est nécessaire pour un choix exclusif.
- L’utilisation de default est optionnelle.
- Tous les cas doivent être différents.
- Les expi doivent être des entiers (ie de type int ou char).

import java.util.Scanner;

public class Default {

public static void main(String[] args) {
int n;
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre entier : ");
n = scanner.nextInt();
switch (n) {
case 0:
System.out.println("nul");
break;
case 1:
System.out.println("un");
break;
default:
System.out.println("grand");
}
System.out.println("Au revoir");
}
}

Structure répétitive

Ces structures permettent de répéter un certain nombre de fois un ensemble de commandes.

19

while
while (expression) {
/* bloc d’instructions */
}
Le bloc d’instructions est exécuté tant que l'expression est vraie.

import java.util.Scanner;

public class While1 {

public static void main(String[] args) {
int n, somme;
somme = 0;
Scanner scanner = new Scanner(System.in);
while (somme < 100) {
System.out.print("Entrez un nombre : ");
n = scanner.nextInt();
somme += n;
}
System.out.println("Somme obtenue : " + somme);
scanner.close();
}
}

do while
do {
/* bloc d’instructions */
} while (expression);

Remarque : Le bloc d’instructions est exécuté au moins une fois.

Exemple :
import java.util.Scanner;

public class Do1 {

public static void main(String[] args) {
int n;
Scanner scanner = new Scanner(System.in);
do {
System.out.print("Entrez un nombre > 0 : ");
n = scanner.nextInt();
System.out.println("Vous avez fourni " + n);
} while (n <= 0);
System.out.println("Réponse correcte");
20

scanner.close();
}
}

for

for (exp1, exp2, exp3) {

/* bloc d’instructions */
}
Où :
- exp1 : initialisation d’une variable de contrôle, aussi appelée index.
- exp2 : expression conditionnelle définissant la condition d’arrêt de la boucle.
- exp3 : une ou des expressions modifiant l’index.
Remarques :
- Cette syntaxe peut être équivalente dans certains cas à while.
- Il est possible d’omettre exp1, exp2 ou exp3, mais les ; restent obligatoires.
Exemple :
public class For1 {
public static void main(String args[]) {
for (int i = 1; i <= 5; i++) {
System.out.println("Bonjour " + i + " fois");
}
}
}

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs. Ils sont très utiles pour
prendre des décisions dans les structures conditionnelles comme `if`, `switch`, et les boucles. Voici les
opérateurs de comparaison en Java :
- == (égal à) : Vérifie si deux valeurs sont égales.
- != (différent de) : Vérifie si deux valeurs sont différentes.
- > (supérieur à) : Vérifie si la valeur de gauche est supérieure à celle de droite.
- < (inférieur à) : Vérifie si la valeur de gauche est inférieure à celle de droite.
- >= (supérieur ou égal à) : Vérifie si la valeur de gauche est supérieure ou égale à celle de droite.
- <= (inférieur ou égal à) : Vérifie si la valeur de gauche est inférieure ou égale à celle de droite.
21

Exemple :

int x = 5;
int y = 10;

if (x == y) {
System.out.println("x est égal à y");
} else if (x > y) {
System.out.println("x est supérieur à y");
} else {
System.out.println("x est inférieur à y");
}

Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner des expressions conditionnelles. Ils sont souvent
utilisés dans les structures conditionnelles et les boucles. Voici les opérateurs logiques en Java :
- && (ET logique) : Renvoie `true` si les deux expressions sont vraies.
- || (OU logique) : Renvoie `true` si au moins une des expressions est vraie.
- ! (NON logique) : Inverse la valeur booléenne de l'expression.

Exemple :
int age = 18;
boolean estMajeur = age >= 18;
boolean aPayer = false;

if (estMajeur && !aPayer) {

System.out.println("Vous pouvez entrer gratuitement.");
} else {
System.out.println("Vous devez payer l'entrée.");
}
22

Dans cet exemple, la condition estMajeur && !aPayer est évaluée à true si estMajeur est true (l'âge est
supérieur ou égal à 18) et aPayer est false (la personne n'a pas encore payé).

Vous pouvez également combiner les opérateurs de comparaison et les opérateurs logiques pour créer
des expressions conditionnelles plus complexes.

import java.util.Scanner;

public class IfElseExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Entrez un nombre entier : ");

int number = scanner.nextInt();

if (number % 2 == 0) {
System.out.println("Le nombre saisi est pair.");
} else {
System.out.println("Le nombre saisi est impair.");
}

scanner.close();
}
}

import java.util.Scanner;

public class SwitchExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.println("Choisissez une option :");

System.out.println("1. Afficher 'Bonjour'");
System.out.println("2. Afficher 'Bonsoir'");
System.out.println("3. Afficher 'Bonne nuit'");
System.out.print("Votre choix : ");
int choice = scanner.nextInt();

switch (choice) {
case 1:
System.out.println("Bonjour");
break;
case 2:
System.out.println("Bonsoir");
break;
case 3:
System.out.println("Bonne nuit");
break;
default:
System.out.println("Option invalide");
}

scanner.close();
}
}
23

public class ForLoopExample {

public static void main(String[] args) {
// Utilisation de la boucle for pour afficher les nombres de 1 à 5
for (int i = 1; i <= 5; i++) {
System.out.println("Nombre : " + i);
}
}
}

import java.util.Scanner;

public class WhileLoopExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int sum = 0;
int number;

// Utilisation d'une boucle while pour calculer la somme des nombres saisis par l'utilisateur
System.out.println("Entrez des nombres entiers (saisissez 0 pour arrêter) :");
while ((number = scanner.nextInt()) != 0) {
sum += number;
}

System.out.println("La somme des nombres saisis est : " + sum);

scanner.close();
}
}

public class BreakContinueExample {

public static void main(String[] args) {
// Exemple d'utilisation de l'instruction break
System.out.println("Exemple d'utilisation de l'instruction break :");
for (int i = 1; i <= 5; i++) {
if (i == 3) {
System.out.println("Arrêt de la boucle à i = 3");
break; // Arrête la boucle lorsqu'i est égal à 3
}
System.out.println("i = " + i);
}

// Exemple d'utilisation de l'instruction continue

System.out.println("\nExemple d'utilisation de l'instruction continue :");
for (int j = 1; j <= 5; j++) {
if (j == 2 || j == 4) {
System.out.println("Ignorer l'itération à j = " + j);
continue; // Passe à l'itération suivante lorsque j est égal à 2 ou 4
}
System.out.println("j = " + j);
}
}
}

import java.util.Scanner;

public class DoWhileExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int nombre;
24

do {
System.out.print("Entrez un nombre positif : ");
nombre = scanner.nextInt();
if(nombre <= 0) {
System.out.println("Le nombre saisi doit être positif !");
}
} while(nombre <= 0);

System.out.println("Merci ! Vous avez saisi un nombre positif.");

scanner.close();
}
}

Les Constantes en Java

En Java, une constante est une variable dont la valeur ne peut pas être modifiée une fois qu'elle a été
assignée. Les constantes sont déclarées à l'aide du mot-clé `final`, ce qui indique que leur valeur est
définitive.

Déclaration de Constantes
En Java, les constantes peuvent être déclarées de deux manières principales :
1. Constantes de type primitif : Ces constantes sont des valeurs immuables de types de données
primitifs tels que int, double, char, boolean, etc.
final int MAX_SIZE = 100;
final double PI = 3.14159;
final char YES_OPTION = 'Y';
final boolean DEBUG_MODE = false;
2. Constantes d'objet : Ces constantes sont des références immuables à des objets, généralement des
chaînes de caractères.
final String COMPANY_NAME = "Acme Corporation";
final String GREETING_MESSAGE = "Welcome to our website!";

Avantages des Constantes

- Clarté du Code : En utilisant des constantes, vous pouvez rendre votre code plus lisible et
compréhensible en remplaçant les valeurs littérales par des noms significatifs.
- Facilité de Maintenance : Les constantes facilitent la maintenance du code en centralisant les
valeurs qui pourraient être modifiées à l'avenir.
25

Utilisation des Constantes

Les constantes peuvent être utilisées dans tout le code de la même manière que les variables, mais leur
valeur ne peut pas être modifiée une fois qu'elles sont initialisées.
public class ConstantExample {
public static void main(String[] args) {
final double TAX_RATE = 0.08;
final int MAX_ATTEMPTS = 3;

// Utilisation des constantes

double totalPrice = 100.0;
double taxAmount = totalPrice * TAX_RATE;
int remainingAttempts = MAX_ATTEMPTS - 1;

System.out.println("Tax Amount: " + taxAmount);

System.out.println("Remaining Attempts: " + remainingAttempts);
}
}

Dans cet exemple, TAX_RATE et MAX_ATTEMPTS sont des constantes qui sont utilisées pour
calculer la taxe sur un prix et pour suivre le nombre d'essais restants, respectivement.

Conventions de Nommage
Il est courant d'écrire le nom des constantes en lettres majuscules, avec des mots séparés par des
underscores, pour les distinguer des variables normales.

Méthodes statiques

Une méthode statique est une méthode qui peut être utilisée sans avoir besoin d'instancier un objet de
la classe à laquelle elle appartient. Cependant, une méthode statique appartient toujours à une classe et
sa définition est donnée à l'intérieur de la définition de la classe.
Lorsqu'une méthode statique est définie, le mot-clé `static` est placé dans l'en-tête de la méthode,
comme ceci :
public static typeDeRetour nomDeLaMethode(parametres) {
// corps de la méthode
}
Les méthodes statiques sont invoquées en utilisant le nom de la classe à laquelle elles appartiennent,
au lieu d'utiliser un objet. Par exemple :
valeurDeRetour = NomDeLaClasse.nomDeLaMethode(arguments);

Quelques points importants sur les méthodes statiques :

● Elles peuvent être appelées sans créer d'instance de la classe.

26

● Elles ne peuvent pas accéder ni modifier les variables d'instance non statiques de la classe (car
elles n'ont pas d'instance associée).
● Elles peuvent accéder et modifier les variables statiques de la classe.
● Elles sont généralement utilisées pour des fonctionnalités qui ne dépendent pas de l'état d'un
objet spécifique.
● Elles sont souvent utilisées pour des méthodes utilitaires, comme les méthodes
mathématiques, de conversion, de validation, etc.
Exemple :
public class MaClasse {
private int valeur; // variable d'instance non statique

public static int multiplier(int a, int b) {

// Cette méthode est statique et ne peut pas accéder à "valeur"
return a * b;
}

public int getValeur() {

return valeur;
}

public void setValeur(int valeur) {

this.valeur = valeur;
}
}

// Utilisation de la méthode statique

int resultat = MaClasse.multiplier(3, 4); // resultat vaut 12

Dans cet exemple, la méthode multiplier est statique et peut être appelée directement avec le nom de la
classe MaClasse, sans avoir besoin de créer une instance de la classe. Cependant, cette méthode ne
peut pas accéder ni modifier la variable d'instance non statique `valeur`.
Piège : Appeler une méthode non statique depuis une méthode statique
● Une méthode statique ne peut pas faire référence à une variable d'instance de la classe, et elle
ne peut pas non plus invoquer une méthode non statique de la classe.
● Une méthode statique n'a pas de contexte d'instance (this), donc elle ne peut pas utiliser une
variable d'instance ou une méthode qui a un this implicite ou explicite pour un objet appelant.
● Une méthode statique peut invoquer une autre méthode statique, cependant.
Lorsqu'une méthode statique tente d'accéder à une variable d'instance ou d'invoquer une méthode non
statique, le compilateur Java génère une erreur. Cela est dû au fait qu'une méthode statique n'est pas
liée à une instance particulière de la classe, donc elle ne peut pas accéder aux membres d'instance.
Exemple d'erreur :

public class MaClasse {

private int valeur; // variable d'instance

public static void afficherValeur() {

System.out.println(valeur); // Erreur de compilation
27

public void setValeur(int valeur) {

this.valeur = valeur; // Cette méthode est non statique, donc elle peut accéder à "valeur"
}
}

Dans cet exemple, la méthode afficherValeur() est statique et tente d'accéder à la variable d'instance
valeur. Cela génère une erreur de compilation, car une méthode statique ne peut pas accéder aux
variables d'instance.
Pour résoudre ce problème, vous pouvez soit rendre la méthode afficherValeur() non statique, soit
passer la valeur de valeur en argument à la méthode statique.
Il est important de bien comprendre cette distinction entre les méthodes statiques et non statiques pour
éviter les erreurs de compilation et les comportements inattendus dans votre code Java.

Astuce : Vous pouvez placer une méthode main() dans n'importe quelle classe
Bien que la méthode main() soit souvent placée seule dans une classe distincte des autres classes d'un
programme, elle peut également être contenue dans la définition d'une classe régulière.
- De cette façon, la classe dans laquelle elle est contenue peut être utilisée pour créer des objets dans
d'autres classes, ou elle peut être exécutée en tant que programme.
- Une méthode main() incluse dans une définition de classe régulière est particulièrement utile
lorsqu'elle contient du code de diagnostic pour la classe.
En Java, la méthode main() est le point d'entrée du programme. Cependant, rien n'empêche de l'inclure
dans une classe qui définit également d'autres méthodes et variables. Cette approche peut être
bénéfique dans les situations suivantes :
1. Tester une classe spécifique: Vous pouvez inclure du code de test ou de diagnostic dans la
méthode main() de la classe que vous voulez tester, ce qui facilite le débogage et la validation de cette
classe.
2. Exécuter une classe en tant que programme autonome: Si vous avez une classe qui peut être
exécutée de manière autonome, vous pouvez inclure une méthode main() dans cette classe, ce qui vous
permettra de l'exécuter directement sans avoir besoin d'une classe principale séparée.
3. Regrouper des fonctionnalités liées: Si vous avez un ensemble de fonctionnalités étroitement
liées, vous pouvez les regrouper dans une seule classe, y compris la méthode main(), pour avoir un
programme autonome et cohérent.

Exemple :
public class Calculatrice {
public static int additionner(int a, int b) {
return a + b;
}

public static int soustraire(int a, int b) {

return a - b;
}
28

public static void main(String[] args) {

int resultat1 = additionner(3, 4);
int resultat2 = soustraire(10, 7);
System.out.println("Résultat de l'addition : " + resultat1);
System.out.println("Résultat de la soustraction : " + resultat2);
}
}

Dans cet exemple, la classe Calculatrice contient des méthodes statiques pour l'addition et la
soustraction, ainsi qu'une méthode main() qui les utilise et affiche les résultats. Cette classe peut être
exécutée directement comme un programme autonome.
Bien que cette approche soit possible, il est souvent recommandé de séparer la méthode main() dans
une classe distincte pour une meilleure organisation et une meilleure maintenabilité du code, surtout
pour les programmes plus importants.
public class MathUtil {

// Méthode statique pour calculer la factorielle d'un nombre

public static int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}

public static void main(String[] args) {

int number = 5;
int result = MathUtil.factorial(number);
System.out.println("Factorielle de " + number + " = " + result);
}
}

Variables statiques

Une variable statique est une variable qui appartient à la classe dans son ensemble, et non à une
instance particulière d'objet.
- Il n'y a qu'une seule copie d'une variable statique par classe, contrairement aux variables d'instance
où chaque objet a sa propre copie.
- Tous les objets de la classe peuvent lire et modifier une variable statique.
- Bien qu'une méthode statique ne puisse pas accéder à une variable d'instance, elle peut accéder à une
variable statique.
- Une variable statique est déclarée comme une variable d'instance, avec l'ajout du modificateur static:
private static int maVariableStatique;
Les variables statiques peuvent être déclarées et initialisées en même temps :
private static int maVariableStatique = 0;
29

- Si elle n'est pas explicitement initialisée, une variable statique sera automatiquement initialisée avec
une valeur par défaut :
- Les variables statiques de type boolean sont initialisées à false.
- Les variables statiques de types primitifs sont initialisées à la valeur zéro de leur type.
- Les variables statiques de type classe sont initialisées à null.
- Il est toujours préférable d'initialiser explicitement les variables statiques plutôt que de compter sur
l'initialisation par défaut.
Une variable statique doit toujours être déclarée private, sauf si elle est aussi une constante définie.
- La valeur d'une constante statique définie ne peut pas être modifiée, donc il est sûr de la rendre
public.
- En plus du mot-clé static, la déclaration d'une constante statique définie doit inclure le modificateur
final qui indique que sa valeur ne peut pas être changée :

public static final int ANNEE_NAISSANCE = 1954;

- Lorsque vous faites référence à une telle constante définie en dehors de sa classe, utilisez le nom de
sa classe au lieu d'un objet appelant :

int annee = MaClasse.ANNEE_NAISSANCE;

Les variables statiques sont utiles lorsque vous avez besoin de partager des données entre toutes les
instances d'une classe, ou lorsque vous avez des valeurs constantes liées à la classe. Cependant, il faut
les utiliser avec précaution, car elles peuvent introduire des effets de bord indésirables si elles sont
modifiées de manière inattendue.

public class Counter {

// Variable statique pour compter le nombre d'instances créées

private static int instanceCount = 0;

// Méthode pour obtenir le nombre d'instances créées

public static int getInstanceCount() {
return instanceCount;
}

// Constructeur pour incrémenter le compteur d'instances

public Counter() {
instanceCount++;
}

public static void main(String[] args) {

// Création de plusieurs instances de Counter
Counter c1 = new Counter();
Counter c2 = new Counter();
30

Counter c3 = new Counter();

// Affichage du nombre total d'instances créées

System.out.println("Nombre total d'instances créées : " + Counter.getInstanceCount());
}
}

public class SharedVariableExample {

// Déclaration d'une variable statique pour stocker une valeur partagée

private static int sharedValue = 0;

// Méthode statique pour accéder à la valeur partagée

public static int getSharedValue() {
return sharedValue;
}

// Méthode statique pour modifier la valeur partagée

public static void setSharedValue(int value) {
sharedValue = value;
}

public static void main(String[] args) {

// Accès et modification de la valeur partagée à partir de différentes instances
SharedVariableExample instance1 = new SharedVariableExample();
SharedVariableExample instance2 = new SharedVariableExample();

instance1.setSharedValue(5);
System.out.println("Valeur partagée après modification par instance1 : " + instance2.getSharedValue());

instance2.setSharedValue(10);
System.out.println("Valeur partagée après modification par instance2 : " + instance1.getSharedValue());
}
}

Tableaux
En Java, on utilise une structure de données appelée "array" (tableau) pour stocker une collection
séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection
de données, mais il est souvent plus utile de le considérer comme une collection de variables du même
type.
Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ..., et nombre99, vous
déclarez une seule variable de tableau telle que "nombres" et utilisez nombres[0], nombres[1], et ...,
nombres[99] pour représenter les variables individuelles.

Déclaration de Variables de Tableau :

Pour utiliser un tableau dans un programme, vous devez déclarer une variable pour référencer le
tableau et spécifier le type de tableau que la variable peut référencer. Voici la syntaxe pour déclarer
une variable de tableau :
typeDeDonnées[] nomRefTableau; // manière préférée.
ou
typeDeDonnées nomRefTableau[]; // fonctionne mais pas la manière préférée.
31

Remarque : La syntaxe "typeDeDonnées[] nomRefTableau" est préférée. La syntaxe "typeDeDonnées

nomRefTableau[]" vient des langages C/C++ et a été adoptée en Java pour accommoder les
programmeurs C/C++.
Exemple :
Les extraits de code suivants sont des exemples de cette syntaxe :
double[] maListe; // manière préférée.
ou
double maListe[]; // fonctionne mais pas la manière préférée.

Création de Tableaux :
Vous pouvez créer un tableau en utilisant l'opérateur "new" avec la syntaxe suivante :

nomRefTableau = new typeDeDonnées[tailleDuTableau];

La déclaration ci-dessus fait deux choses :

Elle crée un tableau en utilisant "new typeDeDonnées[tailleDuTableau]";
Elle assigne la référence du tableau nouvellement créé à la variable nomRefTableau.
La déclaration d'une variable de tableau, la création d'un tableau et l'assignation de la référence du
tableau à la variable peuvent être combinées en une seule instruction, comme illustré ci-dessous :

typeDeDonnées[] nomRefTableau = new typeDeDonnées[tailleDuTableau];

Alternativement, vous pouvez créer des tableaux comme suit :

typeDeDonnées[] nomRefTableau = {valeur0, valeur1, ..., valeurk};

Les éléments du tableau sont accessibles via l'indice. Les indices de tableau commencent à 0 ; c'est-à-
dire qu'ils commencent
Example:
Following statement declares an array variable, myList, creates an array of 10 elements of double
type and assigns its reference to myList:
double[] myList = new double[10];
32

L'image suivante représente le tableau myList. Ici, myList contient dix valeurs de type double et les
indices vont de 0 à 9.
Lorsque nous traitons les éléments d'un tableau, nous utilisons souvent soit une boucle for, soit une
boucle foreach, car tous les éléments d'un tableau sont du même type et la taille du tableau est connue.
Exemple :
Voici un exemple complet montrant comment créer, initialiser et traiter des tableaux :
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Afficher tous les éléments du tableau
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Somme de tous les éléments
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total est " + total);
// Recherche de l'élément le plus grand
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max est " + max);
}
}

Les boucles foreach :

JDK 1.5 a introduit une nouvelle boucle for appelée boucle foreach ou boucle améliorée, qui vous
permet de parcourir le tableau complet séquentiellement sans utiliser de variable d'index.
33

Exemple :
Le code suivant affiche tous les éléments du tableau myList :
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Afficher tous les éléments du tableau
for (double element: myList) {
System.out.println(element);
}
}
}

Tout comme vous pouvez passer des valeurs de type primitif aux méthodes, vous pouvez également
passer des tableaux aux méthodes. Par exemple, la méthode suivante affiche les éléments dans un
tableau d'entiers :
public static void printArray(int[] tableau) {
for (int i = 0; i < tableau.length; i++) {
System.out.print(tableau[i] + " ");
}
}
Vous pouvez l'invoquer en passant un tableau. Par exemple, l'instruction suivante invoque la méthode
printArray pour afficher 3, 1, 2, 6, 4 et 2 :
printArray(new int[]{3, 1, 2, 6, 4, 2});
Renvoyer un tableau à partir d'une méthode :
Une méthode peut également renvoyer un tableau. Par exemple, la méthode ci-dessous renvoie un
tableau qui est l'inversion d'un autre tableau :

public static int[] reverse(int[] liste) {

int[] resultat = new int[liste.length];
for (int i = 0, j = resultat.length - 1; i < liste.length; i++, j--) {
resultat[j] = liste[i];
}
return resultat;
}

Tableaux à plusieurs dimensions en Java

En plus des tableaux unidimensionnels, Java prend également en charge les tableaux à plusieurs
dimensions. Un tableau à plusieurs dimensions est une collection de tableaux unidimensionnels. Les
tableaux à deux dimensions sont les plus couramment utilisés, mais Java prend en charge jusqu'à 255
dimensions.
34

La syntaxe pour déclarer un tableau à plusieurs dimensions est la suivante :

typeDeDonnées[][] nomTableau;

Voici un exemple de déclaration d'un tableau à deux dimensions :

int[][] tableau2D;
Les tableaux à plusieurs dimensions peuvent être initialisés de différentes manières. Voici un exemple
d'initialisation d'un tableau à deux dimensions avec des valeurs prédéfinies :
int[][] tableau2D = { {1, 2, 3}, {4, 5, 6} };

Vous pouvez également initialiser un tableau à deux dimensions avec une taille spécifique en utilisant
l'opérateur `new`, par exemple :
int[][] tableau2D = new int[5][5];

Les éléments d'un tableau à plusieurs dimensions sont accessibles en spécifiant les indices pour chaque
dimension. Par exemple, pour accéder à l'élément à la première ligne et deuxième colonne d'un tableau
à deux dimensions, vous pouvez utiliser :
int valeur = tableau2D[0][1];

Voici un exemple complet illustrant la déclaration, l'initialisation et l'accès aux éléments d'un tableau à
deux dimensions :
public class Tableau2D {
public static void main(String[] args) {
// Déclaration et initialisation d'un tableau à deux dimensions
int[][] tableau2D = { {1, 2, 3}, {4, 5, 6} };

// Accès aux éléments et affichage

System.out.println("Elément à la première ligne et deuxième colonne : " + tableau2D[0][1]);
}
}

Introduction à la classe java.util.Arrays

La classe `java.util.Arrays` fournit des méthodes statiques pour trier et rechercher des tableaux,
comparer des tableaux et remplir les éléments d'un tableau. Ces méthodes sont surchargées pour tous
les types primitifs.

Méthode sort()
La méthode sort() permet de trier un tableau dans l'ordre croissant. Voici un exemple
35

import java.util.Arrays;

public class ArraysDemo {

public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1, 9};
Arrays.sort(numbers);
System.out.println("Tableau trié : " + Arrays.toString(numbers));
}
}

Méthode binarySearch()
La méthode binarySearch() permet de rechercher un élément dans un tableau trié en utilisant la
recherche binaire. Voici un exemple :
import java.util.Arrays;

public class ArraysDemo {

public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(numbers, 3);
System.out.println("Index de l'élément 3 : " + index);
}
}

Méthode equals()
La méthode equals() permet de comparer deux tableaux pour vérifier s'ils contiennent les mêmes
éléments dans le même ordre. Voici un exemple :
import java.util.Arrays;

public class ArraysDemo {

public static void main(String[] args) {
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
boolean isEqual = Arrays.equals(array1, array2);
System.out.println("Les tableaux sont-ils égaux ? " + isEqual);
}
}

Méthode fill()
La méthode fill() permet de remplir tous les éléments d'un tableau avec une valeur spécifiée. Voici un
exemple :
import java.util.Arrays;

public class ArraysDemo {

public static void main(String[] args) {
int[] numbers = new int[5];
Arrays.fill(numbers, 10);
System.out.println("Tableau rempli : " + Arrays.toString(numbers));
}
36