How to Prepare for a Technical Interview as a Java Fresher in 2026: Questions, Topics, Projects & Preparation Plan

What you will learn in this guide

How a Java fresher hiring process works round by round, with a funnel chart.

Which topics carry the most weight, shown with a ratio chart and a priority table.

50+ Java, Spring Boot, SQL and DSA interview questions with short, interview-ready answers.

Code you can type and explain in an interview: OOP, collections, streams, threads, REST and SQL.

Five projects for your resume, a weekly roadmap, a preparation cycle and a readiness curve.

Core Java fundamentals

Direct questions, output-prediction snippets

Clear OOP concepts, correct use of String, collections and exceptions

Problem solving

Coding on paper, whiteboard or online IDE

Logical approach, edge cases handled, readable code

Practical exposure

Project discussion, Spring Boot and SQL questions

A working project on GitHub that you can explain end to end

Learning attitude

Questions on latest Java versions, tools, Git

Awareness of Java 17/21 features, Maven, Git, REST and testing basics

Communication

HR round, explaining your code aloud

Structured answers, honest admission when you do not know something

1. Aptitude / online test

Quantitative, logical reasoning, verbal ability, basic coding MCQs

30 to 90 minutes, timed, online

Daily aptitude practice, previous papers, time management

2. Technical round 1

Core Java, OOP, collections, coding problems

30 to 45 minutes, face to face or video call

Revise fundamentals, solve 3 to 5 problems daily

3. Technical round 2

Project deep dive, Spring Boot, REST, SQL, DSA

45 to 60 minutes

Know every line of your project, prepare database design

4. Managerial / HR

Attitude, communication, relocation, salary, goals

15 to 30 minutes

Prepare self-introduction, strengths, weaknesses, why this company

Pro tip

Many freshers prepare for the technical round and then lose the offer in the HR round. Give HR preparation at least 10% of your total time. The time split chart later in this guide shows exactly where it fits.

Core Java & OOP

JVM/JDK/JRE, data types, String pool, static, final, inheritance, polymorphism, abstraction, encapsulation, interfaces

Very high

Collections & Generics

List, Set, Map, Queue, HashMap internals, Comparable vs Comparator, fail-fast iterators

Very high

DSA & Coding

Arrays, strings, recursion, sorting, searching, linked list, stack, queue, hashing, basic trees

Very high

SQL & JDBC

Joins, GROUP BY, HAVING, subqueries, indexes, normalisation, transactions, JDBC steps

High

Spring Boot & REST

IoC, DI, annotations, controller-service-repository, JPA, exception handling, REST principles

High

Java 8+ Features

Lambda, functional interfaces, Stream API, Optional, records, text blocks, switch expressions

High

Exceptions & Multithreading

Checked vs unchecked, try-with-resources, thread lifecycle, synchronized, volatile, ExecutorService

Medium

Tools & Basics

Git, Maven, Postman, basic Linux commands, unit testing with JUnit

Medium

Mutability

Immutable

Mutable

Mutable

Thread safety

Safe (immutable)

Not thread safe

Thread safe (synchronized)

Speed

Slow for repeated changes

Fastest

Slower than StringBuilder

Use when

Constant text, keys

Single-thread string building

Shared string building (rare today)

Methods

Abstract and concrete

Abstract, default, static and private methods (Java 8/9+)

Variables

Any type of variable

public static final constants only

Inheritance

A class extends only one

A class can implement many

Constructor

Allowed

Not allowed

Best for

Shared state and common base behaviour

Defining a contract / capability

// Custom exception and try-with-resources

public class InvalidAgeException extends RuntimeException {

    public InvalidAgeException(String message) { super(message); }

}

static void register(int age) {

    if (age < 18) throw new InvalidAgeException("Minimum age is 18");

    System.out.println("Registered");

}

// try-with-resources closes the reader automatically

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {

    System.out.println(br.readLine());

} catch (IOException e) {

    System.err.println("File error: " + e.getMessage());

}

ArrayList

Insertion

Yes

Yes

get O(1), add end O(1) amortised, insert middle O(n)

Fast random access, read-heavy lists

LinkedList

Insertion

Yes

Yes

get O(n), add/remove at ends O(1)

Frequent insert/remove at the ends (queue, deque)

HashSet

None

No

One null

