10 Advanced Core Java Interview questions for Experienced Programmers (2023)

Java interview questions for Senior and Experienced programmer
Java is very big and there is no way to prepare completely for any core java interview but there is a level of the question that depends upon your experience, if you are fresher then questions asked in Java interview are mostly based on fundamentals like Iterator vs Enumeration in Java, Why main is public static and void or maybe ArrayList vs LinkedList in Java. Things changes when you apply for a senior developer, Technical lead, or Team Lead Java position, questions asked on that level are more advanced and less popular among Java circles, you may be asked questions from design pattern, questions from multi-threading, Collections, and even asked to write code, design classes and prepare JUnit tests. 

In this Java article, I will share some advanced Core Java interview questions which appear in Senior level interviews mostly on 4 to 6 years and 6 to 8 years of experience.

One important thing to note is that you can not clear the interview by just mugging the answers to these questions because the interviewer is most likely asked you follow-up questions based upon your response and the only way to get through it is to understand the topic well.

10 Core Java interview questions for senior developers and Tech lead in 2023

Here is my list of questions which is worth preparing if you are going for a core java interview for a senior position, these questions are mostly based upon Garbage collection, Concurrency, Collections, design, Coding, and testing.

1. How does ConcurrentHashMap work in Java? 2. is ConcurrentHashMap is thread-safe? (answer)

ConcurrentHashMap in Java is a thread-safe implementation of the Map interface. It achieves thread safety by dividing the underlying map into multiple segments or buckets, each of which can be independently locked. 

This design allows multiple threads to perform read and write operations concurrently, as long as they are working on different segments. While read operations do not block each other, write operations have finer-grained locking to minimize contention. 

The map dynamically resizes and rehashes segments to maintain a reasonable load factor while allowing ongoing concurrent access. It offers high concurrency and performance, making it suitable for scenarios where multiple threads need to access a shared map without external synchronization concerns.

3. Can we replace Hashtable with ConcurrentHashMap without external synchronization? (answer)
As you see there are multiple questions in this category, those are mostly follow-up and can be answered if you understand ConcurrentHashMap well. you can see this article about Hashtable and ConcurrentHashMap to learn more.

4. What is CountDownLatch in Java?
It's an advanced concurrency utility that allows one thread to wait for other threads until the count reaches zero. For example, the Application thread starts 4 other threads to download user data, product data, customer data, and market data. Application thread until all thread complete their job. Every thread once they are complete, call the countDown method which decreases count by 1. This way, the main thread or application thread starts when all thread completed their job and the count is zero. 

5. What is CyclicBarrier in Java?
CyclicBarrier is similar to CountDownLatch, the only difference is that application thread until all thread reaches to barrier instead of the count reaches to zero. You cannot reuse the latch but you can reuse the barrier in Java. 

6. What is the difference between CountDownLatch and CyclicBarrier in Java?
Concurrency is a favorite topic on advanced core java interviews and it's expected from experienced and senior Java developers to have a good understanding of multi-threading and concurrency API in Java. See these posts about CountDownLatch in Java and the Difference between CountDownLatch and CyclicBarrier in Java.

10 Advanced Core Java Interview questions for Experienced Programmer

7. What is Race condition? Have you faced any race conditions?
A race condition is a concurrency-related software bug that occurs when the behavior of a program depends on the relative timing of events, such as the execution order of threads or processes. In a race condition, the correctness of the program's outcome depends on the "race" between multiple threads or processes accessing shared resources or variables without proper synchronization. These issues can lead to unexpected and erroneous behavior.

Common scenarios that can result in race conditions include:

Shared Data Access: When multiple threads or processes read from and write to the same shared data concurrently without proper synchronization mechanisms, such as locks or semaphores.

Thread Scheduling: The order in which threads are scheduled to execute by the operating system can impact the program's behavior, especially when it affects the sequence of operations.

I/O Operations: Race conditions can also occur when multiple threads attempt to perform I/O operations (e.g., reading or writing to files) concurrently without coordination.

