Examen 1Z0-831 · Java SE 25 Developer

Apprenez l’OCP 25 une règle à la fois, avec des réponses exécutées sur le JDK 25.

Le programme de l’OCP 25 est découpé en exercices courts, une règle chacun : 1 471 à ce jour. Répondez, voyez ce qu’a fait le JDK 25, et l’exercice revient juste avant que vous l’oubliiez. Vous apprenez en vous rappelant chaque règle, pas en relisant un livre.

Essayer gratuitement Voir le programme de l’OCP 25

1 471 exercices · 10 domaines · 102 sujets · chaque réponse de code exécutée sur le JDK 25

9.3.1Path operations: resolve, relativize, normalizeJDK 25

What happens?

Main.java

void main() {    Path p = Path.of("a/b/c/d");    Path s = p.subpath(1, 3);    IO.println(s.getNameCount() + " " + s.getFileName());}

Comment se termine java Main.java ?

1S’exécuteet affiche quelque chose, ou rien2Ne compile pasjavac le refuse3Lève une exceptionpendant l’exécution

Une règle par exercice
Chaque exercice teste une seule règle : une erreur vous dit exactement quoi corriger.
C’est la JVM qui tranche, pas nous
Erreurs de compilation, exceptions et sorties sont capturées lors de vraies exécutions.
De retour avant l’oubli
Les exercices manqués reviennent plus tôt. Ceux que vous savez reviennent moins souvent.

Des exercices courts, une règle chacun

Un guide d’étude explique un sujet comme celui-ci une fois, en quelques pages. Ici, il devient 19 exercices courts sur 14 règles, chacun résolu en quelques secondes et planifié séparément. En voici 6, avec ce qu’a fait le JDK 25.

9.3.1Path operations: resolve, relativize, normalize19 exercices sur 14 règles, exécutés sur le JDK 25

Affiche une sortie : 13
Erreur de compilation : 2
Exception à l’exécution : 4

Main.java

void main() {    Path p = Path.of("a/b/..");    IO.println(p.getFileName() + " " + p.normalize().getFileName());}

Affiche une sortie

$ java Main.java.. a

RèglegetFileName() of a/b/.. is .. — nothing is normalized automatically.

Main.java

void main() {    Path p = new Path("a/b");    IO.println(p.getNameCount());}

Erreur de compilation

$ java Main.javaMain.java:2: error: Path is abstract; cannot be instantiated    Path p = new Path("a/b");             ^error: compilation failed

RèglePath is an interface: create with Path.of(first, more…) (legacy Paths.get), never new. Path.of rejects illegal characters with InvalidPathException.

Main.java

void main() {    Path p = Path.of("a/b/c");    IO.println(p.getName(0) + " " + p.getName(3));}

Exception à l’exécution

$ java Main.javaException in thread "main" java.lang.IllegalArgumentException

Règlesubpath(1, 5) on a 4-element path and getName(3) on a 3-element path throw IllegalArgumentException.

Main.java

void main() {    Path from = Path.of("a/b");    Path to = Path.of("a/c/d");    IO.println(from.relativize(to).equals(Path.of("../c/d")));}

Affiche une sortie

$ java Main.javatrue

Règlerelativize(q): path from this to q (a/b → a/c/d = ../c/d); mixing relative and absolute → IllegalArgumentException.

Main.java

void main() throws IOException {    Path p = Path.of("drafts", "q3", "plan.md");    Path real = p.toRealPath();    IO.println(real.isAbsolute() + " " + real.getFileName());}

Exception à l’exécution

$ java Main.javaException in thread "main" java.nio.file.NoSuchFileException: drafts/q3/plan.md

RègletoRealPath() needs the file to exist; toAbsolutePath() does not.

Main.java

void main() {    Path p = Path.of("abc/def");    IO.println(p.startsWith("ab") + " " + p.startsWith("abc"));}

Affiche une sortie

$ java Main.javafalse true

RèglePath.of("abc/def").startsWith("ab") is false.

Main.java

void main() {    Path p = Path.of("a/b/..");    IO.println(p.getFileName() + " " + p.normalize().getFileName());}

Affiche une sortie

$ java Main.java.. a

RèglegetFileName() of a/b/.. is .. — nothing is normalized automatically.

Main.java

void main() {    Path p = new Path("a/b");    IO.println(p.getNameCount());}

Erreur de compilation

$ java Main.javaMain.java:2: error: Path is abstract; cannot be instantiated    Path p = new Path("a/b");             ^error: compilation failed

RèglePath is an interface: create with Path.of(first, more…) (legacy Paths.get), never new. Path.of rejects illegal characters with InvalidPathException.

Main.java

void main() {    Path p = Path.of("a/b/c");    IO.println(p.getName(0) + " " + p.getName(3));}

Exception à l’exécution

$ java Main.javaException in thread "main" java.lang.IllegalArgumentException

Règlesubpath(1, 5) on a 4-element path and getName(3) on a 3-element path throw IllegalArgumentException.

Main.java

void main() {    Path from = Path.of("a/b");    Path to = Path.of("a/c/d");    IO.println(from.relativize(to).equals(Path.of("../c/d")));}

Affiche une sortie

$ java Main.javatrue

Règlerelativize(q): path from this to q (a/b → a/c/d = ../c/d); mixing relative and absolute → IllegalArgumentException.

Main.java

void main() throws IOException {    Path p = Path.of("drafts", "q3", "plan.md");    Path real = p.toRealPath();    IO.println(real.isAbsolute() + " " + real.getFileName());}

Exception à l’exécution

$ java Main.javaException in thread "main" java.nio.file.NoSuchFileException: drafts/q3/plan.md

RègletoRealPath() needs the file to exist; toAbsolutePath() does not.

Main.java

void main() {    Path p = Path.of("abc/def");    IO.println(p.startsWith("ab") + " " + p.startsWith("abc"));}

Affiche une sortie

$ java Main.javafalse true

RèglePath.of("abc/def").startsWith("ab") is false.

Un récap d’une page pour chaque sujet

Chaque sujet a le sien, écrit pour les exercices qu’il accompagne. Il s’ouvre sur l’idée principale, la phrase à retenir, les pièges et un schéma. Le reste est à un clic. Celui-ci porte sur le sujet des exercices ci-dessus.

9.3.1Path operations: resolve, relativize, normalizeRécap

A Path is an immutable, purely syntactic list of name elements (plus an optional root); almost all Path methods just manipulate that list and never touch the disk.

À retenir Path = list of names. Only toRealPath looks at the disk.

Pièges

subpath(1, 5) on a 4-element path and getName(3) on a 3-element path throw IllegalArgumentException.
getFileName() of a/b/.. is .. — nothing is normalized automatically.
normalize() keeps a leading ...
resolve with an absolute argument ignores the receiver.
toRealPath() needs the file to exist; toAbsolutePath() does not.
Path.of("abc/def").startsWith("ab") is false.

Path methods

Method	Example	Result
`getFileName()`	`a/b/c`	`c`
`getParent()`	`a/b/c` · `c`	`a/b` · `null`
`getRoot()`	`a/b`	`null`
`getName(1)`	`a/b/c`	`b` (index 3 → IAE)
`subpath(1,3)`	`a/b/c/d`	`b/c` (end exclusive)
`normalize()`	`a/./b/../c` · `../x/./y`	`a/c` · `../x/y`
`resolve(q)`	`a/b` + `c` · + `/abs`	`a/b/c` · `/abs`
`resolveSibling(q)`	`a/b/c.txt` + `d.txt`	`a/b/d.txt`
`relativize(q)`	`a/b` → `a/c/d`	`../c/d` (mixed kinds → IAE)
`toAbsolutePath()`	`a/b`	cwd + `a/b`
`toRealPath()`	missing file	`NoSuchFileException`

