AI InterviewSearch…Search problems, topics, or pages…Ctrl KGet started
All skill tests

Java · Intermediate skill test

Java (Intermediate)

Java the way production code uses it: the object model, the libraries, the edge cases and the traps — then two problems to solve in Java.

Pass at 60%Distinction at 85%Proctored · full screenNo negative markingCode in JavaValid 2 years

Quick answer

What is on the Java (Intermediate) skill test?

Java as it is used at work: the collections and the contracts they rely on, generics, lambdas and streams, inheritance and the object model in depth, exceptions, the JVM's memory behaviour, concurrency, and modern Java from records to sealed types. Most questions ask what a program prints or whether it compiles; then you solve coding problems in Java at easy and medium difficulty.

The sitting

60% pass85%0100

60%

to pass

1h 20m

total time

27

questions

7 days

to retake

Start the test

The clock starts as soon as you click. Every sitting draws a fresh paper.

Proctored sitting

  • Laptop or desktop only, with a webcam. Phones and tablets can't start a test.
  • The test runs full screen, with the site's navigation hidden.
  • Your webcam stays on and is checked on your computer — nothing is recorded or uploaded.
  • Leaving full screen, switching tab or window or minimising blurs the paper — and so does the camera seeing no one, someone else, a phone, or you looking away. The clock keeps running.
  • Each is a warning; the third ends the sitting, graded as not passed.
  • Pasting, copying, right-click and printing are off.

The paper

2 sections, sat in order, each on its own clock — 1h 20m in all.

1

Concepts

25 Q · 25 marks

30 min

One mark a question, no negative marking. Many questions show a program and ask what it prints. A few ask you to select every correct option, and only the exact set scores.

2

Coding

2 problems · 25 marks

50 min

Write each solution in Java. Run checks the visible cases; Submit runs every hidden case and your best submission per problem is what counts, with partial credit for each case passed.

What it covers

Every paper takes its share from each of these 10 topics, so no two sittings lean the same way.

  1. 01

  2. 02

    Classes & objects

    Practise: Java study plan
  3. 03

    Inheritance & polymorphism

    Practise: Java study plan
  4. 04

  5. 05

  6. 06

  7. 07

    Lambdas & streams

    Practise: Java study plan
  8. 08

  9. 09

  10. 10

Java (Intermediate) is written for people who use Java at work or in substantial projects and want a credential that says more than "knows the syntax". It assumes everything in Java (Basic) and asks about the parts of the language that decide whether production code is correct: the contracts the collections depend on, what generics check at compile time and what is left at run time, how a stream pipeline actually evaluates, which method a call reaches, what the memory model promises two threads, and how recent releases changed everyday code.

The multiple-choice questions are mostly short programs, each built around one behaviour that an experienced developer can explain and a casual one gets wrong. The answer is never a matter of taste: every program either prints one exact line, fails to compile for a reason you can name, or throws an exception you can predict. A few questions ask you to select every correct option, and only the exact set scores. The coding round that follows draws from the catalogue at easy and medium difficulty, and every solution is written in Java.

Ten topics, and how deep each goes

Every sitting draws from all ten topics in balance. Plain syntax, operators and arrays are assumed rather than asked. The later modules of the Java study plan, from interfaces and generics through streams, memory and concurrency to modern Java, teach each of them.

  • Collections. How HashMap, HashSet, TreeMap and the lists decide equality and order, which operations are safe while iterating, and what the Map methods added since Java 8 return.
  • Generics. Type parameters and bounds, wildcards with extends and super and when each is the right choice, type inference, and what type erasure leaves at run time.
  • Lambdas and streams. Functional interfaces and method references, what a lambda may capture, how and when a stream pipeline evaluates, collectors, and Optional used as intended.
  • Inheritance and polymorphism. Overload resolution and dynamic dispatch when both apply to one call, what is inherited and what is only hidden, and how default methods in interfaces interact with classes.
  • Classes and objects. The order in which classes and objects are initialised, and nested, inner and anonymous classes.
  • Exceptions. Try-with-resources, what a finally block can and cannot change, and the compiler's checked-exception rules in their less obvious places.
  • Strings. The string pool, comparison and ordering, and the edge cases of the String methods used every day.
  • Memory and the JVM. Boxing and unboxing, the stack and the heap, reachability and garbage collection, and what immutability really requires.
  • Concurrency. Visibility and atomicity between threads, the locks and atomic classes that provide them, and the executor framework.
  • Modern Java. Records, sealed types, switch expressions, text blocks, var and pattern matching for instanceof.