Resource Allocation: When multiple threads or processes compete for limited resources, such as memory or network connections, race conditions can arise.

As for whether I've faced any race conditions, I'm an artificial intelligence model developed by OpenAI, so I don't run programs or interact with software systems directly. However, race conditions are a common issue in concurrent programming, and many software developers have encountered them at some point in their careers. 

Identifying and mitigating race conditions often requires careful design, thorough testing, and the use of synchronization mechanisms like locks, semaphores, and atomic operations to ensure that shared resources are accessed safely and in a controlled manner.

8. What is deadLock in Java? Write code to avoid deadlock in Java?
Raced conditions and deadlock are major challenges while writing high-performance concurrent Java applications and hands-on experience of dealing with synchronization and concurrency issues expected from a senior and experienced Java programmer. Refer to how to avoid deadlock in Java and What is a race condition in Java for more details.

9. What is PermGen space? or Meta space in Java?
PermGen (Permanent Generation) space in Java was utilized in versions preceding Java 8. It constituted a fixed-size memory area designated for storing class metadata, encompassing class definitions, methods, and their associated data. 

However, PermGen space had limitations in terms of its size, and if an excessive number of classes were loaded or if memory leaks occurred due to class loading and unloading, it could lead to PermGen space errors. 

These errors often manifested as "java.lang.OutOfMemoryError: PermGen space." The introduction of Metaspace in Java 8 marked a departure from the fixed-size constraints of PermGen space, providing a more flexible and efficient solution for managing class metadata.

10. What is a memory leak in Java?
A memory leak in Java occurs when a program fails to release or deallocate memory that it no longer needs, resulting in a gradual consumption of system memory over time. This can lead to reduced system performance and, eventually, the program or application crashing due to running out of available memory.

Memory leaks typically happen when an application inadvertently holds references to objects in memory, preventing the Java garbage collector from reclaiming the memory occupied by these objects. Common causes of memory leaks in Java include:

Unintentional Object Retention
An object that is supposed to be temporary or should be eligible for garbage collection is still referenced by a longer-lived object or data structure.

Caching: Caching mechanisms that store references to objects indefinitely without proper expiration or cleanup strategies can lead to memory leaks.

Listeners and Callbacks: Registering listeners, callbacks, or observers without properly deregistering them can result in objects being held in memory longer than necessary.

Thread Mismanagement: Mishandling threads can lead to memory leaks if thread references are not cleaned up properly.

Unclosed Resources: Failing to close resources like files, database connections, or network sockets can cause resource leaks, which can indirectly lead to memory leaks.

Static Collections: Storing references to objects in static collections can keep them in memory throughout the application's lifecycle.

To identify and fix memory leaks in Java, developers can use profiling tools and memory analysis tools, like VisualVM, YourKit, or Java Mission Control. These tools help track memory usage and identify objects that are not being properly released. Developers can then refactor their code to ensure that references to unnecessary objects are removed when they are no longer needed or implement proper resource management techniques.

It's important to address memory leaks promptly to ensure the efficient and stable operation of Java applications, especially in long-running server applications or services.

11. What is OutOfMemoryError in PermGen or MetaSpace mens? How do you solve those kind of errors? what would be your process and which tools will you use?
An "OutOfMemoryError" in the PermGen or Metaspace memory areas is a specific error that can occur in Java applications when the Java Virtual Machine (JVM) exhausts its allocated memory for storing class metadata and related information. The error message typically appears as "java.lang.OutOfMemoryError: PermGen space" for PermGen or "java.lang.OutOfMemoryError: Metaspace" for Metaspace.

To resolve these errors, a systematic process can be followed:

Error Identification: The first step is recognizing the specific "OutOfMemoryError" message in your application logs, which will specify whether it's a PermGen or Metaspace error.

Root Cause Analysis: Analyze your code and configuration to pinpoint the source of excessive memory consumption. Common culprits include classloading issues, excessive class metadata, and overuse of string interning.

