Java Engineer Checklist

Learning goals

By the end of this chapter you should be able to:

• Self-assess Core Java skills against a production-ready checklist
• Map course topics to common interview themes
• Know where to go next: design patterns, low-level design, and coding practice

You have the Core Java foundation

This course moved from language basics through IO, time, collections, modern APIs, JVM internals, and concurrency. The checklist below is a honest gate before calling yourself interview-ready for backend Java roles (still no Spring — that is the next stack layer).

Use it as a spaced-repetition audit: mark can explain + code cold, need notes, or gap.

Language and OOP

• Classes, interfaces, inheritance, @Override, super
• record, sealed hierarchies, pattern matching switch
• equals/hashCode/Comparable contracts
• Generics: bounds, wildcards ? extends / ? super, type erasure basics
• Exceptions: checked vs unchecked, try-with-resources, suppressed exceptions

Core APIs

• Path, Files, NIO.2 read/write, directory walk
• java.time: Instant, LocalDate, ZonedDateTime, Period/Duration
• Optional — return types, flatMap, anti-patterns avoided

Collections

• Pick List / Set / Map / Queue for a stated problem
• ArrayList vs LinkedList, HashMap internals at high level
• LinkedHashMap LRU, TreeMap/TreeSet ordering
• Immutable List.of, Map.copyOf
• Fail-fast vs weakly consistent iterators

Modern Java (8 → 21)

• Lambdas, method references, functional interfaces
• Streams: lazy pipeline, flatMap, Collectors.groupingBy, when not to stream
• CompletableFuture basics for async composition

JVM

• Heap vs stack vs metaspace — where variables and objects live
• GC roots, minor vs full GC, generational idea
• Common OutOfMemoryError / StackOverflowError causes
• LTS timeline: 8, 11, 17, 21 headline features

Concurrency

• ExecutorService, Future, graceful shutdown
• synchronized, volatile, AtomicInteger, ReentrantLock
• ConcurrentHashMap, CopyOnWriteArrayList, blocking queues
• Virtual threads: IO-bound fit, pinning awareness, pool sizing vs JDBC limits

Coding hygiene

• Program to interfaces; minimal mutable shared state
• Close resources; charset explicit for text files
• No null-heavy APIs where Optional or empty collections clarify intent
• Read stack traces; use debugger and jcmd / thread dump vocabulary

Interview topic map

Practice explaining aloud in 2–3 minutes per row — interviewers probe depth fast.

Where to go next

Design patterns — vocabulary for recurring structures in production code:

/design-patterns/learn/singleton-pattern/

Low-level design — translate requirements into classes and APIs under time pressure:

/low-level-design/learn/in-a-hurry/introduction/

Coding patterns — algorithmic practice that complements Java mechanics:

/code/learn/two-pointers/overview/

After Core Java, a typical path is Spring Boot (web, DI, data access) or Android/Kotlin depending on role — pick one stack and build a small end-to-end project using this checklist as a rubric.

Practice checkpoint

1. Whiteboard: thread-safe hit counter — two acceptable designs? Answer: AtomicLong / LongAdder, or synchronized inc() on holder object.

2. API returns user birthday to global clients — which type? Answer: LocalDate in domain; store/transmit as ISO string or epoch policy documented.

3. One feature from Java 21 you would adopt first in a legacy 11 codebase — justify. Answer: varies; e.g. virtual threads if IO-bound servlet app on 21 runtime; records for DTOs if on 17+.

4. Biggest gap from this checklist for you — pick one and schedule 90 minutes of practice. Answer: personal — pick weakest [ ] row and drill.

Interview angles

• “Tell me about a hard bug” — prepare one story involving concurrency, classloader leak, or equals/hashCode.
• Version migration — show you know 8→11→17→21 drivers, not buzzwords.
• Trade-off language — “ArrayList vs LinkedList” always ties to access pattern and complexity.
• Humility — “I would profile before tuning GC” beats memorizing every -XX flag.

Course complete

You finished the Core Java track. Revisit chapters where you marked need notes, build one small CLI or REST service without Spring using java.time, ConcurrentHashMap, and virtual threads, then continue through the links above.

Happy learning.