50 Java Interview Questions Answers for Practice
Tags: programming, java, development, coding
Published: 2024-04-13 10:28:38

---
title: 50 Java Interview Questions Answers for Practice
published: true
description: Frequently asked core Java interview questions for Java developers
tags: programming, java, development, coding
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2024-04-09 10:54 +0000
---
*Disclosure: This post includes affiliate links; I may receive compensation if you purchase products or services from the different links provided in this article.*

![Java Interview qustions](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m941ygdqbd9b1sezr8ef.png)

Hello devs, are you preparing for Java developer interviews? If Yes, here is a list of some useful Java interview questions for experienced Java programmers having experience in range of 2 to 5 years. 

As an experienced developer you are expected to learn about OOP concepts, Java basics, **Java Collection framework**, Multi-threading and Concurrency utilities introduced in Java 5 and 6, Debugging Java application, Algorithm and Data structure, Some questions on design patterns, JVM and Garbage collection and couple of puzzles.

Actually its mix of everything you do in your day to day work.

If you are going for Java developer with some exposure on web development you will also be asked about popular Java frameworks like Spring, Hibernate, Struts 2.0 and others.

If you have more than 5 years of experience you can also expect questions about build tools like Maven, ANT and Gradle, Java best practices, Unit testing and JUnit and **your experience about solving production issues**.

> One of the most common question I have faced is talking about the last production problem you have faced and how did you solved it. 

If you are asked same question, give them step by step detail, right from analyzing problem to tactical fix to strategic solution.

In this article, I am going to share my list of Java Interview question for Java guys having 2 to 5 years of experience. Since I had similar experience couple of year ago, I know what questions are asked and keeping a list for your own always helps when you start looking for new challenge in your career.

I am not providing answers of these question in this post due to two reasons, questions are quite simple and you guys probably know the answer, second providing answer means I cannot use this post for my own preparation later, which is more important.

Though, I could write another article answering all these question if anyone request or I feel people need it.

