Ce QCM s'adresse aux développeurs qui préparent un test technique Java ou un entretien d'embauche. Vous y trouverez 12 questions de lecture de code et de pièges du langage, chacune accompagnée d'une explication complète.
En bref
Les tests Java de recrutement (SkillValue, CodinGame, HackerRank) reposent presque toujours sur les mêmes fondamentaux : comparaison de String avec == et equals, choix et comportement des collections (ArrayList, LinkedList, HashMap, HashSet), gestion des exceptions avec try/catch/finally, generics et autoboxing, API Stream et lambdas, et enfin héritage, polymorphisme et mots-clés static/final. La plupart des questions prennent la forme « qu'affiche ce programme ? » avec un extrait de 5 à 15 lignes. Le piège est rarement dans l'algorithme : il est dans un détail de sémantique du langage. Ce QCM reprend ces thèmes avec des questions de difficulté progressive.
Les thèmes qui tombent le plus
String : immutabilité, == et equalsThème numéro un des tests Java. Le piège : == compare les références, equals le contenu, et le pool de chaînes fait que deux littéraux identiques partagent la même référence alors qu'un new String() n'en fait pas partie.
Collections : ArrayList, LinkedList, HashMap, HashSetLes recruteurs testent le choix de la bonne structure et sa complexité. Piège classique : modifier une liste pendant un for-each (ConcurrentModificationException) ou redéfinir equals sans hashCode.
Exceptions : checked, unchecked et finallyIl faut savoir distinguer les exceptions vérifiées (IOException) des RuntimeException, et connaître l'ordre d'exécution de finally, y compris quand le try contient un return.
Generics et autoboxingLes generics sont invariants (List<Integer> n'est pas une List<Number>) et l'autoboxing cache des surprises : le cache des Integer entre -128 et 127 fait que == donne true pour 127 et false pour 128.
Streams et lambdasDepuis Java 8, les tests demandent de lire un pipeline filter / map / reduce et d'en prédire le résultat. Piège : oublier qu'un stream est paresseux et qu'il ne s'exécute qu'avec une opération terminale.
static, final, héritage et polymorphismeUne méthode d'instance redéfinie est résolue à l'exécution selon le type réel, mais une méthode static est résolue à la compilation selon le type déclaré. Ce décalage est le piège favori des QCM.
Entraînez-vous : 12 questions corrigées
Choisissez une réponse pour voir l'explication.
Qu'affiche ce programme ?
String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println((a == b) + " " + (a == c) + " " + a.equals(c));
Les deux littéraux "hello" sont internés dans le pool de chaînes : a et b pointent vers le même objet, donc a == b vaut true. new String() crée toujours un nouvel objet en dehors du pool, donc a == c vaut false. equals compare le contenu caractère par caractère, donc a.equals(c) vaut true. Les autres réponses confondent comparaison de référence et comparaison de contenu.
Qu'affiche ce programme ?
String s = "java";
s.toUpperCase();
s.concat("!");
StringBuilder sb = new StringBuilder("java");
sb.append("!");
System.out.println(s + " " + sb);
Un String est immuable : toUpperCase() et concat() renvoient une nouvelle chaîne mais ne modifient jamais l'objet d'origine. Comme leur résultat n'est pas affecté à une variable, s vaut toujours "java". StringBuilder, lui, est mutable : append() modifie sb sur place, qui vaut donc "java!". La réponse A suppose à tort que les méthodes de String modifient l'objet.
Le bloc finally s'exécute toujours, même après un return dans le try. L'ordre réel est : évaluation de return 1, exécution du finally qui affiche "finally", puis retour de la valeur 1 à l'appelant qui l'affiche. Le return ne court-circuite jamais le finally (seul System.exit() le fait), et ce code compile sans problème.
Laquelle de ces exceptions est une exception non vérifiée (unchecked), c'est-à-dire qu'il n'est pas obligatoire de la déclarer avec throws ni de l'attraper ?
NullPointerException hérite de RuntimeException : c'est une exception non vérifiée, le compilateur n'impose ni try/catch ni clause throws. IOException, SQLException et ClassNotFoundException (via ReflectiveOperationException) héritent d'Exception sans passer par RuntimeException : ce sont des exceptions vérifiées (checked) que le compilateur oblige à traiter ou à déclarer.
Qu'affiche ce programme ?
Integer a = 127, b = 127;
Integer c = 128, d = 128;
System.out.println((a == b) + " " + (c == d) + " " + c.equals(d));
L'autoboxing passe par Integer.valueOf(), qui met en cache les valeurs de -128 à 127. a et b reçoivent donc la même instance et a == b vaut true. 128 est hors du cache : c et d sont deux objets distincts, c == d compare les références et vaut false. equals compare les valeurs, donc c.equals(d) vaut true. Il faut toujours comparer des wrappers avec equals.
Une classe Point redéfinit equals() pour comparer x et y, mais ne redéfinit pas hashCode(). On insère deux Point(1, 2) distincts dans un HashSet. Quelle affirmation est correcte ?
HashSet calcule d'abord hashCode() pour choisir le bucket, et n'appelle equals() que sur les éléments du même bucket. Sans redéfinition, hashCode() est celui d'Object (basé sur l'identité) : deux instances distinctes ont presque toujours des hash différents et sont stockées comme deux éléments, malgré equals qui dit qu'elles sont égales. C'est une violation du contrat equals/hashCode, mais le compilateur ne la détecte pas et aucune exception n'est levée.
Qu'affiche ce programme ?
List<Integer> nums = List.of(1, 2, 3, 4, 5, 6);
int r = nums.stream()
.filter(x -> x % 2 == 0)
.map(x -> x * x)
.reduce(0, Integer::sum);
System.out.println(r);
filter garde les pairs : 2, 4, 6. map les élève au carré : 4, 16, 36. reduce(0, Integer::sum) additionne à partir de 0 : 4 + 16 + 36 = 56. La réponse 91 (1+4+9+16+25+36) oublie le filtre, 21 (1+2+3+4+5+6) oublie le filtre et le map, 35 (1+9+25) applique le filtre à l'envers.
Qu'affiche ce programme ?
class A {
static String who() { return "A"; }
String name() { return "A"; }
}
class B extends A {
static String who() { return "B"; }
@Override String name() { return "B"; }
}
// ...
A obj = new B();
System.out.println(obj.who() + obj.name());
Les méthodes static ne sont pas polymorphes : who() est résolue à la compilation d'après le type déclaré de la variable, A, donc obj.who() renvoie "A" (on parle de masquage, pas de redéfinition). name() est une méthode d'instance redéfinie : elle est résolue à l'exécution d'après le type réel de l'objet, B, donc obj.name() renvoie "B". Le résultat est "AB".
Que se passe-t-il à l'exécution ?
List<String> l = new ArrayList<>(List.of("a", "b", "c"));
for (String s : l) {
if (s.equals("a")) {
l.remove(s);
}
}
System.out.println(l);
Le for-each utilise un Iterator interne qui mémorise le modCount de la liste. Appeler l.remove() directement sur la liste modifie ce compteur ; au prochain appel de next(), l'itérateur détecte l'écart et lève une ConcurrentModificationException. Pour supprimer pendant un parcours, il faut utiliser iterator.remove() ou removeIf(). Le code compile parfaitement : la détection se fait uniquement à l'exécution.
Quelle valeur renvoie cette méthode ?
static int f() {
int x = 1;
try {
x = 2;
return x;
} finally {
x = 3;
}
}
Quand return x est atteint, la valeur de x (2) est évaluée et copiée dans la valeur de retour avant que finally ne s'exécute. Le finally modifie ensuite la variable locale x à 3, mais cela n'a aucun effet sur la valeur déjà mise de côté. La méthode renvoie donc 2. Si le finally contenait lui-même un return 3, alors la valeur serait écrasée et 3 serait renvoyé, mais ce n'est pas le cas ici.
Laquelle de ces déclarations compile sans erreur ?
Les generics sont invariants : même si Integer hérite de Number, List<Integer> n'est pas une List<Number>, donc A et D ne compilent pas. Avec ? extends Number, on peut lire des Number mais on ne peut rien ajouter (le compilateur ne sait pas quel sous-type exact la liste contient), donc le l.add(1) de B échoue. Avec ? super Integer, la liste accepte n'importe quel Integer en écriture : C compile. C'est la règle PECS, Producer Extends, Consumer Super.
Qu'affiche ce programme ?
Long l = 127L;
System.out.println(l.equals(127) + " " + l.equals(127L) + " " + (l == 127));
Le littéral 127 est un int, donc l.equals(127) autoboxe un Integer ; Long.equals() exige un Long et renvoie false même si les valeurs sont égales. 127L est bien un Long, donc l.equals(127L) vaut true. Pour l == 127, l'opérande de gauche est un wrapper et celui de droite un primitif : Java fait un unboxing de l en long et compare 127 == 127, ce qui vaut true. Le piège est le premier terme : equals ne convertit jamais les types.
Score0 / 12
Le jour du test
Devant un extrait de code, repérez d'abord le type déclaré de chaque variable : la plupart des pièges (static, generics, equals sur wrappers) se résolvent par le type à la compilation et non par le type réel.
Sur une question String ou Integer avec ==, cherchez systématiquement le pool de chaînes ou le cache -128 à 127 avant de répondre.
Avec try/catch/finally, écrivez mentalement l'ordre d'exécution ligne par ligne et demandez-vous si le return a déjà évalué sa valeur.
Pour un stream, calculez étape par étape sur papier (après filter, après map, après reduce) au lieu de deviner le résultat global.
Quelle version de Java faut-il connaître pour un test de recrutement ?
La majorité des tests ciblent Java 8 à 17 : lambdas, Stream API, Optional, var (Java 10), records et switch expressions (Java 14-17). Les fondamentaux (String, collections, exceptions) ne changent pas d'une version à l'autre et représentent l'essentiel des questions.
Combien de temps dure un QCM Java sur SkillValue ou CodinGame ?
Comptez généralement 20 à 40 questions en 30 à 60 minutes, soit environ 1 min 30 par question. Les tests mélangent QCM de lecture de code et parfois un ou deux exercices d'implémentation.
Les questions portent-elles sur Spring ou uniquement sur le langage ?
Un test Java « core » reste sur le langage et la bibliothèque standard. Si l'offre mentionne Spring ou Hibernate, attendez-vous à un bloc dédié : injection de dépendances, annotations courantes, cycle de vie des beans, JPA.
Comment progresser rapidement sur les pièges du langage ?
Exécutez vous-même chaque extrait sur lequel vous hésitez dans un jshell ou un IDE : voir le résultat réel fixe la règle mieux que la relire. Refaites ensuite ce QCM sans regarder les réponses et notez les thèmes où vous vous trompez encore.