Java Interview Questions: 1

Java Advanced Topics

HashMap Internal Working

• A HashMap uses an array of nodes (buckets) and a linked list or binary tree to store key-value pairs.
• The hash code of a key determines the bucket index, and collisions are stored in a linked list or binary tree.

ClassLoader

• A ClassLoader is part of the Java Runtime Environment that loads classes into memory.
• Types of ClassLoader include:
  • Bootstrap ClassLoader: Loads core Java classes (java.lang.*, etc.).
  • Extension ClassLoader: Loads classes from the java.ext.dirs directory.
  • System/Application ClassLoader: Loads classes from the classpath.

Java Memory Model

• The Java Memory Model (JMM) defines how threads interact through memory and what behaviors are allowed in concurrent executions.
• It specifies how and when different threads can see values written by other threads, and how to enforce ordering and visibility of changes to shared variables using volatile, synchronized, and final.

Comparable and Comparator

• Comparable is used for natural ordering and is implemented by the class itself (compareTo method).
• Comparator is used for custom ordering and is implemented as a separate class (compare method).

Volatile Keyword

• The volatile keyword ensures that changes to a variable are visible to all threads.
• It prevents the variable from being cached in CPU caches, so every read/write is done directly from/to main memory.

Garbage Collectors

• Types of garbage collectors include:
  • Serial Garbage Collector: Uses a single thread.
  • Parallel Garbage Collector: Uses multiple threads for garbage collection.
  • CMS (Concurrent Mark-Sweep) Garbage Collector: Aims for low pause times.
  • G1 (Garbage-First) Garbage Collector: Divides heap into regions and collects regions with the most garbage first.

PermGen and Metaspace

• PermGen (Permanent Generation) was used in Java 7 and earlier to store class metadata.
• Metaspace was introduced in Java 8, which is not limited by the heap size and can grow dynamically.

Synchronized Keyword

• Synchronized ensures that only one thread can execute a block of code or method at a time.
• It locks the object or class, preventing other threads from accessing the synchronized block until the lock is released.

References

• PhantomReference is used to track objects that have been finalized but not yet collected by the garbage collector.
• WeakReference is collected when no strong references exist.
• SoftReference is collected when memory is low.

Default and Static Methods in Interfaces

• Default methods allow interfaces to provide methods with implementations to avoid breaking existing implementations.
• Static methods can be called without an instance.

ForkJoinPool

• The ForkJoinPool is designed for work that can be broken into smaller tasks and executed in parallel.
• It uses the ForkJoinTask to recursively divide tasks and join the results.

Reflection

• Reflection allows inspection and modification of classes, methods, and fields at runtime.
• It is used for tasks like testing frameworks, dependency injection, and accessing private members.

Spring Framework

• Spring manages the bean life cycle through stages: instantiation, dependency injection, initialization, and destruction.
• Bean life cycle methods like @PostConstruct and @PreDestroy can be used for custom initialization and cleanup.

ExecutorService and ForkJoinPool

• ExecutorService is designed for managing a pool of threads and submitting tasks.
• ForkJoinPool is specifically designed for fork/join tasks that can be broken into smaller tasks.

CompletableFuture

• CompletableFuture extends Future with asynchronous methods, allowing non-blocking operations and combining multiple futures with functional-style callbacks.

java.util.concurrent Package

• The java.util.concurrent package provides utilities for concurrent programming, including thread-safe collections, synchronization aids, and executors for managing threads.

Spring Annotations

• @Component is a generic stereotype for any Spring-managed component.
• @Service indicates a service layer component.
• @Repository indicates a data access layer component and adds persistence exception translation.
• @Controller is used for Spring MVC controllers.

Hibernate and ORM

• Hibernate is an ORM framework that maps Java objects to database tables, managing database operations and providing features like caching, lazy loading, and transaction management.

Lazy and Eager Initialization

• Lazy Initialization defers the bean creation until it is needed.
• Eager Initialization creates the beans at the startup.

Diamond Problem

• The Diamond Problem occurs with multiple inheritance, where a class inherits from two classes with the same method.
• Java handles it by using interfaces with default methods and avoiding multiple class inheritance.

Microservices and Spring Boot

• Microservices architecture structures an application as a collection of loosely coupled services.
• Spring Boot supports microservices with features like embedded servers, simplified configuration, and Spring Cloud for distributed systems management.

Spring Security

• Spring Security provides comprehensive security services for Java applications, including authentication, authorization, and protection against common vulnerabilities.

Stream API

• The Stream API is used for processing sequences of elements, providing operations like map, filter, and reduce, supporting functional-style programming.

Aspect-Oriented Programming (AOP)

• AOP allows separation of cross-cutting concerns (like logging, security) from the main business logic using aspects, advice, and pointcuts.

Annotations

• Annotations provide metadata for classes, methods, and fields.
• They can influence program behavior at compile-time or runtime and are used extensively in frameworks like Spring and JPA.

Callable and Runnable Interfaces

• Callable returns a result and can throw a checked exception.
• Runnable does not return a result and cannot throw a checked exception.

JPA and Hibernate

• JPA (Java Persistence API) is a specification for ORM in Java.
• Hibernate is a JPA implementation that provides additional features.

Reactive Programming

• Reactive Programming is an asynchronous programming paradigm concerned with data streams and propagation of change.
• It is implemented in Java using frameworks like Reactor and RxJava, supporting non-blocking and event-driven applications.

Apache Kafka

• Apache Kafka is a distributed streaming platform used for building real-time data pipelines and streaming applications.
• It can be integrated with Java applications using Kafka clients for producing and consuming messages.