# 📚 Java Programming Language – Part 9/10: Collections Framework
#Java #Collections #DataStructures #Programming

Welcome to Part 9 of our Java series! Today we'll explore the powerful Collections Framework - essential for handling groups of objects efficiently.

---

## 🔹 Collections Framework Overview
The Java Collections Framework provides:
- Interfaces (List, Set, Map, etc.)
- Implementations (ArrayList, HashSet, HashMap, etc.)
- Algorithms (Searching, Sorting, Shuffling)


---

## 🔹 Core Interfaces
| Interface | Description | Key Implementations |
|-----------|-------------|---------------------|
| List | Ordered collection (allows duplicates) | ArrayList, LinkedList |
| Set | Unique elements (no duplicates) | HashSet, TreeSet |
| Queue | FIFO ordering | LinkedList, PriorityQueue |
| Map | Key-value pairs | HashMap, TreeMap |

---

## 🔹 List Implementations
### 1. ArrayList

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add(1, "Charlie"); // Insert at index 1

System.out.println(names); // [Alice, Charlie, Bob]
System.out.println(names.get(0)); // Alice

### 2. LinkedList

List<Integer> numbers = new LinkedList<>();
numbers.add(10);
numbers.addFirst(5); // Add to beginning
numbers.addLast(20); // Add to end

System.out.println(numbers); // [5, 10, 20]

---

## 🔹 Set Implementations
### 1. HashSet (Unordered)

Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice"); // Duplicate ignored

System.out.println(uniqueNames); // [Alice, Bob] (order may vary)

### 2. TreeSet (Sorted)

Set<Integer> sortedNumbers = new TreeSet<>();
sortedNumbers.add(5);
sortedNumbers.add(2);
sortedNumbers.add(8);

System.out.println(sortedNumbers); // [2, 5, 8]

---

## 🔹 Map Implementations
### 1. HashMap

Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
ageMap.put("Alice", 26); // Overwrites previous value

System.out.println(ageMap.get("Alice")); // 26
System.out.println(ageMap.containsKey("Bob")); // true

### 2. TreeMap (Sorted by keys)

Map<String, String> sortedMap = new TreeMap<>();
sortedMap.put("Orange", "Fruit");
sortedMap.put("Carrot", "Vegetable");
sortedMap.put("Apple", "Fruit");

System.out.println(sortedMap); 
// {Apple=Fruit, Carrot=Vegetable, Orange=Fruit}

---

## 🔹 Iterating Collections
### 1. For-Each Loop

List<String> colors = List.of("Red", "Green", "Blue");
for (String color : colors) {
    System.out.println(color);
}

### 2. Iterator

Set<Integer> numbers = new HashSet<>(Set.of(1, 2, 3));
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

### 3. forEach() Method (Java 8+)

Map<String, Integer> map = Map.of("A", 1, "B", 2);
map.forEach((key, value) -> 
    System.out.println(key + ": " + value));

---

## 🔹 Collections Utility Class
Powerful static methods for collections:

List<Integer> numbers = new ArrayList<>(List.of(3, 1, 4, 1, 5));

Collections.sort(numbers); // [1, 1, 3, 4, 5]
Collections.reverse(numbers); // [5, 4, 3, 1, 1]
Collections.shuffle(numbers); // Random order
Collections.frequency(numbers, 1); // 2

---

# 📚 Java Programming Language – Part 10/10: Streams & Modern Java Features
#Java #Streams #Lambda #ModernJava #Programming

Welcome to the final part of our Java series! Today we'll explore powerful modern Java features including Streams API and Lambda expressions.

---

## 🔹 Lambda Expressions
Concise way to implement functional interfaces.

### 1. Basic Syntax

// Traditional way
Runnable r1 = new Runnable() {
    public void run() {
        System.out.println("Running!");
    }
};

// Lambda equivalent
Runnable r2 = () -> System.out.println("Running!");

### 2. Lambda Variations

// No parameters
() -> System.out.println("Hello")

// Single parameter
name -> System.out.println("Hello " + name)

// Multiple parameters
(a, b) -> a + b

// With return and body
(x, y) -> {
    int sum = x + y;
    return sum * 2;
}

---

## 🔹 Functional Interfaces
Single abstract method interfaces work with lambdas.

### 1. Common Functional Interfaces
| Interface | Method | Example Use |
|----------------|----------------|---------------------------|
| Predicate<T> | test(T t) | Filter elements |
| Function<T,R>| apply(T t) | Transform elements |
| Consumer<T> | accept(T t) | Perform actions |
| Supplier<T> | get() | Generate values |

### 2. Practical Example

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Using Predicate
Predicate<String> startsWithA = name -> name.startsWith("A");
names.stream().filter(startsWithA).forEach(System.out::println);

// Using Function
Function<String, Integer> nameLength = String::length;
names.stream().map(nameLength).forEach(System.out::println);

---

## 🔹 Streams API
Powerful way to process collections functionally.

### 1. Stream Pipeline

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()          // Source
    .filter(n -> n % 2 == 0)       // Intermediate operation
    .map(n -> n * 2)               // Intermediate operation
    .reduce(0, Integer::sum);      // Terminal operation

System.out.println(sum);  // 12 (2*2 + 4*2)

### 2. Common Stream Operations
| Operation | Type | Example |
|-----------|------|---------|
| filter | Intermediate | .filter(n -> n > 5) |
| map | Intermediate | .map(String::toUpperCase) |
| sorted | Intermediate | .sorted(Comparator.reverseOrder()) |
| forEach | Terminal | .forEach(System.out::println) |
| collect | Terminal | .collect(Collectors.toList()) |
| reduce | Terminal | .reduce(0, Integer::sum) |