Apprendre d’abord, puis s’entraîner

Le programme de l’OCP 25 est long. Un guide d’étude le couvre une fois, en prose. Un examen blanc complet teste tout d’un coup : chaque question mêle plusieurs pièges et sujets, et une séance prend environ deux heures. Apprenez ici d’abord, une règle à la fois, puis entraînez-vous en conditions d’examen.

Dans cette application
Apprendre une règle à la fois
Des séances courtes chaque jour. Chaque exercice teste une règle, montre ce qu’a fait la JVM et revient juste avant que vous ne l’oubliiez.
Dans cette application
Mesurer sa préparation par domaine
Le taux de rappel par domaine montre les objectifs que vous manquez encore : vous travaillez ceux-là au lieu de tout relire.
Avec des examens blancs complets, comme Enthuware
S’entraîner en conditions d’examen
Des examens blancs complets et chronométrés : code long, pièges mêlés, chrono. Enthuware est fait pour ça. Les quelques examens blancs d’ici vérifient votre rythme. Ils ne remplacent pas une banque complète.

Guide d’étude
Une séance
Un chapitre
Règles par question
Beaucoup, expliqués en prose
Quand vous découvrez votre erreur
Quand vous vous testez
Quand ça revient
Quand vous le relisez
Idéal pour
Un premier passage complet sur le programme
Exercices courts, ici
Une séance
Le temps que vous avez : arrêtez après n’importe quel exercice
Règles par question
Un seul
Quand vous découvrez votre erreur
Juste après votre réponse, avec la sortie de la JVM
Quand ça revient
Juste avant que vous l’oubliiez
Idéal pour
Apprendre chaque règle jusqu’à ce qu’elle tienne
Examen blanc complet
Une séance
50 questions en 120 minutes
Règles par question
Plusieurs, sur plusieurs sujets
Quand vous découvrez votre erreur
Après avoir rendu tout l’examen
Quand ça revient
Au prochain examen blanc
Idéal pour
Répéter l’examen avant de le réserver

Guide d’étude, exercices courts et examen blanc complet, comparés
	Guide d’étude	Exercices courts, ici	Examen blanc complet
Une séance	Un chapitre	Le temps que vous avez : arrêtez après n’importe quel exercice	50 questions en 120 minutes
Règles par question	Beaucoup, expliqués en prose	Un seul	Plusieurs, sur plusieurs sujets
Quand vous découvrez votre erreur	Quand vous vous testez	Juste après votre réponse, avec la sortie de la JVM	Après avoir rendu tout l’examen
Quand ça revient	Quand vous le relisez	Juste avant que vous l’oubliiez	Au prochain examen blanc
Idéal pour	Un premier passage complet sur le programme	Apprendre chaque règle jusqu’à ce qu’elle tienne	Répéter l’examen avant de le réserver

Le programme de l’OCP 25, en carte

10 domaines, chacun avec ses exercices, son récap et son calendrier de révision. Choisissez-en un pour voir ce qu’il couvre.

Domaine 1

Values, text & time

Handling Date, Time, Text, Numeric and Boolean Values

1.1Primitives, wrappers & expressions
1.2String, text blocks & StringBuilder
1.3Date-Time API

17 sujets dans l’OCP 25

Values, text & time92 %
Program flow84 %
Object-oriented Java71 %
Exceptions88 %
Arrays & collections66 %
Streams & lambdas58 %
Packaging & modules79 %
Concurrency62 %
I/O & NIO.274 %
Localization55 %

Exemple d’apprenant, données fictivesObjectif 80 %

Sachez quand vous êtes prêt, domaine par domaine

La préparation, c’est votre taux de rappel prévu sur chaque domaine de l’OCP 25, pas un score unique et opaque. Inscrivez-vous quand chaque barre dépasse votre objectif.

Même code, autre version de Java, autre réponse