add/contains O(1) avg

Unique values, fast lookup

LinkedHashSet

Insertion

No

One null

O(1) avg

Unique values with insertion order

TreeSet

Sorted

No

No

O(log n)

Sorted unique values

HashMap

None

Unique keys

One null key

O(1) avg

General key-value storage

LinkedHashMap

Insertion / access

Unique keys

One null key

O(1) avg

Cache (LRU) and ordered maps

TreeMap

Sorted by key

Unique keys

No null key

O(log n)

Sorted key-value data, range queries

// Sort by marks (descending), then by name

List<Student> list = new ArrayList<>(students);

list.sort(Comparator.comparing(Student::getMarks).reversed()

                    .thenComparing(Student::getName));

// ExecutorService and virtual thread

ExecutorService pool = Executors.newFixedThreadPool(4);

Future<Integer> result = pool.submit(() -> 21 * 2);

System.out.println(result.get());   // 42 (inside a method that throws Exception)

pool.shutdown();

// Java 21 virtual thread

Thread.ofVirtual().start(() -> System.out.println("Hello from a virtual thread"));

Lambda expressions

Java 8

Short anonymous functions: (a, b) -> a + b

Functional interfaces

Java 8

Interface with a single abstract method, e.g. Runnable, Predicate, Function

Stream API

Java 8

Declarative pipelines: filter, map, reduce, collect

Optional

Java 8

Container that avoids null checks and NullPointerException

var (local variable type inference)

Java 10

Compiler infers the type: var list = new ArrayList<String>();

Text blocks

Java 15

Multi-line strings using triple quotes

Records

Java 16

Compact immutable data classes: record Point(int x, int y) {}

Sealed classes

Java 17

Restrict which classes can extend a type

Pattern matching, switch expressions

Java 14 to 21

Cleaner type checks and expression-style switch

Virtual threads

Java 21

Lightweight JVM-managed threads for high concurrency

// Stream API example commonly asked in interviews

record Employee(String name, String dept, double salary) {}

// Average salary per department for employees earning above 30000

Map<String, Double> avg = employees.stream()

    .filter(e -> e.salary() > 30000)

    .collect(Collectors.groupingBy(Employee::dept,

             Collectors.averagingDouble(Employee::salary)));

// Names of the top 3 highest paid employees

List<String> top3 = employees.stream()

    .sorted(Comparator.comparingDouble(Employee::salary).reversed())

    .limit(3)

    .map(Employee::name)

    .toList();

// Strings and basic logic

// 1. Reverse a string and check palindrome

static boolean isPalindrome(String s) {

    String clean = s.replaceAll("[^A-Za-z0-9]", "").toLowerCase();

    return clean.equals(new StringBuilder(clean).reverse().toString());

}

// 2. First non-repeating character (O(n) time)

static char firstUnique(String s) {

    Map<Character, Integer> freq = new LinkedHashMap<>();

    for (char c : s.toCharArray()) freq.merge(c, 1, Integer::sum);

    for (var e : freq.entrySet()) if (e.getValue() == 1) return e.getKey();

    return '\0';

}

// 3. Fibonacci (iterative, O(n) time, O(1) space)

static long fib(int n) {

    long a = 0, b = 1;

    for (int i = 0; i < n; i++) { long t = a + b; a = b; b = t; }

    return a;

}

// Design questions: immutable class and Singleton

// Immutable class: final class, final fields, no setters, defensive copy

public final class Student {

    private final int id;

    private final String name;

    private final List<String> skills;

    public Student(int id, String name, List<String> skills) {

        this.id = id;

        this.name = name;

        this.skills = List.copyOf(skills);   // defensive copy

    }

    public int getId() { return id; }

    public String getName() { return name; }

    public List<String> getSkills() { return skills; }

}

// Thread-safe Singleton using the holder idiom

public class AppConfig {

    private AppConfig() {}

    private static class Holder { static final AppConfig INSTANCE = new AppConfig(); }

    public static AppConfig getInstance() { return Holder.INSTANCE; }

}

Interview habit that sets you apart

Before writing code, say your approach in one or two sentences, mention edge cases (empty input, null, duplicates), then code. Finish by walking through a sample input and stating the complexity. This structure alone makes an average solution sound professional.

// Spring Boot 3: Entity + Repository + REST Controller + global exception handler

@Entity

public class Course {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;

    @NotBlank private String title;

    // getters and setters

}

public interface CourseRepository extends JpaRepository<Course, Long> {

    List<Course> findByTitleContainingIgnoreCase(String keyword);

}

@RestController

@RequestMapping("/api/courses")

public class CourseController {

    private final CourseRepository repo;

    public CourseController(CourseRepository repo) { this.repo = repo; }

    @GetMapping

    public List<Course> all() { return repo.findAll(); }

    @GetMapping("/{id}")

    public ResponseEntity<Course> one(@PathVariable Long id) {

        return repo.findById(id).map(ResponseEntity::ok)

                   .orElse(ResponseEntity.notFound().build());

    }

    @PostMapping @ResponseStatus(HttpStatus.CREATED)

    public Course create(@Valid @RequestBody Course c) { return repo.save(c); }

}

@RestControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)

    public ResponseEntity<String> badRequest(IllegalArgumentException ex) {

        return ResponseEntity.badRequest().body(ex.getMessage());

    }

}

WHERE vs HAVING

WHERE filters rows before grouping; HAVING filters groups after GROUP BY.

DELETE vs TRUNCATE vs DROP

DELETE removes selected rows and can be rolled back; TRUNCATE removes all rows quickly; DROP removes the whole table structure.

Primary key vs foreign key

A primary key uniquely identifies a row; a foreign key links a row to a primary key in another table.

INNER vs LEFT JOIN

INNER returns only matching rows; LEFT returns all rows from the left table plus matches from the right.

What is an index?

A structure that speeds up reads on a column at the cost of slower writes and extra storage.

What is normalisation?

Organising tables to reduce redundancy, commonly up to 3NF.

What does ACID stand for?

Atomicity, Consistency, Isolation, Durability: guarantees of reliable transactions.

-- Three SQL queries asked in almost every fresher interview

-- Second highest salary

SELECT MAX(salary) FROM employee

WHERE salary < (SELECT MAX(salary) FROM employee);

-- Find duplicate emails

SELECT email, COUNT(*) AS total FROM users

GROUP BY email HAVING COUNT(*) > 1;

-- Employee count per department, including empty departments

SELECT d.dept_name, COUNT(e.id) AS total

FROM department d LEFT JOIN employee e ON e.dept_id = d.id

GROUP BY d.dept_name;

Arrays

Two pointers, prefix sum, sliding window, Kadane's algorithm

30

Strings

Anagram, palindrome, frequency map, substring problems

25

Hashing (HashMap/HashSet)

Two Sum, duplicates, grouping, frequency counting

15

Linked list

Reverse, detect cycle, merge, middle node

15

Stack and queue

Valid parentheses, next greater element, queue using stacks

15

Sorting and searching

Binary search and variations, merge sort, quick sort basics

15

Recursion and backtracking

Factorial, subsets, permutations, N-Queens basics

10

Trees

Traversals, height, BST insert/search, level order

20

Basic dynamic programming

Fibonacci, climbing stairs, knapsack, longest common subsequence

10

// Two classic patterns: hashing and binary search

// Two Sum with HashMap: O(n) time, O(n) space

static int[] twoSum(int[] nums, int target) {

    Map<Integer, Integer> seen = new HashMap<>();

    for (int i = 0; i < nums.length; i++) {

        Integer j = seen.get(target - nums[i]);

        if (j != null) return new int[]{j, i};

        seen.put(nums[i], i);

    }

    return new int[]{-1, -1};

}

// Binary search: O(log n) time

static int binarySearch(int[] a, int key) {

    int low = 0, high = a.length - 1;

    while (low <= high) {

        int mid = low + (high - low) / 2;   // avoids integer overflow

        if (a[mid] == key) return mid;

        if (a[mid] < key) low = mid + 1; else high = mid - 1;

    }

    return -1;

}

Student / Employee Management System

Core Java, JDBC or Spring Boot, MySQL

CRUD, search, pagination, validation, role-based access

Beginner

Online Course or Library Portal

Spring Boot, JPA, MySQL, Thymeleaf/React

Registration, login, course catalogue, enrolment, admin panel

Beginner to intermediate

E-commerce Backend API

Spring Boot, JPA, MySQL, Postman

Products, cart, orders, JWT authentication, exception handling

