This directory groups interview questions and preparation guides by topic. We start with the skills named in the job description, revise the fundamentals behind them and practice explaining our answers aloud. For each topic, a useful answer includes the main idea, a small example and a reason for choosing one approach over another.
We also check the interview format before making a study plan. A coding round needs practice solving problems, while a project discussion needs clear examples from work we have actually done. We can ask the recruiter about the rounds and use the guides below to fill specific gaps.
1. Start with the Java topics in the job description
For a junior Java role, we begin with core Java, object-oriented programming, strings and collections. For an experienced role, we also prepare concurrency, JVM behavior and design decisions. JVM stands for Java Virtual Machine, the runtime that executes Java bytecode.
Begin with the Core Java, OOP, Collections and String guides below, then add concurrency and JVM material according to the role. Use a topic guide to revise a concept, then write a small example without looking at the answer. Explaining why the example behaves as it does is more useful than memorizing a definition alone.
- Java Interview Preparation Guide
- Core Java Interview Questions
- Concurrency Interview Questions
- OOP Interview Questions
- Java Collections Interview Questions
- Java HashMap Interview Questions
- Java String Interview Questions
- How HashMap Works
- How Iterator Works
- Hashtable and Its Alternatives
- Interview Questions Asked for an Oracle Project
- Java Interview Questions for Five Years of Experience
2. Match Spring preparation to the application stack
For a Spring role, we practice explaining what happens when an HTTP request reaches an application. MVC stands for Model-View-Controller, a way to separate data, presentation and request coordination. The Spring MVC guide covers request handling, while the Boot guide explains how application configuration creates and connects components.
For security questions, we distinguish authentication, which identifies a caller, from authorization, which decides what that caller may do. AOP stands for aspect-oriented programming, which separates shared behavior such as transaction handling from the application methods it surrounds. The AOP guide explains how a proxy, an object that intercepts calls to another object, adds that behavior around a method. That idea also helps us understand transaction and method-security questions.
- How DispatcherServlet Works
- Spring Boot Interview Questions and Auto-configuration
- Spring MVC Interview Questions
- Spring AOP Interview Questions
- Spring Security Interview Questions
3. Add the tools and coding rounds the role requires
Choose these guides according to the role. For SQL, we work through small tables and explain which rows a query returns. For Git, we explain how a command changes the working files and history. For Docker, we distinguish an image from a running container and describe what happens to its data.
For coding practice, we explain the approach before writing it, check a small example and discuss time and memory use. The DSA guide groups problems by topic so we can practice a technique across related problems. DSA means data structures and algorithms.
- Top 40 DSA Problems to Practice for Coding Interviews
- SQL Interview Questions
- Docker Interview Questions
- Python Interview Questions
- Git Interview Questions
- Interview Puzzles and Coding Exercises
4. Prepare decisions from your own projects
These guides support questions about maintainability, testing, error handling and performance. We connect a principle to a concrete decision, such as separating storage from email delivery or testing a query against a real database.
When discussing our own work, we explain the requirement, the alternatives we considered and what we observed after the change. If an example is only a personal practice exercise, we say so rather than presenting it as production experience.
- SOLID Principles in Java
- Open-Closed Principle
- Single Responsibility Principle
- Unit Testing Best Practices
- FIRST Principles for Reliable Unit Tests, covering fast, independent, repeatable, self-validating and timely tests
- Testing the Data Access Object (DAO) Layer
- Eight Signs of Poorly Written Unit Tests
- Java Exception Handling Best Practices
- Camel Case, Pascal Case, Snake Case and Kebab Case
- Improving Java Application Performance
5. Practice explaining and applying each answer
We can use a short study session to answer a few questions aloud, solve one relevant coding problem and revisit one answer we could not explain clearly. A practice partner can ask follow-up questions that reveal gaps a memorized answer hides.
We also prepare questions for the team, such as how it reviews code, tests changes and investigates failures. The Tech Interview Handbook provides a broader guide to interview formats and preparation beyond the topic questions in this directory.
Happy Learning!