Vous changez d’examen ? Les exercices dont le résultat change entre Java 17, 21 et 25 sont signalés comme pièges de version. Choisissez un JDK pour voir ce qu’il a fait de celui-ci.

Main.java

enum Light { RED, AMBER, GREEN }void main() {    Light l = Light.GREEN;    String action = switch (l) {        case Light.RED -> "stop";        case AMBER, GREEN -> "go";    };    IO.println(action);}

Exécution capturée

Exécuté sur le JDK 17

Erreur de compilationCode de sortie 1

$ java Main.javaMain.java:5: error: an enum switch case label must be the unqualified name of an enumeration constant        case Light.RED -> "stop";                  ^error: compilation failed

Quelques examens blancs au format de l’OCP 25

50 questions · 120 minutes · 68 % pour réussir. Une fois les règles apprises, ils servent à vérifier votre rythme et à repérer les domaines qui vous coûtent encore des points. Ils ne remplacent pas une banque d’examens blancs complète pour la répétition générale.

Commencez gratuitement. Payez quand ça marche pour vous.

Prix en euros, TVA comprise. Un pass couvre tous les examens Java OCP : OCP 17, 21 et 25.

Gratuit
0 €
Environ 15 % des exercices de chaque examen, avec la preuve et le calendrier de révision.
Commencer gratuitement
Pass d’entraînement
24 € pour 120 jours
Tous les exercices, récaps et examens blancs des examens Java OCP.
Prendre le pass d’entraînement
Cours + entraînement
39 € pour 120 jours
Le cours complet, leçon par leçon, plus le pass d’entraînement.
Prendre le cours
Accès complet
99 € par an
Chaque certification dès son lancement, cours et entraînement compris.
Prendre l’accès complet

Questions

Faut-il quand même des examens blancs complets ?

Oui. Cette application sert à apprendre les règles, une à la fois. Avant de réserver l’OCP 25, entraînez-vous avec les examens blancs chronométrés de Enthuware. Ils vous préparent à la longueur, aux pièges mêlés et au chrono.

S’agit-il de vraies questions d’examen ?

Non, et nous ne le prétendons jamais. Chaque exercice est original, écrit à partir des objectifs publics de l’OCP 25, de la spécification du langage Java et de la Javadoc.

Comment savoir que les réponses sont justes ?

Chaque exercice de code est compilé et exécuté sur le JDK de chaque examen auquel il s’applique. La réponse, c’est ce qu’a fait la JVM, et vous voyez sa sortie.

Quel examen choisir : OCP 17, 21 ou 25 ?

Celui qui correspond au Java qu’utilise votre équipe. Les programmes diffèrent : Java 17 inclut encore JDBC, et Java 25 ajoute les imports de modules et les fichiers source compacts. L’application indique quels exercices s’appliquent au vôtre.

Environ 221 exercices gratuits sur l’OCP 25. Sans carte bancaire.

Essayer gratuitement

Apprenez l’OCP 25 une règle à la fois, avec des réponses exécutées sur le JDK 25.

What happens?

Une règle par exercice

C’est la JVM qui tranche, pas nous

De retour avant l’oubli

Des exercices courts, une règle chacun

Un récap d’une page pour chaque sujet

Pièges

À savoir

À l’examen

Apprendre d’abord, puis s’entraîner

Apprendre une règle à la fois

Mesurer sa préparation par domaine

S’entraîner en conditions d’examen

Guide d’étude

Exercices courts, ici

Examen blanc complet

Le programme de l’OCP 25, en carte

Values, text & time

Sachez quand vous êtes prêt, domaine par domaine

Même code, autre version de Java, autre réponse

Exécution capturée

Quelques examens blancs au format de l’OCP 25

Commencez gratuitement. Payez quand ça marche pour vous.

Gratuit

Pass d’entraînement

Cours + entraînement

Accès complet

Questions

Environ 221 exercices gratuits sur l’OCP 25. Sans carte bancaire.