Intermediate

Expense Tracker with Reports

Spring Boot, MySQL, React or HTML/JS

Add/edit expenses, category totals, monthly summary charts

Intermediate

Job Portal or Hospital Appointment System

Spring Boot, Spring Security, MySQL, REST

Multiple user roles, booking flow, email notification, search filters

Intermediate to advanced

1. Problem

Why the project exists

Small institutes track students on paper and lose data.

2. Solution

What you built in one sentence

A Spring Boot REST application with MySQL for managing student records.

3. Architecture

Layers, database, security

Controller, service, repository layers; JWT for login; MySQL with four tables.

4. Challenge

One real problem you solved

Fixed the N+1 query problem using a fetch join, cutting response time.

5. Improvement

What you would do next

Add caching, Docker deployment and a CI pipeline.

Tell me about yourself

Use a 60-second structure: education, technical skills, one project, career goal. Do not read your resume aloud.

Why Java? Why should we hire you?

Link Java's strengths (enterprise demand, ecosystem) to your projects and eagerness to learn.

What are your strengths and weaknesses?

Give a genuine strength with proof; pick a real, fixable weakness and show what you are doing about it.

Where do you see yourself in 5 years?

Show growth within the role: strong developer, then ownership of modules, then mentoring.

Are you willing to relocate or work in shifts?

Answer honestly and professionally; avoid vague replies.

Do you have any questions for us?

Ask about training, the technology stack, team structure and the first-year learning path.

Sample answer: Tell me about yourself

"I am a computer science graduate with a strong interest in back-end development. I learned Core Java, collections, SQL and Spring Boot, and built a student management REST API with JWT login that I have pushed to GitHub. I practise DSA daily and enjoy debugging. I am looking for a Java developer role where I can learn from a good team and contribute to real projects."

1

Java basics and OOP

Syntax, data types, loops, arrays, classes, objects; 2 small programs daily

Comfortable writing basic programs

2

OOP in depth and Strings

Inheritance, polymorphism, abstraction, interfaces, String pool, StringBuilder

Can explain OOP with examples

3

Exceptions and Collections I

Checked/unchecked, custom exceptions, List and Set, iterators

10 collection programs done

4

Collections II and Java 8

Map internals, Comparable/Comparator, lambdas, streams, Optional

Can explain HashMap internals

5

SQL and JDBC

Joins, group by, subqueries, indexes, JDBC CRUD

20 SQL queries solved

6

Spring Boot basics

IoC, DI, first REST API, controller-service-repository

Working CRUD API

7

JPA and project start

Entities, relationships, validation, start the capstone project

Project skeleton on GitHub

8

Project build and security basics

Exception handling, DTOs, login/JWT basics, Postman testing

Project 70% complete

9

Multithreading and revision

Threads, synchronization, ExecutorService, revise Java Q&A

Revision notes ready

10

DSA intensification

2 to 3 problems daily: arrays, strings, hashing, linked list

100+ problems solved

11

Mock interviews I

Two technical mocks, one HR mock, resume review

Weak topics identified

12

Mock interviews II and applications

Fix weak areas, final project polish, apply to companies and walk-ins

Interview-ready, applications sent

Block 1

Concept learning: Java, Spring Boot or SQL topic of the day

60 minutes

Block 2

Hands-on coding: implement the concept in the IDE

60 minutes

Block 3

DSA: solve 2 to 3 problems and write the approach in a notebook

60 minutes

Block 4

Project work, aptitude practice or mock interview (rotate by day)

30 to 60 minutes

Weekend

Revision, one full mock interview, update GitHub and resume

3 to 4 hours

Memorising answers without understanding

Explain every concept in your own words with a small code example.

Listing technologies you cannot explain

Keep your resume honest; revise every skill you list.

Ignoring DSA until the last week

Solve a few problems daily from the start.

Not knowing your own project deeply

Be able to explain every class, table and API endpoint.

Coding silently

Think aloud; interviewers evaluate the process, not only the answer.

Skipping edge cases

Always test with empty, null, single-element and duplicate inputs.

Bluffing when you do not know

Say "I am not sure, but I would approach it like this" and reason it out.

Neglecting SQL

Practise joins and group-by queries; they are asked in most interviews.

Poor HR preparation

