[go: up one dir, main page]
Scribd
Upload
6 views6 pages

Interview Java Questions and Answers for Java Developer

The document lists the top 50 'Difference Between' interview questions for Java developers, covering key concepts such as JDK vs JRE vs JVM, Abstract Class vs Interface, and ArrayList vs LinkedList. Each entry provides a concise definition and comparison of the terms. This resource serves as a quick reference for Java developers preparing for interviews.

Uploaded by

salvepradip18
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
6 views6 pages

Interview Java Questions and Answers for Java Developer

The document lists the top 50 'Difference Between' interview questions for Java developers, covering key concepts such as JDK vs JRE vs JVM, Abstract Class vs Interface, and ArrayList vs LinkedList. Each entry provides a concise definition and comparison of the terms. This resource serves as a quick reference for Java developers preparing for interviews.

Uploaded by

salvepradip18
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Page 1

Top 50 'Difference Between' Interview Questions for Java Developers

1. JDK vs JRE vs JVM


JDK: Development kit including compiler.
JRE: Runtime environment to execute Java programs.
JVM: Machine that runs Java bytecode.

2. Abstract Class vs Interface


Abstract Class: Can have both abstract and concrete methods.
Interface: Only abstract methods (before Java 8).

3. ArrayList vs LinkedList
ArrayList: Fast random access, slow insert/delete.
LinkedList: Slow random access, fast insert/delete.

4. HashMap vs Hashtable
HashMap: Not synchronized, allows one null key.
Hashtable: Synchronized, does not allow null keys.

5. == vs .equals()
==: Compares references (memory location).
.equals(): Compares values (can be overridden).

6. String vs StringBuilder vs StringBuffer


String: Immutable.
StringBuffer: Mutable, synchronized.
StringBuilder: Mutable, not synchronized.

7. Overloading vs Overriding
Overloading: Same method, different parameters.
Overriding: Same method, same parameters, different class.

8. Static vs Final
Static: Belongs to class, shared among objects.
Final: Prevents modification of class, method, or variable.

Created by @arjunummavagol
Page 2

9. Checked vs Unchecked Exceptions


Checked: Must be handled (IOException, SQLException).
Unchecked: Runtime errors (NullPointerException).

10. Process vs Thread


Process: Independent execution, separate memory.
Thread: Lightweight, shared memory within a process.

11. Deep Copy vs Shallow Copy


Shallow Copy: Copies references, changes reflect in both objects.
Deep Copy: Creates independent copies of objects.

12. Heap Memory vs Stack Memory


Heap: Stores objects, shared among threads.
Stack: Stores method calls, local variables.

13. Synchronized vs Concurrent Collections


Synchronized: Locks whole collection.
Concurrent: Uses java.util.concurrent for better performance.

14. Volatile vs Synchronized


Volatile: Ensures visibility across threads.
Synchronized: Provides atomicity by locking sections.

15. Callable vs Runnable


Runnable: No return value.
Callable: Returns a result (Future<T>), supports exceptions.

16. HashSet vs TreeSet


HashSet: Unordered, uses hashing (O(1) operations).
TreeSet: Ordered, uses Red-Black Tree (O(log n) operations).

17. Comparable vs Comparator


Comparable: Defines natural ordering inside class.
Comparator: Custom ordering outside class.

18. Serialization vs Deserialization

Created by @arjunummavagol
Page 3

Serialization: Converts object to byte stream.


Deserialization: Converts byte stream back to object.

19. ForkJoinPool vs ThreadPoolExecutor


ForkJoinPool: Uses work-stealing for parallelism.
ThreadPoolExecutor: Fixed number of worker threads.

20. Mutable vs Immutable Objects


Immutable: Cannot be modified after creation.
Mutable: Can be changed after creation.

21. Spring Boot vs Spring MVC


Spring Boot: Standalone, microservices-friendly.
Spring MVC: Web framework for Java apps.

22. REST API vs SOAP