Easy and medium problems, in Java

The coding round is where the credential shows you can build, not only read. Its problems come from the catalogue at easy and medium difficulty, and the harder one usually needs a technique rather than a direct loop: a hash map that turns a nested search into one pass, a sliding window, a prefix sum, binary search, a stack or a heap. The roadmap lessons show each one with Java code, and the Hash Table, Sorting and Heap problem lists are good places to practise at medium difficulty.

Each problem gives you a public static method to complete; the input arrives as its arguments and you return the answer. Pasting is switched off, so your Java has to come from memory: the Map and Deque methods, a PriorityQueue with a comparator, sorting objects or part of an array, converting between List<Integer> and int[]. Write those until you no longer stop to think about them, because the medium problem leaves little time for looking things up.

Run checks the visible examples; Submit runs thousands of hidden, generated cases. Each case you pass earns its share of the marks and your best submission per problem counts, so submit a correct solution as soon as you have one and refine it afterwards.

A plan for developers who already use Java

Working Java developers tend to know the common path well and its edges less well, because production code rarely forces the question. A plan aimed at that gap:

  1. Pick the topics above that you use least, perhaps wildcards, stream evaluation or the memory model, and read those modules of the Java study plan end to end, quizzes included.
  2. For each behaviour you are unsure of, write the smallest program that shows it and predict the output before you run it. Does an enum constant's constructor run once, or every time the constant is used? Ten lines settle it, and the prediction you got wrong is the one you will remember.
  3. Solve medium problems in Java against a timer, without an IDE, so that the coding round's editor feels familiar.
  4. Read the explanation of every quiz answer, including the ones you got right. The test rewards knowing why, and a correct guess teaches nothing.

Traps that catch experienced developers

  • Relying on what usually happens. Code that has always worked on your machine can still be wrong by the language's rules, and the questions ask about the rules. When an option says the outcome can vary, decide whether Java guarantees the order or the visibility involved, not whether you have ever seen it fail.
  • Mixing up compile time and run time. Overload choice uses the compile-time types of the arguments; overriding uses the run-time class of the object. Decide which mechanism a call goes through before you trace it.
  • Losing track of what was copied. Many behaviours come down to whether you hold a copy, a view or a shared reference. Ask that question of every collection, array and builder handed from one place to another.
  • Reading deferred code as if it ran where it is written. A stream pipeline, a Supplier or a CompletableFuture stage runs when something asks for its result.
  • Skipping the compile check. Experienced readers trace the logic and forget to ask whether the code compiles at all; sometimes the option saying it does not is the right one.

Without the Basic credential first

The Basic test is not a prerequisite. A fair self-check: if you can answer the sample question below and explain why each wrong option is wrong, you are working at this level. If the topics on the Java (Basic) page, such as constructor chaining, checked exceptions and pass-by-value, still take thought, sit that first and come back.

Java Certification Test (Intermediate)

A free 80-minute Java skill test at intermediate level. Pass with 60% to earn a verifiable CodeKairo credential and a profile frame.

  • Skill: Java
  • Level: Intermediate
  • Duration: 80 minutes
  • Questions: 27
  • Pass mark: 60% (distinction at 85%)
  • Credential: Verifiable, valid for 2 years

Java the way production code uses it: the object model, the libraries, the edge cases and the traps — then two problems to solve in Java.

What is on the Java (Intermediate) skill test?

Java as it is used at work: the collections and the contracts they rely on, generics, lambdas and streams, inheritance and the object model in depth, exceptions, the JVM's memory behaviour, concurrency, and modern Java from records to sealed types. Most questions ask what a program prints or whether it compiles; then you solve coding problems in Java at easy and medium difficulty.

Sections

SectionQuestionsTimeKindMarks each
Concepts2530 minMultiple choice1
Coding250 minCoding12.5