Rehearse your introduction and common HR answers aloud.

Skipping mock interviews

Do at least four mocks; feedback is the fastest way to improve.

Training and upskilling

Java Full Stack Development, Software Testing, hands-on projects and practical technical skill development.

Recruitment and talent solutions

Candidate sourcing and screening, technical and aptitude assessment, campus recruitment support and end-to-end hiring for companies.

College and employability programs

Employability enhancement, technical and soft-skills training, campus drives, workshops and industry connect programs.

Placement and career support

Aptitude and technical training, mock interviews, resume and interview preparation, and job opportunities with placement support.

Course name

Java Full Stack Development (job-ready program) with placement support

Duration

Around 4 to 6 months depending on the batch and program (the institute's pages mention both)

Mode of training

Classroom training at the Warje, Pune centre and live online classes

Who can join

Engineering, BCA, MCA, BSc and other graduates, final-year students, freshers and working professionals; no coding background needed

Technical modules

Core Java, Advanced Java, Data Structures and Algorithms (DSA), Spring Boot, REST APIs, SQL, HTML, CSS and JavaScript

Practical learning

Daily coding practice, real-time projects and hands-on assignments

Aptitude and soft skills

Aptitude training, spoken English, soft-skills development and group discussion practice

Interview preparation

Mock interviews, resume building and interview guidance

Placement support

100% placement assistance and unlimited placement calls through campus and off-campus opportunities

Certificate

Course completion certificate on successful completion

Other courses

Software Testing and Data Science training programs

Weak Core Java and OOP fundamentals

Structured Core Java and Advanced Java classes with practical examples and doubt solving.

Fear of coding rounds and DSA

A dedicated DSA module with daily coding practice, so problem solving becomes a habit.

No Spring Boot or REST experience

Spring Boot and REST API training with projects that mirror what companies build.

Weak SQL and database knowledge

SQL training integrated with back-end development.

Nothing impressive to show in projects

Real-time project work that you can explain, demonstrate and place on your resume and GitHub.

Poor aptitude score in online tests

Regular aptitude training sessions alongside technical classes.

Low confidence and communication gaps

Spoken English, soft-skills sessions and group discussion practice.

No idea how real interviews feel

Mock interviews, resume and interview preparation with feedback.

Not enough interview opportunities

Placement assistance with unlimited placement calls and exposure to companies in VibrantMinds' hiring network.

A final-year student with basic Java knowledge

Start the 12-week plan now and join a structured course for DSA, Spring Boot and mock interviews.

A fresh graduate with no job offer yet

Join a job-oriented Java Full Stack program with placement support and apply in parallel from week 8.

A non-IT graduate switching to software

Begin with the fundamentals in a beginner-friendly classroom or online batch; no coding background is required.

Someone with a career gap

Use structured training, projects and mock interviews to rebuild confidence and fill your resume with recent work.

1

Call or message +91 95035 79517 or visit the Warje, Pune centre to speak with a counsellor.

2

Ask for the current Java Full Stack syllabus, batch timings (classroom or online) and fee details.

3

Attend a demo or counselling session and check whether the schedule suits you.

4

Enrol, follow the weekly plan, build projects, give mock interviews and apply with placement support.

Company

VibrantMinds Technologies Pvt. Ltd.

Office address

Viva Academy Building, Near St. Mary's Church & Petrol Pump, Mumbai-Bangalore Highway, Warje, near Karvenagar, Pune, Maharashtra 411058

Phone / WhatsApp enquiry

+91 95035 79517

Careers email

careers@vibrantmindstech.com

Main website

www.vibrantmindstech.com

Candidates page

vibrantmindstech.com/candidates

Jobs page

vibrantmindstech.com/jobs

Placements / success stories

vibrantmindstech.com/sucess-stories

Blog

vibrantmindstech.com/blog

Contact us page

vibrantmindstech.com/contact-us

Google Maps

Open location on Google Maps

LinkedIn

linkedin.com/company/vibrantminds-technologies

Facebook

facebook.com/VibrantMindsTech

Instagram

instagram.com/vibrantminds_technologies

Telegram job updates

t.me/vibrantmindsitjobs

Start your Java career journey today

Call +91 95035 79517 or visit www.vibrantmindstech.com to know more about the Java Full Stack course, Software Testing course and placement support in Pune.