Intermediate Java is the level most real application code actually runs on: List, Map and Set from the Collections framework, generics instead of raw types, and interfaces used to decouple code. It is genuinely productive — and it is also where Integer autoboxing produces one of the strangest, most-asked-about surprises in the entire language, because it works correctly on small numbers and quietly stops on larger ones.
What "Intermediate" Actually Covers
The Collections framework: ArrayList and LinkedList and when the difference actually matters, HashMap and when to reach for LinkedHashMap or TreeMap instead, HashSet for uniqueness. Generics — `List` instead of a raw List — and understanding that generics are a compile-time safety feature.
Interfaces versus abstract classes and when each is the right tool, method overriding versus overloading, try/catch/finally including what finally guarantees, and the autoboxing/unboxing that lets an int and an Integer be used somewhat interchangeably — along with knowing where "somewhat" stops being safe to rely on.
Where It Breaks
- Comparing two autoboxed Integer values with == and getting true for small numbers (cached, -128 to 127) and false for larger ones (not cached) — a bug that passes every small test case and fails in production
- Overriding equals() on a custom class without also overriding hashCode(), silently breaking that class's use as a HashMap key or HashSet member
- Modifying a List or Map while iterating over it in a for-each loop, throwing ConcurrentModificationException even in purely single-threaded code
- Relying on HashMap iteration order, which is not guaranteed or stable, when the code actually needed LinkedHashMap (insertion order) or TreeMap (sorted order)
- A `finally` block containing its own `return` statement, which silently overrides and discards whatever the try or catch block was about to return — legal, compiles cleanly, and rarely what the author intended
The pattern across all five: intermediate Java tools are correct and well-designed, and each has one specific, well-documented edge where relying on convenient-looking behaviour (small-number caching, hash-bucket iteration order) breaks the moment real data or real control flow diverges from the toy example that made it look safe.
What to Put on a CV at This Level
"Intermediate Java: Collections framework (List/Map/Set), generics, interfaces, try/catch/finally, autoboxing" is accurate and matches what most job ads asking for "solid Java" actually want — building a working application component from scratch, not just modifying one that already exists.
What would overstate it: claiming "advanced Java" on the strength of using a HashMap correctly. Advanced work, covered next, is specifically about generics beyond the basics, the Stream API, and how the JVM actually resolves overloaded methods — a distinct, testable claim.
The Next Rung
Advanced Java is built around the Stream API for declarative data processing, bounded generics and wildcards, understanding type erasure (generic type information does not exist at runtime — it is compile-time-only), and how the compiler resolves an overloaded method call when autoboxing and varargs both make more than one overload technically applicable.
The Java Test scores collections/generics and OOP/concurrency fundamentals separately across its 30 questions, which is a fast way to see specifically whether autoboxing or the equals/hashCode contract is the actual gap holding an intermediate score back.
Why Intermediate Java Is Where Most Real Application Code Sits
It is worth saying plainly: intermediate is not a consolation tier. A large share of business-logic code, CRUD services and internal tools never touch a bounded wildcard or a custom Stream collector, and do not need to — the collections-and-generics toolkit here is a complete, employable skill on its own.
The honest reason to push further is that any code processing real, larger data sets, or handling numeric IDs that regularly exceed 127, or relying on iteration order, eventually meets exactly the edge case this tier is built to catch. If that describes the work ahead, the advanced tier is worth the time. If it does not, intermediate Java done carefully — with the autoboxing and equals/hashCode traps genuinely understood — is a complete and trustworthy skill.