What it covers

Java (Intermediate) is written for people who use Java at work or in substantial projects and want a credential that says more than "knows the syntax". It assumes everything in Java (Basic) and asks about the parts of the language that decide whether production code is correct: the contracts the collections depend on, what generics check at compile time and what is left at run time, how a stream pipeline actually evaluates, which method a call reaches, what the memory model promises two threads, and how recent releases changed everyday code.

The multiple-choice questions are mostly short programs, each built around one behaviour that an experienced developer can explain and a casual one gets wrong. The answer is never a matter of taste: every program either prints one exact line, fails to compile for a reason you can name, or throws an exception you can predict. A few questions ask you to select every correct option, and only the exact set scores. The coding round that follows draws from the catalogue at easy and medium difficulty, and every solution is written in Java.

Ten topics, and how deep each goes

Every sitting draws from all ten topics in balance. Plain syntax, operators and arrays are assumed rather than asked. The later modules of the Java study plan, from interfaces and generics through streams, memory and concurrency to modern Java, teach each of them.

  • Collections. How HashMap, HashSet, TreeMap and the lists decide equality and order, which operations are safe while iterating, and what the Map methods added since Java 8 return.
  • Generics. Type parameters and bounds, wildcards with extends and super and when each is the right choice, type inference, and what type erasure leaves at run time.
  • Lambdas and streams. Functional interfaces and method references, what a lambda may capture, how and when a stream pipeline evaluates, collectors, and Optional used as intended.
  • Inheritance and polymorphism. Overload resolution and dynamic dispatch when both apply to one call, what is inherited and what is only hidden, and how default methods in interfaces interact with classes.
  • Classes and objects. The order in which classes and objects are initialised, and nested, inner and anonymous classes.
  • Exceptions. Try-with-resources, what a finally block can and cannot change, and the compiler's checked-exception rules in their less obvious places.
  • Strings. The string pool, comparison and ordering, and the edge cases of the String methods used every day.
  • Memory and the JVM. Boxing and unboxing, the stack and the heap, reachability and garbage collection, and what immutability really requires.
  • Concurrency. Visibility and atomicity between threads, the locks and atomic classes that provide them, and the executor framework.
  • Modern Java. Records, sealed types, switch expressions, text blocks, var and pattern matching for instanceof.

Easy and medium problems, in Java

The coding round is where the credential shows you can build, not only read. Its problems come from the catalogue at easy and medium difficulty, and the harder one usually needs a technique rather than a direct loop: a hash map that turns a nested search into one pass, a sliding window, a prefix sum, binary search, a stack or a heap. The roadmap lessons show each one with Java code, and the Hash Table, Sorting and Heap problem lists are good places to practise at medium difficulty.

Each problem gives you a public static method to complete; the input arrives as its arguments and you return the answer. Pasting is switched off, so your Java has to come from memory: the Map and Deque methods, a PriorityQueue with a comparator, sorting objects or part of an array, converting between List<Integer> and int[]. Write those until you no longer stop to think about them, because the medium problem leaves little time for looking things up.

Run checks the visible examples; Submit runs thousands of hidden, generated cases. Each case you pass earns its share of the marks and your best submission per problem counts, so submit a correct solution as soon as you have one and refine it afterwards.

A plan for developers who already use Java

Working Java developers tend to know the common path well and its edges less well, because production code rarely forces the question. A plan aimed at that gap:

  1. Pick the topics above that you use least, perhaps wildcards, stream evaluation or the memory model, and read those modules of the Java study plan end to end, quizzes included.
  2. For each behaviour you are unsure of, write the smallest program that shows it and predict the output before you run it. Does an enum constant's constructor run once, or every time the constant is used? Ten lines settle it, and the prediction you got wrong is the one you will remember.
  3. Solve medium problems in Java against a timer, without an IDE, so that the coding round's editor feels familiar.
  4. Read the explanation of every quiz answer, including the ones you got right. The test rewards knowing why, and a correct guess teaches nothing.

