Aide-mémoire Java
Dernière mise à jour
Hello World et structure d'un programme
Chaque programme Java démarre depuis une méthode main à l'intérieur d'une classe.
| Élément | Code |
|---|---|
| Déclaration de classe | public class Main { ... } |
| Point d'entrée | public static void main(String[] args) { ... } |
| Afficher une ligne | System.out.println("Hello, World!"); |
| Afficher sans saut de ligne | System.out.print("text"); |
| Lire une saisie | Scanner sc = new Scanner(System.in); |
| Importer une classe | import java.util.ArrayList; |
| Commentaires | // line et /* block */ |
Types de données
Les primitifs sont en minuscules ; leurs classes enveloppes prennent une majuscule.
| Type | Description |
|---|---|
int | Entier signé 32 bits |
long | Entier signé 64 bits |
double / float | Nombres à virgule flottante |
boolean | true ou false |
char | Caractère Unicode unique de 16 bits |
byte / short | Entiers 8 bits / 16 bits |
String | Texte immuable (une classe, pas un primitif) |
Integer, Double, Boolean | Classes enveloppes des primitifs |
var | Type local inféré (Java 10+) |
Variables
| Opération | Syntaxe |
|---|---|
| Déclarer et initialiser | int x = 5; |
| Inférence de type (locale) | var name = "Ada"; |
| Constante | final double PI = 3.14159; |
| Concaténation de chaînes | String s = "Hi " + name; |
| Convertir une chaîne en int | int n = Integer.parseInt("42"); |
| Convertir un int en chaîne | String s = String.valueOf(42); |
| Chaîne formatée | String.format("%d items", n) |
Contrôle de flux
| Instruction | Syntaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Instruction switch | switch (n) { case 1: ...; break; default: ...; } |
| Expression switch | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| Boucle while | while (i < n) { ... } |
| Boucle do-while | do { ... } while (i < n); |
| Boucle for | for (int i = 0; i < n; i++) { ... } |
| For amélioré (for-each) | for (String item : list) { ... } |
| Break / continue | break; sort d'une boucle, continue; passe à l'itération suivante |
Méthodes
| Opération | Syntaxe |
|---|---|
| Définir une méthode | int add(int a, int b) { return a + b; } |
| Sans valeur de retour | void greet() { ... } |
| Méthode statique | static int square(int x) { return x * x; } |
| Méthode publique | public String getName() { return name; } |
| Varargs | int sum(int... nums) { ... } |
| Appeler une méthode | int r = add(2, 3); |
| Appeler une méthode statique | Math.max(a, b); |
| Surcharge de méthode | int max(int a, int b) et double max(double a, double b) |
Classes et POO
| Opération | Syntaxe |
|---|---|
| Définir une classe | public class Dog { ... } |
| Champ | private String name; |
| Constructeur | public Dog(String name) { this.name = name; } |
| Créer un objet | Dog d = new Dog("Rex"); |
| Getter / setter | public String getName() { return name; } |
| Héritage | class Puppy extends Dog { ... } |
| Interface | interface Runnable { void run(); } |
| Implémenter une interface | class Task implements Runnable { ... } |
| Redéfinir une méthode | @Override public void speak() { ... } |
Collections
Collections génériques de java.util.
| Type | Usage et exemple |
|---|---|
ArrayList<T> | Tableau dynamique : list.add(1); list.get(0); list.size(); |
HashMap<K, V> | Clé-valeur : map.put("a", 1); map.get("a"); |
HashSet<T> | Valeurs uniques : set.add(5); set.contains(5); |
LinkedList<T> | Liste doublement chaînée, idéale comme file/deque |
ArrayDeque<T> | Pile/file : dq.push(x); dq.pop(); |
| Tableau | int[] nums = {1, 2, 3}; |
| Parcourir une liste | for (T x : list) { ... } |
| Parcourir une map | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Streams et lambdas
Pipelines de style fonctionnel sur les collections (Java 8+).
| Opération | Syntaxe |
|---|---|
| Expression lambda | x -> x * 2 |
| Créer un stream | list.stream() |
| Filtrer | .filter(n -> n > 0) |
| Mapper / transformer | .map(n -> n * 2) |
| Trier | .sorted() ou .sorted(Comparator.reverseOrder()) |
| Réduire / sommer | .reduce(0, Integer::sum) |
| Compter / tester | .count(), .anyMatch(n -> n > 5) |
| Collecter en liste | .collect(Collectors.toList()) |
| Pour chaque | .forEach(System.out::println) |
Schémas courants (try/catch, génériques)
| Schéma | Syntaxe |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| Attraper une exception précise | catch (IOException e) { ... } |
| Finally | finally { ... } s'exécute toujours |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| Lever une exception | throw new IllegalArgumentException("bad"); |
| Classe générique | class Box<T> { T value; } |
| Méthode générique | <T> T first(List<T> list) { ... } |
| Type borné | <T extends Number> |
La syntaxe Java, les collections et les opérations de stream que vous utilisez le plus, sur une seule page. Cet aide-mémoire Java est une référence rapide pour écrire du Java - les types de données, le contrôle de flux, les classes, les collections ArrayList/HashMap, l'API Streams, ainsi que les schémas d'exceptions et de génériques que vous utilisez tous les jours.
Tout ce qui figure ici est du Java standard (Java 8 et ultérieur) et se compile avec javac. Copiez ce dont vous avez besoin, ou essayez n'importe quel extrait en direct dans le playground Java - aucun JDK à installer.
FAQ de l'aide-mémoire Java
Cet aide-mémoire Java est-il gratuit ?
Oui. Cet aide-mémoire Java est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver une syntaxe, une collection ou une opération de stream.
Quelle est la différence entre == et .equals() en Java ?
Pour les objets,
== compare les références - c'est-à-dire si deux variables pointent vers exactement le même objet - tandis que .equals() compare le contenu. Deux objets String distincts ayant le même texte sont .equals() mais ne sont pas forcément ==. Utilisez toujours .equals() pour comparer les chaînes et autres objets par valeur ; n'utilisez == que pour les primitifs (int, boolean, etc.) ou pour vérifier null.À quoi servent les streams en Java ?
L'API Streams (Java 8+) vous permet de traiter les collections avec un pipeline d'opérations lisible -
filter, map, sorted, reduce, collect - au lieu de boucles manuelles. Vous commencez par list.stream(), enchaînez des opérations intermédiaires et terminez par une opération terminale comme collect(Collectors.toList()) ou forEach. Cela garde le code de transformation des données concis et expressif.Puis-je m'entraîner à Java en ligne ?
Oui. Ouvrez le playground Java pour compiler et exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucun JDK à installer. Quand vous voulez de la structure, le cours Java interactif gratuit de Coddy vous emmène des variables et des boucles jusqu'aux classes, aux collections et aux streams, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des briques de base les plus courantes (types, contrôle de flux, méthodes) jusqu'aux plus avancées (streams, génériques, exceptions), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers le reste.
Ressources connexes
Plus d'aide-mémoires