REST: Lightweight, JSON/XML, stateless.
SOAP: XML-based, more secure, used in enterprise apps.

23. SQL vs NoSQL


SQL: Structured, relational database.
NoSQL: Unstructured, schema-less, scalable.

24. Microservices vs Monolithic Architecture


Microservices: Independent services, scalable.
Monolithic: Single large application, harder to scale.

25. Lambda Expressions vs Anonymous Classes


Lambda: Shorter syntax, introduced in Java 8.
Anonymous Class: More verbose, used before Java 8.

26. RESTful Web Services vs GraphQL


REST: Predefined endpoints, fixed structure.
GraphQL: Flexible queries, client-driven API.

27. GET vs POST in HTTP


GET: Retrieves data, can be cached.

Created by @arjunummavagol
Page 4

POST: Sends data, not cached, used for sensitive data.

28. String Pool vs Heap Memory


String Pool: Stores unique string literals.
Heap Memory: Stores all objects including strings.

29. Checked Exception vs Runtime Exception


Checked: Requires handling.
Runtime: Unchecked, occurs at runtime.

30. Primitive vs Wrapper Classes


Primitive: int, double, etc. No object features.
Wrapper: Integer, Double, etc. Provides additional methods.

31. Soft Reference vs Weak Reference


Soft: Garbage collected when memory is low.
Weak: Collected more aggressively by GC.

32. Iterator vs ListIterator


Iterator: Can only traverse forward.
ListIterator: Can traverse both directions.

33. BlockingQueue vs ConcurrentLinkedQueue


BlockingQueue: Thread-safe with waiting mechanisms.
ConcurrentLinkedQueue: Non-blocking queue with better performance.

34. HashMap vs ConcurrentHashMap


HashMap: Not thread-safe.
ConcurrentHashMap: Thread-safe, better concurrency.

35. Stream API vs Collections API


Stream API: Functional operations on data.
Collections API: Traditional data structure manipulations.

36. Garbage Collection vs Manual Memory Management


GC: Automated memory cleanup.
Manual: Programmer manages memory (C, C++).

Created by @arjunummavagol
Page 5

37. WeakHashMap vs HashMap


WeakHashMap: Uses weak references, entries removed when no strong reference.
HashMap: Uses strong references, entries persist.

38. Static Binding vs Dynamic Binding


Static: Resolved at compile-time.
Dynamic: Resolved at runtime (method overriding).

39. ClassLoader vs Class.forName()


ClassLoader: Loads classes at runtime.
Class.forName(): Loads class dynamically by name.

40. Bitwise Operators vs Logical Operators


Bitwise: Operates at bit level.
Logical: Operates on boolean values.

41. Predicate vs Function in Java Streams


Predicate: Returns boolean.
Function: Returns transformed value.

42. TreeMap vs HashMap


TreeMap: Ordered (Red-Black Tree).
HashMap: Unordered (Hashing).

43. Deadlock vs Starvation in Threading


Deadlock: Two threads waiting on each other.
Starvation: A thread never gets CPU time.

44. IdentityHashMap vs HashMap


IdentityHashMap: Uses reference equality.
HashMap: Uses equals() for key comparison.

45. Singleton vs Prototype in Spring


Singleton: One instance per Spring container.
Prototype: New instance every time requested.

Created by @arjunummavagol
Page 6

46. Fail-fast vs Fail-safe Iterators


Fail-fast: Throws ConcurrentModificationException.
Fail-safe: Works on a copy, avoids exceptions.

47. Public vs Private Access Modifier


Public: Accessible from anywhere.
Private: Accessible only within the same class.

48. Synchronous vs Asynchronous Processing


Synchronous: Tasks execute sequentially.
Asynchronous: Tasks run concurrently, improving performance.

49. Path vs Classpath in Java


Path: Defines where system binaries are located.
Classpath: Defines where Java classes and libraries are located.

50. Iterator vs Spliterator


Iterator: Used for sequential traversal.
Spliterator: Supports parallel processing with better performance.

Created by @arjunummavagol

You might also like