Memory Allocation Adjustment: Depending on the error type and the Java version in use, you may adjust memory allocation parameters. For PermGen, you can increase the PermGen space using JVM flags like -XX:MaxPermSize (prior to Java 8) or for Metaspace, you can use -XX:MaxMetaspaceSize. However, it's essential to balance this with the available system resources.

Code Review and Cleanup: Examine your codebase for potential memory leaks or areas where objects or resources are not properly released. Tools like profilers and memory analysis tools can help identify problematic areas.

Class Unloading: For PermGen space, consider enabling class unloading if it's disabled. In some cases, this can help reclaim memory used by obsolete classes. You can use the JVM flag -XX:+CMSClassUnloadingEnabled (prior to Java 8).

Upgrade Java Version: If you're experiencing Metaspace errors, consider upgrading to a newer Java version as Metaspace was introduced in Java 8 with a more efficient memory management approach.

Use Profiling and Diagnostic Tools: Utilize profiling tools like VisualVM, YourKit, or Java Mission Control to analyze memory usage patterns and identify memory-hogging objects or classes.

Implement Proper Resource Management: Ensure that resources like file handles, database connections, and network sockets are properly closed after use to prevent resource leaks.

Monitor and Test: Continuously monitor your application's memory usage and conduct stress tests to ensure that the adjustments and code changes have effectively resolved the issue.

By following this process and using appropriate tools, you can diagnose and resolve "OutOfMemoryError" issues related to PermGen or Metaspace in your Java applications, ensuring their stability and optimal performance.

12. What is the difference between NoClassDefFoundError and ClassNotFoundException in Java?
NoClassDefFoundError and ClassNotFoundException are both exceptions in Java related to class loading and classpath issues, but they serve different purposes and occur at different stages of the class-loading process. Here's the key difference between them:

  • This error occurs at runtime.
  • It indicates that the Java Virtual Machine (JVM) was able to find and load the class during compilation and class loading but encountered a problem when trying to initialize the class during runtime.
  • Common causes include missing runtime dependencies or issues in static initializer blocks (e.g., exceptions thrown during static variable initialization).
  • This error often indicates that the class was available during compilation but is missing or problematic during runtime.

public class Example {
    public static void main(String[] args) {
        // This line compiles successfully, assuming SomeClass exists.
        SomeClass obj = new SomeClass();

        // However, if SomeClass is not available during runtime, you'll get a NoClassDefFoundError.

  • This is an exception that occurs during the class-loading process.
  • It indicates that the JVM is unable to find the class during the class-loading process.
  • Common causes include issues with the classpath, such as the class not being in the specified classpath or the JAR file containing the class not being present.
  • This exception typically occurs when trying to explicitly load a class using Class.forName() or when attempting to use a class that the JVM needs to load as part of normal program execution.

public class Example {
    public static void main(String[] args) {
        try {
            // Attempt to load a class that doesn't exist.
        } catch (ClassNotFoundException e) {
            // Handle the exception here.

In summary, NoClassDefFoundError occurs at runtime when a class that was available during compilation cannot be initialized during runtime, while ClassNotFoundException is a checked exception that occurs during the class-loading process when the JVM cannot find the class in the specified classpath.

These are some questions related to Errors and Exceptions in Java, OutOfMemoryError and NoclassDefFoundError are the most common yet dreaded errors in Java. see the links for more details.

You can also find answers to these questions by searching on google, the key point is to understand it deeply.

Related Interview Questions from Java67 blog

Thanks for reading this article so far. If you like these Java interview questions or have seen them on your telephonic round of interviews, then please share this post with your friends and colleagues on Facebook, Twitter, Email, etc. If you have any questions or feedback, please drop a note.

All the best Guys


  1. Really good questions! Thanks a lot

  2. In my opinion, there is no point asking simple questions to experienced professionals. I would rather prefer to ask fundamental in depth, practical issued faced by enterprise application and how have they solved them in past. You can also quiz them on design, coding, best practices and more important bad practices to avoid. If someone has decent experience in Java, he definitely knows that why comparing String using == is bad or why using float or double for price can create lot of problems of precision, accuracy and rounding.


Feel free to comment, ask questions if you have any doubt.