---

## 🔹 Method References
Shortcut for lambda expressions.

### 1. Types of Method References

// Static method
Function<String, Integer> parser = Integer::parseInt;

// Instance method of object
Consumer<String> printer = System.out::println;

// Instance method of class
Function<String, String> upper = String::toUpperCase;

// Constructor
Supplier<List<String>> listSupplier = ArrayList::new;

---

## 🔹 Optional Class
Handle null values safely.

### 1. Basic Usage

Optional<String> name = Optional.ofNullable(getName());

String result = name
    .map(String::toUpperCase)
    .orElse("DEFAULT");

System.out.println(result);

### 2. Practical Example

public class UserService {
    public Optional<User> findUser(String id) {
        // May return null
        return Optional.ofNullable(database.findUser(id));
    }
}

// Usage:
userService.findUser("123")
    .ifPresentOrElse(
        user -> System.out.println("Found: " + user),
        () -> System.out.println("User not found")
    );

---

## 🔹 Modern Java Features (Java 8-17)
### 1. Records (Java 16)

public record Person(String name, int age) {}

// Automatically generates:
// - Constructor
// - Getters
// - equals(), hashCode(), toString()

### 2. Pattern Matching (Java 16)

if (obj instanceof String s) {
    System.out.println(s.length());
}

### 3. Text Blocks (Java 15)

String json = """
    {
        "name": "Alice",
        "age": 25
    }
    """;

# 📚 100 Essential Java Interview Questions
#Java #Interview #Programming #OOP #Collections #Multithreading

---

## 🔹 Core Java (20 Questions)
1. What is JVM, JRE, and JDK?
2. Explain public static void main(String[] args)
3. Difference between == and .equals()?
4. What are Java primitives? List all 8.
5. Explain autoboxing/unboxing
6. What are varargs?
7. Difference between String, StringBuilder, and StringBuffer
8. What are immutable objects? How to create them?
9. Explain final, finally, and finalize
10. What are annotations? Common built-in annotations?
11. Difference between throw and throws
12. What is static keyword?
13. Can we override static methods?
14. What is method overloading vs overriding?
15. What is this and super keywords?
16. Explain pass-by-value in Java
17. What are wrapper classes? Why needed?
18. What is enum? When to use?
19. Difference between instanceof and getClass()
20. What is type casting? Implicit vs explicit

---

## 🔹 OOP Concepts (15 Questions)
21. 4 Pillars of OOP with examples
22. What is abstraction vs encapsulation?
23. Difference between abstract class and interface (Java 8+)
24. Can an interface have constructors?
25. What is polymorphism? Runtime vs compile-time
26. What is method hiding?
27. What is composition vs inheritance?
28. What is the Liskov Substitution Principle?
29. How to achieve multiple inheritance in Java?
30. What is a singleton? Thread-safe implementation
31. What is a factory pattern?
32. What is a marker interface?
33. What is a POJO?
34. What is the instanceof operator used for?
35. What is object cloning? Shallow vs deep copy

---

## 🔹 Collections Framework (15 Questions)
36. Collections hierarchy diagram explanation
37. Difference between List, Set, and Map
38. ArrayList vs LinkedList
39. HashSet vs TreeSet
40. HashMap vs HashTable vs ConcurrentHashMap
41. How HashMap works internally?
42. What is hashing? Hashcode/equals contract
43. What is Comparable vs Comparator?
44. Fail-fast vs fail-safe iterators
45. How to make collections immutable?
46. What is PriorityQueue?
47. Difference between Iterator and ListIterator
48. What are Java 8 stream APIs?
49. map() vs flatMap()
50. What are collectors? Common collectors

---

## 🔹 Exception Handling (10 Questions)
51. Exception hierarchy in Java
52. Checked vs unchecked exceptions
53. What is try-with-resources?
54. Can we have try without catch?
55. What is exception propagation?
56. Difference between throw and throws
57. How to create custom exceptions?
58. What is Error vs Exception?
59. Best practices for exception handling
60. What is @SuppressWarnings?

---

## 🔹 Multithreading (15 Questions)
61. Process vs thread
62. Ways to create threads
63. Runnable vs Callable
64. Thread lifecycle states
65. What is synchronization?
66. synchronized keyword usage
67. What are volatile variables?
68. What is deadlock? How to avoid?
69. What is thread starvation?
70. wait(), notify(), notifyAll() methods
71. What is thread pool? Executor framework
72. What is Future and CompletableFuture?
73. What is atomic variable?
74. What is ThreadLocal?
75. Concurrent collections in Java

---

## 🔹 Java 8+ Features (10 Questions)
76. What are lambda expressions?
77. Functional interfaces in Java
78. Method references types
79. Optional class purpose
80. Stream API operations
81. map() vs flatMap()
82. What are default methods?
83. What are static methods in interfaces?
84. New Date/Time API benefits
85. Records and sealed classes

---

## 🔹 JVM & Performance (10 Questions)
86. JVM architecture overview
87. What is classloader?
88. What is bytecode?
89. What is JIT compiler?
90. Heap memory structure
91. What is garbage collection? Types of GC
92. String pool concept
93. How to handle memory leaks?
94. What is OutOfMemoryError? Common causes
95. JVM tuning parameters

---

📌 What are Data Transfer Objects? Learn to Use DTOs in Your Java Spring-Based Projects

✍️ Augustine Alul
🏷️ #Java

📌 What are Data Transfer Objects? Learn to Use DTOs in Your Java Spring-Based Projects

✍️ Augustine Alul
🏷️ #Java