Traps that catch experienced developers

  • Relying on what usually happens. Code that has always worked on your machine can still be wrong by the language's rules, and the questions ask about the rules. When an option says the outcome can vary, decide whether Java guarantees the order or the visibility involved, not whether you have ever seen it fail.
  • Mixing up compile time and run time. Overload choice uses the compile-time types of the arguments; overriding uses the run-time class of the object. Decide which mechanism a call goes through before you trace it.
  • Losing track of what was copied. Many behaviours come down to whether you hold a copy, a view or a shared reference. Ask that question of every collection, array and builder handed from one place to another.
  • Reading deferred code as if it ran where it is written. A stream pipeline, a Supplier or a CompletableFuture stage runs when something asks for its result.
  • Skipping the compile check. Experienced readers trace the logic and forget to ask whether the code compiles at all; sometimes the option saying it does not is the right one.

Without the Basic credential first

The Basic test is not a prerequisite. A fair self-check: if you can answer the sample question below and explain why each wrong option is wrong, you are working at this level. If the topics on the Java (Basic) page, such as constructor chaining, checked exceptions and pass-by-value, still take thought, sit that first and come back.

Sample question

Topic: Collections

What does this program print?

import java.util.*;

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        for (int n : new int[] {3, 9, 4, 9, 1}) {
            pq.offer(n);
        }
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < 3; i++) {
            out.append(pq.poll()).append(' ');
        }
        System.out.println(out.append(pq.size()));
    }
}
  1. 9 4 3 1
  2. 1 3 4 2
  3. 3 9 4 2
  4. 9 9 4 2
Show the answer

D. 9 9 4 2

A PriorityQueue is a heap, not a set, so it keeps both 9s. With Collections.reverseOrder() as its comparator, poll() always removes the largest element left, so three polls give 9, 9 and 4, and two elements (3 and 1) remain. A collection that dropped duplicates, like a TreeSet, would give A; the default comparator makes it a min-heap, which gives B; and insertion order, C, is what a plain FIFO queue such as ArrayDeque would give.

Common questions

Does the Java Intermediate test cover Spring, Hibernate or other frameworks?

No. Every question is about the language and the JDK's own libraries, chiefly java.util, java.util.function, java.util.stream and java.util.concurrent. Knowing a framework well helps only as far as you know what the plain Java underneath it does.

Which Java version do the modern-Java questions assume?

Java 17. Records, sealed classes and interfaces, switch expressions, text blocks, var and pattern matching for instanceof are all in scope. Nothing depends on a later release, so record patterns and pattern matching in switch, which became final in Java 21, are not examined.

How much concurrency does it expect?

What a developer needs to write correct multithreaded code, not how locks are implemented: what synchronized, volatile and the atomic classes each guarantee, and how the java.util.concurrent executors and futures are used. When an outcome would depend on timing, a question asks what the language guarantees rather than what usually happens.

Is there partial credit in the coding round?

Yes. Each problem is checked against thousands of hidden cases, every case you pass earns its share of that problem's marks, and your best submission per problem is the one that counts. Submitting a correct but unpolished solution early and improving it afterwards is safe: a worse later attempt never replaces a better one.

Rules

This is a certification test. Pass with 60% and you earn a verifiable CodeKairo credential — 85% earns it with distinction. It is valid for 2 years.

  • The sections are timed separately and taken in order. A section you leave cannot be reopened.
  • The server keeps the clock. Closing the tab or reloading does not pause it.
  • Your answers save as you go and survive a refresh.
  • The coding section must be answered in Java. Run checks the visible cases; Submit runs every hidden case.
  • You may sit this test again 7 days after a sitting ends. Your best result stands.

Integrity. Work alone and from what you know, on a laptop or desktop with a webcam — phones and tablets cannot sit a skill test. The test runs full screen and must stay in front the whole time, and the webcam must see you, alone: leaving full screen, switching to another tab or window, minimising, or the camera seeing no one, someone else, a phone or you looking away blurs the paper and counts against you — the first 2 are warnings, and the third ends the sitting, graded as not passed. The camera check runs in your browser; nothing is recorded or uploaded. Pasting into the editor is switched off. A sitting that looks assisted can be reviewed, and a credential earned that way is revoked.

The answers are never shown — not during the test and not after it. Your result breaks the score down by topic and points you to what to practise.