----------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------
Below are crisp, interview-ready answers for the 68 high-probability Collections questions.
They are written exactly at the depth expected for a 3+ years TCS Java Backend interview — not too shallow, not over-theoretical.
You can revise directly from this.
Max from numbers.
Optional<Integer> max = numbers.stream()
.max(Integer::compareTo);
Find Duplicates
List<Integer> duplicates = numbers.stream()
.filter(i -> Collections.frequency(numbers, i) > 1)
.distinct() // remove duplicate duplicates themselves
.collect(Collectors.toList());
remove duplicates
List<Integer> unique = numbers.stream()
.distinct()
.collect(Collectors.toList());
Frequenct of character
String str= "hello welcome to ravoi";
Map<Character, Long> frequency =
str.chars() // IntStream
.mapToObj(ch -> (char) ch) // Stream<Character>
.collect(Collectors.groupingBy(ch -> ch,Collectors.counting() ));
// Print result
frequency.forEach((ch, count) ->
System.out.println("'" + ch + "' → " + count)); }
max salary of employee
Optional<Employee> maxsal= employees.stream().sorted(Comparator.comparingInt(Employee::getSalary).reversed()).findFirst();
List to MAp
Map<Long, Person> map = people.stream()
.collect(Collectors.toMap(
Person::getId, // KeyMapper: how to get the key
Function.identity() // ValueMapper: the whole object becomes the value
));
Group employee by department
Map<String, List<Employee>> byDept = employees.stream()
.collect(Collectors.groupingBy(Employee::getDepartment));
JAVA COLLECTIONS – 90% ASKED QUESTIONS WITH ANSWERS
A. BASICS
1. What is Collection Framework?
A unified architecture of interfaces, implementations, and algorithms to store, manipulate, and retrieve groups of objects efficiently.
2. Difference between Collection and Collections?
Collection → Interface (List, Set, Queue)
Collections → Utility class with static methods like sort(), reverse(), synchronizedList()
3. Difference between List, Set, Map?
List → Allows duplicates, maintains order
Set → No duplicates
Map → Key–value pairs, keys are unique
4. Why Map is not part of Collection hierarchy?
Because Collection works on single elements, while Map works on key–value pairs. Their contracts are fundamentally different.
5. Core interfaces in Collection Framework?
Iterable
Collection
List
Set
Queue
(Map is separate)
6. Array vs ArrayList?
Array → Fixed size, supports primitives
ArrayList → Dynamic size, objects only
7. ArrayList vs LinkedList?
8. ArrayList vs Vector?
ArrayList → Not synchronized
Vector → Synchronized, slower, legacy
9. Why ArrayList is not synchronized?
To improve performance. Synchronization is optional and can be added externally.
10. How to make ArrayList thread-safe?
B. ARRAYLIST & LINKEDLIST
11. How does ArrayList work internally?
Uses a dynamic array. When capacity is exceeded, a new array is created and elements are copied.
12. Default capacity of ArrayList?
Initially 0
On first add → 10
13. How ArrayList grows?
New capacity = old capacity × 1.5
14. Time complexity in ArrayList?
get → O(1)
add → O(1) amortized
remove → O(n)
15. How LinkedList works internally?
Uses doubly linked list (previous + next references).
16. Why LinkedList insertion is faster?
No shifting of elements; only pointer updates.
17. When to use LinkedList?
When frequent insertions/deletions are required.
18. Difference between ArrayList and LinkedList?
ArrayList → index-based
LinkedList → node-based
C. SET
19. HashSet vs LinkedHashSet vs TreeSet?
20. How HashSet works internally?
Internally uses a HashMap, storing elements as keys.
21. How HashSet prevents duplicates?
Uses hashCode() + equals().
22. Can HashSet store null?
Yes, only one null.
23. Why TreeSet does not allow null?
Uses compareTo() / Comparator, which throws NullPointerException.
24. If compareTo() returns 0?
Elements are treated as duplicates.
D. HASHMAP (MOST IMPORTANT)
25. What is HashMap?
A Map implementation that stores data as key–value pairs using hashing.
26. How HashMap works internally?
hashCode of key
Calculate index
Store in bucket
equals() check for collision
Store or replace value
27. Default capacity & why 16?
28. Load factor?
Threshold to resize map. Default = 0.75
29. What is rehashing?
Increasing capacity and redistributing entries.
30. When rehashing happens?
When size > capacity × load factor.
31. Collision handling?
Uses Linked List (Java 7)
Uses Linked List → Red-Black Tree (Java 8)
32. Same hashCode, different equals?
Stored in same bucket as separate entries.
33. Why equals() after hashCode()?
To confirm exact key match inside same bucket.
34. Nulls in HashMap?
1 null key
Multiple null values
35. Why HashMap is not thread-safe?
No synchronization → race conditions possible.
36. Why immutable keys?
Hash code doesn’t change → avoids lookup failure.
37. HashMap issue in Java 7?
Worst case lookup = O(n) due to linked list.
38. Java 8 improvement?
Buckets converted to Red-Black Tree.
39. When list converts to tree?
When bucket size > 8 and capacity ≥ 64.
40. Why Red-Black Tree?
Guaranteed O(log n) lookup.
E. MAP VARIANTS
41. HashMap vs Hashtable?
Hashtable is synchronized, legacy, no nulls.
42. HashMap vs ConcurrentHashMap?
ConcurrentHashMap is thread-safe and high-performance.
43. HashMap vs LinkedHashMap?
LinkedHashMap maintains insertion/access order.
44. HashMap vs TreeMap?
TreeMap maintains sorted order.
45. Why ConcurrentHashMap does not allow null?
To avoid ambiguity during concurrent reads.
46. How ConcurrentHashMap is thread-safe (Java 8)?
Uses CAS + synchronized blocks, no full locking.
F. ITERATOR & CONCURRENCY
47. Fail-fast?
Throws ConcurrentModificationException.
48. Fail-safe?
Works on copy; no exception.
49. Why ConcurrentModificationException?
Structural modification during iteration.
50. Iterator vs ListIterator?
ListIterator supports bidirectional traversal.
51. Can you modify collection during iteration?
No, except using Iterator.remove().
52. How to modify safely?
Use Iterator remove or concurrent collections.
G. equals() & hashCode()
53. Contract?
Equal objects → same hashCode.
54. equals overridden but not hashCode?
HashMap lookup fails.
55. Unequal objects same hashCode?
Yes, allowed.
56. hashCode changes after insertion?
Object becomes unreachable in HashMap.
H. SORTING
57. Comparable vs Comparator?
Comparable → natural ordering
Comparator → custom ordering
58. How TreeSet sorts?
Uses compareTo() or Comparator.
59. compareTo inconsistent with equals?
Violates Set contract → duplicates allowed.
60. Sort List of objects?
Using Collections.sort() or Java 8 streams.
I. REAL-TIME SCENARIOS
61. Remove duplicates from List?
Convert to Set.
62. Frequency of elements?
Use HashMap.
63. Sort employees by salary?
Comparator / Stream sorted().
64. First non-repeated character?
LinkedHashMap.
65. Convert List to Map?
Use Stream collect().
66. Iterate Map?
entrySet, keySet, values.
67. Fast search collection?
HashMap / HashSet.
68. Thread-safe collection?
ConcurrentHashMap / CopyOnWriteArrayList.
FINAL TRUTH
If you revise only this, you cover ~90% of TCS Collections questions.
If you want next:
One-page last-minute revision
Mock interview (Q → expected answer)
Collections + Streams combined revision
Tell me how many hours left — I’ll optimize further.
Below is a focused and comprehensive list of Java 8 interview questions with clear, interview-ready answers, tailored for 2–5 years (especially 3+ years) Java backend developers. These are the most frequently asked questions in real interviews (TCS, Infosys, Wipro, Cognizant, Accenture, CGI, etc.).
1. What are the main features introduced in Java 8?
Answer:
Java 8 introduced functional programming concepts into Java.
Key features:
Lambda Expressions
Functional Interfaces
Stream API
Default and Static methods in interfaces
Optional class
Method References
New Date & Time API (java.time)
Nashorn JavaScript Engine (less common in interviews)
2. What is a Lambda Expression?
Answer:
A lambda expression is an anonymous function that provides a clear and concise way to implement a functional interface.
Syntax:
(parameters) -> expression
Example:
Runnable r = () -> System.out.println("Hello");
Benefits:
3. What is a Functional Interface?
Answer:
A functional interface contains exactly one abstract method.
Examples:
Annotation:
@FunctionalInterface
(Compile-time safety)
4. Difference between Lambda Expression and Anonymous Class
| Lambda | Anonymous Class |
|---|
| No class creation | Creates a class |
| Less code | More boilerplate |
No this ambiguity | this refers to inner class |
| Faster execution | Slower |
5. What is Stream API?
Answer:
Stream API is used to process collections of data in a functional and declarative manner.
Stream does NOT store data; it processes data from a source.
6. Explain Stream Pipeline
A stream works in three stages only:
Source
Intermediate Operations
Terminal Operation
Example:
list.stream()
.filter(n -> n > 10)
.map(n -> n * 2)
.forEach(System.out::println);
7. Difference between map() and flatMap()
| map() | flatMap() |
|---|
| One-to-one mapping | One-to-many mapping |
| Output is Stream of Streams | Output is single Stream |
Example:
list.stream().map(s -> s.split(""));
list.stream().flatMap(s -> Arrays.stream(s.split("")));
8. Difference between filter() and map()
9. What is Optional?
Answer:
Optional is a container object used to avoid NullPointerException.
Common methods:
isPresent()
orElse()
orElseGet()
orElseThrow()
ifPresent()
Example:
Optional<String> name = Optional.ofNullable(value);
System.out.println(name.orElse("Default"));
10. Difference between orElse() and orElseGet()
11. What are Method References?
Answer:
Method reference is a shorthand syntax of lambda expression.
Types:
Static method → ClassName::method
Instance method → object::method
Constructor → ClassName::new
Example:
list.forEach(System.out::println);
12. What is forEach()?
Answer:
A terminal operation used to iterate over elements.
Difference:
13. Difference between findFirst() and findAny()
14. What is reduce()?
Answer:
Used to reduce stream elements to a single value.
Example:
int sum = list.stream().reduce(0, Integer::sum);
15. Difference between collect() and reduce()
reduce() → immutable reduction
collect() → mutable reduction (List, Set, Map)
16. Difference between Stream and ParallelStream
| Stream | ParallelStream |
|---|
| Single thread | Multiple threads |
| Order preserved | Order not guaranteed |
| Less overhead | High overhead |
Use parallel streams only for large datasets.
17. Can we reuse a Stream?
Answer:
No. A stream can be consumed only once.
18. Difference between Predicate, Function, Consumer, Supplier
| Interface | Method | Purpose |
|---|
| Predicate | test() | Condition |
| Function | apply() | Transformation |
| Consumer | accept() | Consumes |
| Supplier | get() | Supplies |
19. Default methods in Interface – Why needed?
Answer:
To add new methods to interfaces without breaking existing implementations.
20. New Date and Time API advantages
Classes:
LocalDate
LocalTime
LocalDateTime
ZonedDateTime
21. Common Java 8 Coding Questions (Very Important)
Find highest/lowest number
Find duplicate elements
Count frequency of characters
Sort map by values
Find second highest number
Group employees by department
Find max salary employee
Convert List to Map
Remove duplicates
Find first non-repeated character
22. Real Interview Tip (Important)
Interviewers expect:
If you want, I can:
Give Java 8 coding questions with step-by-step explanation
Provide a Java 8 one-page interview cheat sheet
Create a Java 8 mock interview (Q&A format)
Tell me how you want to proceed.
Here are the **most frequently asked core Java interview questions** with **simple, easy-to-say answers** in plain English. These are the ones interviewers ask again and again in 2025–2026 (for freshers, 1–5 years experience, and even senior roles). I've kept explanations short, clear, and natural — the way you can speak confidently in an interview.
I've grouped them and numbered them like before.
### Core Java Fundamentals & OOP
1. **What are the main features of Java?**
Java is simple, object-oriented, platform-independent, secure, robust (strong error checking), supports multithreading, has automatic garbage collection, and is portable (write once, run anywhere).
2. **Why is Java platform-independent? Explain JDK, JRE, JVM.**
Java is platform-independent because source code (.java) compiles to bytecode (.class), and bytecode runs on any machine with a JVM.
- **JVM** (Java Virtual Machine): Runs the bytecode.
- **JRE** (Java Runtime Environment): JVM + libraries needed to run Java programs.
- **JDK** (Java Development Kit): JRE + tools like compiler (javac) to develop Java programs.
3. **Why is Java not 100% object-oriented?**
Because it has primitive types like int, float, boolean — these are not objects.
4. **What are the four pillars of OOP? Give simple examples.**
- **Encapsulation**: Hide data inside class (use private variables + public getters/setters).
- **Inheritance**: Child class gets features from parent (extends keyword).
- **Polymorphism**: Same method name does different things (method overriding or overloading).
- **Abstraction**: Show only what is needed, hide details (abstract class or interface).
5. **Difference between abstract class and interface?**
- Abstract class: Can have both abstract and normal methods, instance variables, constructors.
- Interface: Before Java 8 — only abstract methods. After Java 8 — can have default and static methods.
A class can extend only one abstract class but implement many interfaces.
6. **Can we override static, private, or final methods?**
No.
- Static: Belongs to class, not object → no overriding.
- Private: Not visible to child class.
- Final: Cannot be changed.
7. **Method overloading vs method overriding?**
- Overloading: Same method name, different parameters (in same class).
- Overriding: Same method name + same parameters (child class changes parent method).
8. **Difference between final, finally, finalize?**
- **final**: Keyword — variable (constant), method (cannot override), class (cannot extend).
- **finally**: Block after try-catch — always runs (cleanup like closing files).
- **finalize**: Method in Object class — called by garbage collector before destroying object (rarely used now).
9. **Why are Strings immutable in Java?**
For security (passwords), thread-safety, caching in String pool, and better performance.
10. **Difference between == and .equals()?**
- **==** : Checks if two references point to same memory (same object).
- **.equals()** : Checks content equality (you can override it, like in String).
### Memory, JVM & Garbage Collection
11. **Difference between Stack and Heap memory?**
- **Stack**: Fast, stores method calls, local variables (LIFO). Each thread has its own stack.
- **Heap**: Stores objects, shared by all threads. Garbage collected here.
12. **How does Garbage Collection work?**
JVM automatically frees memory from unused objects. It has young generation (Eden + Survivor) for short-lived objects and old generation for long-lived. Minor GC is fast, Major/Full GC is slower.
13. **What is String pool? How does intern() work?**
String pool is special part of heap for string literals (to save memory).
`intern()` brings string to pool if not already there and returns pooled reference.
### Multithreading & Concurrency
14. **What is multithreading? Difference between Thread and Runnable?**
Multithreading = multiple threads run at same time (better CPU use).
- Extend **Thread** class: Simple but limits inheritance.
- Implement **Runnable**: Better — allows extending another class.
15. **Difference between synchronized and ReentrantLock?**
- **synchronized**: Easy keyword, automatic lock release.
- **ReentrantLock**: More control (tryLock, timeout, fairness, interruptible).
16. **What is volatile keyword?**
Tells JVM not to cache variable — always read/write from main memory. Useful for visibility in multithreading (not atomicity).
17. **What is deadlock? How to prevent it?**
Deadlock = two threads wait forever for each other's lock.
Prevent: Lock in same order, use timeouts, avoid nested locks.
18. **Difference between wait(), notify(), notifyAll()?**
They work inside synchronized block.
- wait(): Thread releases lock and waits.
- notify(): Wakes one waiting thread.
- notifyAll(): Wakes all waiting threads.
### Collections Framework
19. **Difference between ArrayList and LinkedList?**
- **ArrayList**: Fast random access (get/set), slow insert/delete in middle.
- **LinkedList**: Fast insert/delete, slow random access.
20. **How does HashMap work internally?**
Uses array of buckets. Hash code → index → if collision, uses linked list (or tree if many). Load factor 0.75 → resize when full.
21. **Difference between HashMap, LinkedHashMap, TreeMap?**
- **HashMap**: No order.
- **LinkedHashMap**: Maintains insertion order.
- **TreeMap**: Sorted order (by key).
22. **What is fail-fast vs fail-safe iterator?**
- Fail-fast: Throws ConcurrentModificationException if collection changed during iteration (ArrayList, HashMap).
- Fail-safe: No exception, works on copy or allows changes (CopyOnWriteArrayList, ConcurrentHashMap).
### Exception Handling
23. **Difference between checked and unchecked exceptions?**
- Checked: Must handle or declare (throws) — e.g., IOException.
- Unchecked: Runtime, no need to handle — e.g., NullPointerException.
24. **Difference between throw and throws?**
- **throw**: Manually throw exception (throw new Exception()).
- **throws**: Declare method can throw exception.
25. **What is try-with-resources?**
Automatically closes resources (files, connections) after try block — no need for finally (Java 7+).
### Strings & Others
26. **Difference between String, StringBuilder, StringBuffer?**
- **String**: Immutable.
- **StringBuilder**: Mutable, not thread-safe, faster.
- **StringBuffer**: Mutable, thread-safe (synchronized), slower.
27. **What is autoboxing and unboxing?**
Automatic conversion: int → Integer (autoboxing), Integer → int (unboxing). Can cause performance issues in loops.
### Java 8+ Features
28. **What are lambda expressions?**
Short way to write anonymous methods (for functional interfaces). Example: `(a,b) -> a + b`
29. **What is Stream API?**
Processes collections in functional style (filter, map, reduce). Lazy — operations run only when terminal operation called.
30. **Difference between map() and flatMap()?**
- **map()**: One-to-one (transforms each element).
- **flatMap()**: One-to-many → flattens nested collections.
These cover 80–90% of core Java questions asked in interviews. Practice saying them out loud in simple words — interviewers like clear, confident answers more than bookish language.
If you want code examples for any (like producer-consumer, custom HashMap logic, or Stream code), or more advanced ones (for 5+ years), just tell me your experience level! All the best for your interview! 💪