By the way, if you are new to Java programming language or want to improve Java skills then you can also checkout sites like  [CodeGym](https://codegym.cc/?ref=javinpaul3), [ZTM](https://academy.zerotomastery.io/a/aff_qdttm1hx/external?affcode=441520_zytgk2dn) and [karpado](https://karpadoschool.teachable.com/a/aff_dndxllz7/external?affcode=536712_cf-umzkm) to learn Java by building Games and projects. 


[![Grokking the Java Interview book](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/le6kolmisnaczcrxob3x.png)](https://gumroad.com/l/QqjGH)

## Java Interview Questions for 1 to 2 years Experienced
This list contains questions from different topics e.g. OOP concepts, multi-threading and concurrency, Java collections, Web services, Spring, Hibernate, Database and JDBC, it doesn't cover all topics you need to prepare. 

I will add few more topics later when I have some time, for now, try to answer these questions without doing Google :)

### Java Interview questions on OOP Concepts
Here are a couple of questions on OOP design, SOLID principle and baseic programming concepts

**1\. What is the difference between loose coupling and tight coupling?** 
Loose coupling allows components to interact with each other with minimal dependencies, while tight coupling creates strong dependencies between components.

**2\. What is the difference between cohesion and coupling?** 
Cohesion refers to the degree to which elements within a module belong together, while coupling refers to the degree of interdependence between modules.

**3\. What is Liskov Substitution principle? Can you explain with an example?** 
Liskov Substitution principle states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. 

For example, if you have a class hierarchy with a superclass "Shape" and subclasses "Circle" and "Square", any method that works with Shape should also work with Circle or Square without causing errors.

**4\. What is the difference between abstract class and interface in Java?** 
Abstract classes can have both abstract and concrete methods, while interfaces can only have abstract methods. Additionally, a class can implement multiple interfaces but can only extend one abstract class.

**5\. What is the difference between composition, aggregation, and association?** 
Composition implies a strong ownership relationship where the lifetime of the contained object is dependent on the container. 

Aggregation implies a weaker relationship where the contained object can exist independently of the container. Association implies a relationship between two classes without any ownership or lifecycle dependency.

-----

### Java Interview questions on Collections
Now, let's see a few questions form Collections and Stream

**1\. Difference between List, Set, and Map in Java?** 
Lists maintain elements in sequential order and allow duplicates (e.g., ArrayList, LinkedList). Sets do not allow duplicates and do not guarantee order (e.g., HashSet, TreeSet). Maps store key-value pairs and do not allow duplicate keys (e.g., HashMap, TreeMap).

**2\. Difference between synchronized and concurrent collection in Java?** 
Synchronized collections use explicit locking to achieve thread-safety, allowing only one thread to modify the collection at a time. Concurrent collections use non-blocking algorithms and are designed for high concurrency, allowing multiple threads to modify the collection concurrently without explicit locking.

**3\. How does the get method of HashMap work in Java?** 
The `get` method of HashMap calculates the hash code of the provided key, determines the index in the underlying array based on the hash code, and then searches for the key at that index. If found, it returns the corresponding value; otherwise, it returns null.

**4\. How is ConcurrentHashMap different from Hashtable? How does it achieve thread-safety?** 
ConcurrentHashMap allows concurrent access to the map without blocking, while Hashtable uses synchronized methods to achieve thread-safety, resulting in potential performance bottlenecks. ConcurrentHashMap achieves thread-safety by dividing the map into segments, each with its lock, allowing multiple threads to modify different segments concurrently.

**5\. When to use LinkedList over ArrayList in Java?** 
Use LinkedList when frequent insertion and deletion operations are required, as LinkedList provides constant-time insertion and deletion at any position. Use ArrayList when random access and iteration are frequent, as ArrayList provides constant-time access by index.

-----

### Java Interview questions on Concurrency and Threads
Now, its time to see questions from Java multithreading and concurrency concepts:

**1\. How do notify and notifyAll work, and what's the difference between them? Why prefer notifyAll to notify?** 
Both `notify` and `notifyAll` are methods in Java used to wake up threads waiting on a monitor (i.e., waiting to acquire an object's lock). `notify` wakes up one randomly selected thread, while `notifyAll` wakes up all waiting threads. `notifyAll` is preferred because it ensures that all waiting threads are notified, preventing potential indefinite waiting and improving system responsiveness.

**2\. What is a race condition and how do you avoid it?** 
A race condition occurs when the outcome of a program depends on the timing or interleaving of multiple threads. To avoid race conditions, you can use synchronization mechanisms like locks, semaphores, or atomic operations to ensure that critical sections of code are executed atomically or only by one thread at a time.

**3\. What is a deadlock and how do you avoid it?** 
Deadlock occurs when two or more threads are stuck waiting for each other to release resources that they need to proceed. To avoid deadlock, you can use techniques such as resource ordering, avoiding nested locks, or using timeouts for acquiring locks. Additionally, designing code with a clear and consistent locking order can help prevent deadlocks.

**4\. What are some of the high-level concurrency classes provided by java.util.concurrent and how do they work?** 
Some high-level concurrency classes provided by `java.util.concurrent` include `ExecutorService`, `ThreadPoolExecutor`, `CountDownLatch`, `Semaphore`, `CyclicBarrier`, `BlockingQueue`, and `ConcurrentHashMap`. These classes provide thread-safe implementations of common concurrency patterns and mechanisms like thread pools, synchronization primitives, and concurrent data structures.

**5\. Can you implement a producer-consumer solution in Java?**
Yes, here is the code:

```java
import java.util.concurrent.ArrayBlockingQueue;

class Producer implements Runnable {
    private final ArrayBlockingQueue<Integer> queue;
    private int count = 0;

    Producer(ArrayBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            while (true) {
                queue.put(produce());
                Thread.sleep(1000); // Simulate some work
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private int produce() {
        System.out.println("Producing: " + count);
        return count++;
    }
}

class Consumer implements Runnable {
    private final ArrayBlockingQueue<Integer> queue;

    Consumer(ArrayBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            while (true) {
                consume(queue.take());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void consume(int item) {
        System.out.println("Consuming: " + item);
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

        producerThread.start();
        consumerThread.start();
    }
}

```
-----

### Java Interview questions on Database, SQL, and JDBC
JDBC is used for connecting database from Java program, let's ee a few questions on Database and JDBC
**1\. How do you prevent SQL injection attacks?** 
To prevent SQL injection attacks, use parameterized queries (prepared statements) with bound parameters, input validation, and escape characters. Avoid dynamic SQL queries constructed by concatenating user input.

**2\. What is the difference between WHERE and HAVING clause?** The WHERE clause filters rows before the grouping and aggregation process, while the HAVING clause filters aggregated data after the grouping process based on specified conditions.

**3\. What are transactions? What is ACID?** 
Transactions are a set of SQL statements that are executed as a single unit of work. ACID is an acronym for Atomicity, Consistency, Isolation, and Durability, which are properties that ensure the reliability of transactions in a database system.

**4\. Difference between truncate, delete, and drop clause in SQL?**

-   `TRUNCATE`: Removes all rows from a table but retains the table structure and any associated constraints or indexes.
-   `DELETE`: Removes specific rows from a table based on a condition, but retains the table structure and associated constraints.
-   `DROP`: Deletes an entire table, including its structure, data, and associated constraints and indexes.

**5\. What are window functions? How do they work?**
Window functions perform calculations across a set of rows related to the current row within a query result set. They allow you to perform aggregate functions (such as SUM, AVG, COUNT) over a specified window or subset of rows, defined by the OVER clause. Window functions operate on a set of rows and return a single value for each row based on that set of rows. They are often used for tasks such as ranking, aggregation, and calculating running totals.

See, [**Grokking the SQL Interview**](https://javinpaul.gumroad.com/l/grokking-the-sql-interview) book if you need more questions on Database and SQL

[![SQL Interview questions books](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hynfkgkv3tl2lp8yhzsr.png)](https://javinpaul.gumroad.com/l/grokking-the-sql-interview) 
-----

### Java Interview questions on Hibernate
Now, its time to see questions from Hibernate, one of the popular Java framework:

**1\. When is it better to use plain SQL instead of ORM?** 
It's better to use plain SQL when:
-   Complex queries need to be optimized for performance.
-   The database schema or query requirements are not well-supported by the ORM framework.
-   Direct control over SQL statements, database connections, or transactions is required.

**2\. Difference between sorted and ordered collection?** 
In Java, a sorted collection maintains elements in a specific order defined by a comparator or by the natural ordering of elements, while an ordered collection maintains elements in the order they were inserted.

**3\. How does second level cache work?** 
Second level cache in Hibernate stores objects in a shared cache region, typically across multiple sessions. When an entity is queried for the first time, it is fetched from the database and stored in the second level cache. Subsequent queries for the same entity can then be satisfied from the cache instead of hitting the database, improving performance.

**4\. What is the difference between save() and persist() in Hibernate?** 
Both `save()` and `persist()` methods in Hibernate are used to save an entity to the database. However, `save()` returns the generated identifier immediately, while `persist()` doesn't guarantee immediate execution of the SQL INSERT statement; it may be executed later during flush time. Additionally, `persist()` is part of the JPA specification, while `save()` is specific to Hibernate.

**5\. What is the difference between Hibernate and MyBatis?**
-   Hibernate is a full-fledged ORM framework that maps Java objects to database tables, manages database connections, and provides various querying mechanisms. MyBatis, on the other hand, is a lightweight persistence framework that uses SQL mapping files to map Java objects to SQL queries.
-   Hibernate is typically used for domain-driven development, where object-oriented modeling is prominent, while MyBatis is often preferred for projects where direct control over SQL queries is required, such as legacy database systems or complex SQL scenarios.
-   Hibernate provides caching mechanisms, automatic dirty checking, and transaction management, while MyBatis offers more control over SQL queries and mappings, allowing developers to write SQL queries directly.

-----

### Java Interview questions on Web Services and Microservices
Now, let's see questions form Microservice architecture and REST web services

**1\. Difference between SOAP-based and REST-based web services?** SOAP is protocol-based with rigid structure, while REST is architectural style based on stateless communication with flexible endpoints.

**2\. What is SOAP Envelope?** 
It encapsulates the entire SOAP message and defines its structure.

**3\. How to implement security in RESTful web service?** 
Implement SSL/TLS for encryption and authentication.

**4\. What is Payload in REST?** 
It's the data transmitted in the body of the HTTP request or response.

**5\. What is Microservices?** It's an architectural style where applications are composed of small, independent services.

**6\. What is the difference between Microservices and REST?** Microservices refer to architectural design, while REST is an architectural style for networked applications.

**7\. What is the difference between Monolithic and Microservices?** 
Monolithic has single codebase, while Microservices have multiple, independent components; Monolithic can have higher latency.

**8\. What problem does SAGA pattern solve?** 
It manages distributed transactions in Microservices architecture.

**9\. What is service discovery in Microservices?** 
It's the mechanism for locating services dynamically within a Microservices architecture.

**10\. What are common Microservices Patterns you have used in your project?** 
Service Registry, Circuit Breaker, API Gateway.

------

### Java and Spring Interview Preparation Material
Before any Java and Spring Developer interview, I always read the [Grokking the Java Interview] (https://gumroad.com/l/QqjGH) and [Grokking the Spring boot Interviw](https://javinpaul.gumroad.com/l/HMOAv)

Here are few more questions from these books:

[![Java object oriented questions ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2gu1mkhyqugcrmvvll8q.png)](https://gumroad.com/l/QqjGH)

and, 

[![Spring boot interview questions] (https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k387mequ4mlgayb6o89e.png)](https://javinpaul.gumroad.com/l/HMOAv)


And, if you are new to Java then you can also checkout sites like  [CodeGym](https://codegym.cc/?ref=javinpaul3), [ZTM](https://academy.zerotomastery.io/a/aff_qdttm1hx/external?affcode=441520_zytgk2dn) and [karpado](https://karpadoschool.teachable.com/a/aff_dndxllz7/external?affcode=536712_cf-umzkm) to learn Java by building Games and projects. 
Thank you guys for now. You can find the answers in web easily but if there are enough interest, I can also update the post. Let me know if you have also asked these questions before. If anyone knows answer, can also post as comment.

Good luck for your Java Interview.

By the way, if you are new to Java programming language or want to improve Java skills then you can also checkout following best Java courses to get better: