100% Free
🎯 3200+ Questions. One Goal: Your Success Sign In Sign Up

Top Java Interview Questions

Curated Java interview questions and answers across difficulty levels.

Last updated:

Java Interview Questions & Answers

Skip to Questions

Welcome to our comprehensive collection of Java interview questions and answers. This page contains expertly curated interview questions covering all aspects of Java, from fundamental concepts to advanced topics. Whether you're preparing for an entry-level position or a senior role, you'll find questions tailored to your experience level.

Our Java interview questions are designed to help you:

  • Understand core concepts and best practices in Java
  • Prepare for technical interviews at all experience levels
  • Master both theoretical knowledge and practical application
  • Build confidence for your next Java interview

Each question includes detailed answers and explanations to help you understand not just what the answer is, but why it's correct. We cover topics ranging from basic Java concepts to advanced scenarios that you might encounter in senior-level interviews.

Use the filters below to find questions by difficulty level (Entry, Junior, Mid, Senior, Expert) or focus specifically on code challenges. Each question is carefully crafted to reflect real-world interview scenarios you'll encounter at top tech companies, startups, and MNCs.

Questions

120 questions
Q1:

What are the main features of Java?

Entry

Answer

Key Features:
• Object-Oriented
• Platform-Independent via JVM
• Robust memory management
• Multithreaded
• Secure via JVM sandboxing
Permalink
Q2:

What is the difference between JDK, JRE, and JVM?

Entry

Answer

JVM: Executes Java bytecode.
JRE: JVM + libraries needed to run Java apps.
JDK: JRE + tools for developing Java applications.
Permalink
Q3:

What is the difference between Java and C++?

Entry

Answer

Java uses automatic garbage collection.
Java is platform-independent; C++ is platform-specific.
Java does not support direct pointers, improving security.
Permalink
Q4:

Explain object-oriented programming concepts in Java.

Entry

Answer

OOP principles:
• Encapsulation
• Inheritance
• Polymorphism
• Abstraction
Java applies these via classes, interfaces, and objects.
Permalink
Q5:

What is a class and an object in Java?

Entry

Answer

Class: Blueprint for creating objects.
Object: Instance of a class containing data and behavior.
Permalink
Q6:

What are primitive and reference data types?

Entry

Answer

Primitive: Stores actual value (int, boolean, etc.).
Reference: Stores memory address of objects (arrays, strings, objects).
Permalink
Q7:

What is the difference between method overloading and overriding?

Entry

Answer

Overloading: Same method name, different parameters.
Overriding: Subclass modifies inherited method.
Overloading = compile-time; overriding = runtime behavior.
Permalink
Q8:

What are constructors in Java?

Entry

Answer

Constructors initialize objects.
Can be default or parameterized.
Overloaded constructors offer multiple initialization ways.
Permalink
Q9:

What is the difference between this and super keywords?

Entry

Answer

this: Refers to current instance.
super: Refers to parent class.
Used to call parent constructors and resolved naming conflicts.
Permalink
Q10:

What are access modifiers in Java?

Entry

Answer

public: Accessible everywhere.
private: Inside class only.
protected: Same package + subclasses.
default: Same package.
Permalink
Q11:

What is the difference between static and instance members?

Entry

Answer

Static: Belongs to class, shared by all objects.
Instance: Unique per object.
Static members accessed without creating object.
Permalink
Q12:

What is the difference between final, finally, and finalize?

Entry

Answer

final: Constant or non-overridable.
finally: Executes after try/catch.
finalize: Called before garbage collection.
Permalink
Q13:

What is garbage collection in Java?

Entry

Answer

Automated memory cleanup removing unused objects.
Prevents memory leaks and improves performance.
Permalink
Q14:

What are Java packages and their benefits?

Entry

Answer

Packages group related classes.
Provide organization, modularity, and access control.
Prevents naming conflicts.
Permalink
Q15:

What is an interface and how is it different from an abstract class?

Entry

Answer

Interface: Only abstract methods (older Java).
Abstract class: Can have concrete methods and fields.
Interfaces support multiple inheritance.
Permalink
Q16:

What are Java exceptions?

Entry

Answer

Exceptions represent runtime errors.
Checked exceptions must be handled.
Unchecked exceptions don't require mandatory handling.
Permalink
Q17:

What is the difference between == and equals()?

Entry

Answer

== compares references.
equals() compares values.
equals() can be overridden for custom comparison.
Permalink
Q18:

What are wrapper classes and autoboxing/unboxing?

Entry

Answer

Wrapper classes represent primitive types as objects.
Autoboxing: primitive ? wrapper.
Unboxing: wrapper ? primitive.
Permalink
Q19:

What are Java generics and why are they used?

Entry

Answer

Generics provide type safety.
Prevent runtime casting errors.
Used in classes, methods, and collections.
Permalink
Q20:

What are Java collections?

Entry

Answer

Collections store groups of objects.
Common types: List, Set, Map, Queue.
Provide efficient searching, sorting, and manipulation.
Permalink
Q21:

What are Java 8 Lambda expressions?

Entry

Answer

Lambda expressions are anonymous functions used to implement functional interfaces.
They simplify collection processing, event handling, and reduce boilerplate.
Improve readability compared to anonymous inner classes.
Permalink
Q22:

Explain functional interfaces.

Entry

Answer

Functional interfaces have one abstract method (SAM).
Examples include Runnable, Callable, Comparator.
Marked with @FunctionalInterface and used with lambda expressions.
Permalink
Q23:

What is the Streams API in Java?

Entry

Answer

Streams provide functional-style operations for processing data sequences.
Support map, filter, reduce, collect operations.
Work in sequential or parallel mode.
Permalink
Q24:

Difference between intermediate and terminal operations in Streams.

Entry

Answer

Intermediate operations are lazy and return streams (map, filter, sorted).
Terminal operations produce results (collect, forEach, reduce).
Pipeline allows chaining multiple intermediate operations.
Permalink
Q25:

Explain Optional in Java.

Entry

Answer

Optional prevents null references by wrapping values.
Provides methods like isPresent(), orElse(), ifPresent().
Improves null-safety and reduces NullPointerExceptions.
Permalink
Q26:

What is method reference in Java 8?

Entry

Answer

Method references provide shorthand for calling methods directly.
Examples: Class::staticMethod, object::instanceMethod, Class::new.
Reduce lambda verbosity.
Permalink
Q27:

Difference between map and flatMap in Streams.

Entry

Answer

map transforms each element individually.
flatMap flattens nested structures like lists inside streams.
Useful for handling nested collections.
Permalink
Q28:

Explain Collectors in Streams API.

Entry

Answer

Collectors accumulate stream elements into collections or other results.
Examples: toList(), toSet(), groupingBy(), joining().
Useful for aggregation and transformation.
Permalink
Q29:

What are default and static methods in interfaces?

Entry

Answer

Default methods provide implementation inside interfaces.
Static methods belong to the interface and cannot be overridden.
Enhance flexibility and backward compatibility.
Permalink
Q30:

Explain the difference between sequential and parallel streams.

Entry

Answer

Sequential streams process elements one-by-one.
Parallel streams divide tasks into multiple threads.
Parallelism improves performance for large datasets when operations are thread-safe.
Permalink
Q31:

How do Java 8 enhancements improve collection processing?

Entry

Answer

Lambdas reduce boilerplate.
Streams enable functional, chainable operations.
Collectors simplify grouping and aggregation.
Permalink
Q32:

How do you handle exceptions in lambda expressions?

Entry

Answer

Checked exceptions must be handled inside lambda.
Custom functional interfaces can declare throws clauses.
Ensures clean functional-style error handling.
Permalink
Q33:

Difference between Predicate, Function, Consumer, and Supplier.

Entry

Answer

Predicate tests conditions and returns boolean.
Function transforms input to output.
Consumer performs action without returning.
Supplier provides a value without input.
Permalink
Q34:

How do streams differ from traditional iteration?

Entry

Answer

Streams provide declarative processing.
Support lazy evaluation and parallelism.
Improve readability and performance for large datasets.
Permalink
Q35:

How do you group elements using Collectors?

Entry

Answer

groupingBy groups data by a key.
Supports downstream collectors like counting, summing, mapping.
Useful for analytics and reports.
Permalink
Q36:

Explain the use of peek() in streams.

Entry

Answer

peek is an intermediate operation for debugging.
Lets you inspect elements without modifying them.
Not intended for business logic.
Permalink
Q37:

Difference between Optional.map() and Optional.flatMap().

Entry

Answer

map transforms the wrapped value and wraps it again.
flatMap avoids nested Optionals by flattening results.
Useful with functions returning Optional.
Permalink
Q38:

Difference between immutable and unmodifiable collections.

Entry

Answer

Immutable collections cannot change after creation.
Unmodifiable collections prevent modification through wrapper but underlying data may still change.
Both enhance safety.
Permalink
Q39:

How do you handle nulls in streams?

Entry

Answer

Use filter(Objects::nonNull) to remove nulls.
Wrap values with Optional to avoid null checks.
Prevents NullPointerExceptions.
Permalink
Q40:

What are the new Stream-related features in Java 9+?

Entry

Answer

Java 9+ adds ifPresentOrElse for Optional.
Collectors.teeing for combining results.
Factory methods like List.of(), Set.of(), Map.of().
Enhanced Stream.iterate() for bounded sequences.
Permalink
Q41:

Explain the four pillars of OOP in Java.

Junior

Answer

Encapsulation: Hides internal state and exposes only required methods.
Inheritance: Allows classes to reuse fields and methods.
Polymorphism: Treat objects as instances of parent type.
Abstraction: Hides implementation using abstract classes or interfaces.
Permalink
Q42:

Difference between abstract classes and interfaces.

Junior

Answer

Abstract classes can have fields, constructors, and concrete methods.
Interfaces declare abstract methods (plus default/static methods).
Java allows single inheritance for classes but multiple inheritance through interfaces.
Permalink
Q43:

What is method overriding vs method overloading?

Junior

Answer

Overloading: Same method name, different parameters; compile-time polymorphism.
Overriding: Subclass redefines parent method; runtime polymorphism.
Overriding requires inheritance.
Permalink
Q44:

How does the super keyword work?

Junior

Answer

super refers to parent class.
Used to call parent constructors or parent methods.
Helps resolve naming conflicts between superclass and subclass.
Permalink
Q45:

Explain constructor chaining in Java.

Junior

Answer

Constructor chaining calls one constructor from another using this().
super() calls parent constructor.
Ensures proper initialization and code reuse.
Permalink
Q46:

What are static blocks and static methods?

Junior

Answer

Static block executes once when class loads.
Static methods belong to class and can be accessed without object creation.
Permalink
Q47:

Difference between final, finally, and finalize.

Junior

Answer

final: Makes variables constant, classes non-inheritable, methods non-overridable.
finally: Executes after try/catch always.
finalize: Called before garbage collection (deprecated).
Permalink
Q48:

Explain Java exception hierarchy.

Junior

Answer

Throwable ? Error and Exception.
Error: Serious issues (not handled usually).
Exception: Can be handled.
Checked exceptions must be declared; unchecked are runtime exceptions.
Permalink
Q49:

How is multiple inheritance handled in Java?

Junior

Answer

Java does not support multiple inheritance of classes.
Achieved using interfaces.
Prevents diamond problem.
Permalink
Q50:

Explain object cloning in Java.

Junior

Answer

Cloning creates object copies.
Uses Cloneable interface.
Shallow copy copies references; deep copy duplicates full object graph.
Permalink
Q51:

What is the difference between == and equals()?

Junior

Answer

== compares references.
equals() compares content.
equals() should be overridden for custom comparison.
Permalink
Q52:

Explain hashCode() and equals() contract.

Junior

Answer

If two objects are equal via equals(), their hashCode() must match.
Required for HashMap, HashSet, and other collections.
Permalink
Q53:

How does the instanceof keyword work?

Junior

Answer

Checks whether an object belongs to a specific class or subclass.
Useful for safe type casting.
Permalink
Q54:

Explain Java packages and access control.

Junior

Answer

Packages group related classes.
Access modifiers: public, private, protected, default.
Improves modularity and avoids naming conflicts.
Permalink
Q55:

Difference between deep copy and shallow copy.

Junior

Answer

Shallow copy copies references; objects shared.
Deep copy duplicates all objects; independent copies.
Permalink
Q56:

Explain Java memory model.

Junior

Answer

Memory divided into Heap (objects) and Stack (references & primitives).
Method area holds class data.
GC manages heap memory.
Permalink
Q57:

How does garbage collection work in Java?

Junior

Answer

GC removes unreachable objects.
Algorithms include Mark-and-Sweep and Generational GC.
Prevents memory leaks automatically.
Permalink
Q58:

How do Java Strings differ from StringBuilder and StringBuffer?

Junior

Answer

String is immutable.
StringBuilder is mutable and faster but not thread-safe.
StringBuffer is thread-safe (synchronized).
Permalink
Q59:

Explain Java enums.

Junior

Answer

Enums represent fixed constants.
Can have fields, constructors, and methods.
Improve type safety and readability.
Permalink
Q60:

What are Java annotations?

Junior

Answer

Annotations provide metadata for code.
Affect compilation or runtime behavior.
Examples: @Override, @Deprecated, @SuppressWarnings.
Permalink
Q61:

What are the main interfaces of the Java Collections Framework?

Junior

Answer

List: Ordered collection allowing duplicates.
Set: No duplicates, unordered or sorted.
Map: Key-value pairs with unique keys.
Queue/Deque: FIFO or double-ended structures.
Iterable: Base interface enabling iteration.
Permalink
Q62:

What is the difference between ArrayList and LinkedList?

Junior

Answer

ArrayList: Backed by array; fast random access; slower insert/delete in middle.
LinkedList: Doubly linked nodes; fast insert/delete; slow random access.
Permalink
Q63:

What is the difference between HashMap, TreeMap, and LinkedHashMap?

Junior

Answer

HashMap: Unordered, fast via hashing.
TreeMap: Sorted keys, uses Red-Black tree.
LinkedHashMap: Maintains insertion order.
Permalink
Q64:

Explain the difference between List, Set, and Map.

Junior

Answer

List: Ordered, allows duplicates.
Set: No duplicates.
Map: Key-value pairs with unique keys.
Permalink
Q65:

What are Java generics and why use them?

Junior

Answer

Generics provide compile-time type safety.
Enable reusable classes and methods.
Reduce casting and runtime errors.
Permalink
Q66:

How do wildcards in generics work?

Junior

Answer

? extends T: Accepts T or subclasses.
? super T: Accepts T or superclasses.
Used for flexible yet safe type handling.
Permalink
Q67:

What is the difference between Comparable and Comparator?

Junior

Answer

Comparable: Natural ordering defined in class.
Comparator: External custom sorting logic.
Both used during sorting.
Permalink
Q68:

What is the difference between fail-fast and fail-safe iterators?

Junior

Answer

Fail-fast: Throws ConcurrentModificationException.
Fail-safe: Works on copy; allows modification.
Permalink
Q69:

Explain Java multithreading.

Junior

Answer

Thread is independent execution path.
Runnable defines thread task.
Lifecycle: New ? Runnable ? Running ? Waiting/Blocked ? Terminated.
Permalink
Q70:

How do you create and start a thread?

Junior

Answer

Extend Thread or implement Runnable.
Call start() to run thread asynchronously.
Thread pools manage multiple threads efficiently.
Permalink
Q71:

What are synchronized methods and blocks?

Junior

Answer

Ensure exclusive access to shared resources.
Prevent race conditions.
Synchronized block gives finer locking control.
Permalink
Q72:

Explain inter-thread communication.

Junior

Answer

Uses wait(), notify(), notifyAll().
Helps coordinate producer-consumer tasks.
Must be inside synchronized blocks.
Permalink
Q73:

What are deadlocks and how do you prevent them?

Junior

Answer

Deadlock: Threads wait forever for each other's locks.
Prevent by avoiding nested locks, ordering locks consistently, or using timeouts.
Permalink
Q74:

What is the difference between volatile, synchronized, and atomic variables?

Junior

Answer

volatile: Ensures visibility of changes.
synchronized: Ensures mutual exclusion.
Atomic variables: Lock-free thread-safe operations.
Permalink
Q75:

Explain thread priorities and scheduling.

Junior

Answer

Threads have priorities (1–10).
Higher priority gets more CPU time but no guaranteed order.
Actual scheduling depends on OS and JVM.
Permalink
Q76:

Explain thread pools in Java.

Junior

Answer

Thread pools reuse worker threads.
Reduce overhead of thread creation.
Executors provide fixed, cached, and scheduled pools.
Permalink
Q77:

What is the difference between Callable and Runnable?

Junior

Answer

Runnable: No return value; no checked exceptions.
Callable: Returns value and may throw exceptions.
Used with ExecutorService to get Future results.
Permalink
Q78:

Explain Java concurrent collections.

Junior

Answer

Thread-safe optimized collections.
Examples: ConcurrentHashMap, CopyOnWriteArrayList.
Avoids manual synchronization.
Permalink
Q79:

Explain producer-consumer problem in Java.

Junior

Answer

Producer adds data; consumer removes it.
Requires thread coordination and shared buffers.
Uses wait(), notify(), or BlockingQueue.
Permalink
Q80:

How do you handle thread safety in Java?

Junior

Answer

Use synchronization, locks, atomic variables, and concurrent collections.
Avoid shared mutable state.
Design carefully for safe concurrent execution.
Permalink
Q81:

Explain the Java Memory Model (JMM).

Mid

Answer

Java Memory Model defines visibility, ordering, and atomicity rules.
Heap stores objects; Stack stores references and local variables.
Method area stores class metadata.
PC register tracks execution.
Garbage collector manages heap memory automatically.
Permalink
Q82:

What is the role of JVM, JIT, and bytecode?

Mid

Answer

JVM executes Java bytecode across platforms.
Bytecode is the intermediate compiled code.
JIT compiler converts bytecode to native machine code at runtime for faster execution.
Permalink
Q83:

Explain garbage collection algorithms in Java.

Mid

Answer

Mark-and-Sweep marks live objects and removes unused ones.
Generational GC optimizes by separating objects into young and old generations.
Stop-the-world pauses occur during GC phases.
Modern collectors like G1 and ZGC reduce latency.
Permalink
Q84:

What are soft, weak, and phantom references?

Mid

Answer

SoftReference cleared when memory is low; used for caching.
WeakReference cleared during GC if no strong references exist.
PhantomReference used for cleanup before object collection.
Permalink
Q85:

Explain Java ClassLoaders.

Mid

Answer

ClassLoaders load classes dynamically at runtime.
Types: Bootstrap, Extension, System, and Custom loaders.
Enable modularity, dynamic behavior, and class reloading.
Permalink
Q86:

How do you implement multithreading optimizations?

Mid

Answer

Use immutable objects for thread safety.
Prefer concurrent collections and atomic variables.
Minimize synchronized blocks.
Use thread pools for efficient thread reuse.
Permalink
Q87:

Explain the difference between process and thread in Java.

Mid

Answer

Process: Independent execution with separate memory.
Thread: Lightweight execution sharing memory within a process.
Threads improve concurrency; processes ensure isolation.
Permalink
Q88:

What is the difference between checked and unchecked exceptions in multithreaded contexts?

Mid

Answer

Checked exceptions must be declared or handled.
Unchecked exceptions do not require declaration.
Threads must handle exceptions internally; unhandled runtime exceptions terminate threads.
Permalink
Q89:

Explain the Singleton design pattern in Java.

Mid

Answer

Ensures one instance of a class exists.
Implement using eager loading, lazy loading, double-checked locking, or enum.
Provides global access to the instance.
Permalink
Q90:

Explain the Factory design pattern.

Mid

Answer

Factory pattern creates objects without exposing creation logic.
Promotes loose coupling and extensibility.
Used in dependency injection and plugin architectures.
Permalink
Q91:

Explain the Observer design pattern.

Mid

Answer

Defines one-to-many relationship between objects.
Observers are notified automatically on state changes.
Useful for event-driven systems and GUIs.
Permalink
Q92:

Explain the Strategy design pattern.

Mid

Answer

Encapsulates algorithms into separate classes.
Allows changing behavior at runtime.
Improves flexibility and maintainability.
Permalink
Q93:

Explain the Decorator design pattern.

Mid

Answer

Adds behavior to objects dynamically without modifying class.
Promotes composition over inheritance.
Used in I/O streams and UI components.
Permalink
Q94:

Explain the Adapter design pattern.

Mid

Answer

Converts interface of one class into another expected by client.
Enables integration of incompatible systems.
Useful for legacy code and third-party APIs.
Permalink
Q95:

Explain the Proxy design pattern.

Mid

Answer

Provides a surrogate object to control access to another object.
Used for lazy loading, security, caching, and remote proxies.
Permalink
Q96:

Explain Java volatile and its role in concurrency.

Mid

Answer

volatile ensures visibility of variable changes.
Prevents instruction reordering for that variable.
Does not guarantee atomicity for compound operations.
Permalink
Q97:

Explain Java Atomic classes.

Mid

Answer

Provide lock-free thread-safe operations.
Examples: AtomicInteger, AtomicBoolean, AtomicReference.
Faster than synchronized blocks for single-variable operations.
Permalink
Q98:

What are Java locks and ReentrantLocks?

Mid

Answer

Locks provide advanced synchronization features.
ReentrantLock allows same thread to re-acquire lock.
Supports fairness, tryLock, timed locking, and conditions.
Permalink
Q99:

How does Java handle thread pools?

Mid

Answer

ExecutorService manages thread pools.
Reduces overhead of thread creation.
Supports scheduled and concurrent task execution.
Permalink
Q100:

Explain Java memory optimization strategies.

Mid

Answer

Use primitive types when possible.
Avoid unnecessary object creation.
Apply lazy initialization and caching.
Choose efficient collections.
Minimize object retention to help GC.
Permalink
Q101:

Explain Java concurrency utilities.

Senior

Answer

The java.util.concurrent package provides high-level concurrency support.
Includes ExecutorService, ThreadPoolExecutor, ScheduledExecutorService, BlockingQueue, Semaphore, CountDownLatch.
Reduces boilerplate synchronization and improves performance in multithreaded applications.
Permalink
Q102:

What is ExecutorService and why is it used?

Senior

Answer

ExecutorService manages threads and executes tasks asynchronously.
Supports thread pools, scheduling, submit(), invokeAll(), shutdown().
Improves resource management and avoids manual thread creation.
Permalink
Q103:

Difference between Callable and Runnable.

Senior

Answer

Runnable has no return value and cannot throw checked exceptions.
Callable returns values and can throw exceptions.
Callable works with Future for asynchronous results.
Permalink
Q104:

Explain Future and CompletableFuture.

Senior

Answer

Future represents the result of an asynchronous computation.
CompletableFuture extends Future with non-blocking, chainable, and combinational operations.
Useful for reactive, asynchronous workflows.
Permalink
Q105:

Difference between synchronized and ReentrantLock.

Senior

Answer

synchronized is simple and blocks until a lock is released.
ReentrantLock provides tryLock(), timeouts, fairness, and multiple conditions.
ReentrantLock offers more control and flexibility.
Permalink
Q106:

Explain CountDownLatch, CyclicBarrier, and Semaphore.

Senior

Answer

CountDownLatch waits for a set of threads to finish.
CyclicBarrier allows threads to wait for each other repeatedly.
Semaphore controls access to limited resources using permits.
Permalink
Q107:

How does Java ensure thread safety?

Senior

Answer

Thread safety is achieved using synchronized blocks, locks, atomic variables, and concurrent collections.
Prefer immutability and minimize shared mutable state.
Use functional programming constructs where possible.
Permalink
Q108:

Explain volatile keyword and atomicity.

Senior

Answer

volatile guarantees visibility of updates across threads.
Does not ensure atomic operations for increments or composite actions.
Use atomic classes or synchronization for atomicity.
Permalink
Q109:

Explain parallel streams.

Senior

Answer

Parallel streams process data using multiple threads.
Increase performance for CPU-intensive tasks.
Operations must be thread-safe to avoid race conditions.
Permalink
Q110:

Explain Fork/Join framework.

Senior

Answer

Fork/Join supports parallel processing using divide-and-conquer approach.
Uses ForkJoinPool and RecursiveTask or RecursiveAction.
Ideal for large recursive computations.
Permalink
Q111:

How do you avoid deadlocks?

Senior

Answer

Acquire locks in a consistent order.
Avoid nested locks where possible.
Use tryLock() or timed locks.
Prefer higher-level concurrency utilities.
Permalink
Q112:

Explain ThreadLocal.

Senior

Answer

ThreadLocal stores per-thread variables.
Each thread gets its own isolated copy.
Useful for caching, user sessions, or context propagation.
Permalink
Q113:

Explain CompletableFuture chaining.

Senior

Answer

CompletableFuture allows async task chaining with thenApply, thenAccept, thenCombine, exceptionally.
Enables building non-blocking, reactive pipelines.
Permalink
Q114:

Difference between parallel streams and CompletableFuture.

Senior

Answer

Parallel streams provide easy parallelism for collection processing.
CompletableFuture gives fine-grained control over async tasks.
Use based on concurrency requirements and task complexity.
Permalink
Q115:

How does Java handle thread priorities?

Senior

Answer

Threads have priorities from 1 to 10.
Higher-priority threads are scheduled preferentially but order is not guaranteed.
Actual scheduling depends on JVM and OS.
Permalink
Q116:

Explain reactive programming in Java.

Senior

Answer

Reactive programming uses asynchronous, non-blocking data streams.
Implemented via libraries like RxJava and Reactor.
Useful for microservices, streaming, and event-driven systems.
Permalink
Q117:

Explain CompletableFuture vs Future.

Senior

Answer

Future is limited; get() is blocking and lacks chaining.
CompletableFuture supports non-blocking operations, chaining, combination, and exception handling.
More powerful for async workflows.
Permalink
Q118:

How do you handle exceptions in parallel processing?

Senior

Answer

Handle exceptions inside threads individually.
Use CompletableFuture.exceptionally() or handle().
Avoid uncaught exceptions that silently terminate threads.
Permalink
Q119:

Best practices for thread safety and performance.

Senior

Answer

Prefer immutability and stateless logic.
Minimize synchronized sections.
Use atomic types and concurrent collections.
Load-test multithreaded code thoroughly.
Permalink
Q120:

Modern Java features for performance optimization.

Senior

Answer

Use streams and parallel streams carefully.
Use Fork/Join for divide-and-conquer workloads.
Leverage CompletableFuture for async tasks.
Prefer immutable objects to reduce synchronization overhead.
Permalink

Curated Sets for Java

No curated sets yet. Group questions into collections from the admin panel to feature them here.

People Also Ask - Related Java Questions

What are the main features of Java?
What is the difference between JDK, JRE, and JVM?
What is the difference between Java and C++?
Explain object-oriented programming concepts in Java.
What is a class and an object in Java?
What are primitive and reference data types?
Ready to level up? Start Practice