Java Programming Labs

Your Task: Master Java's HashMap and HashSet collections for efficient key-value storage and unique element management.

Detailed Requirements:
1. Import java.util.* for collection classes.

2. Create and use HashMap:
   • HashMap<String, Integer> scores = new HashMap<>();
   • put(key, value) - add/update entries
   • get(key) - retrieve value by key
   • containsKey(key) - check if key exists
   • keySet(), values(), entrySet() - iterate

3. Create and use HashSet:
   • HashSet<String> names = new HashSet<>();
   • add(element) - adds unique elements only
   • contains(element) - check membership
   • remove(element) - remove element

4. Iterate through collections using for-each or entrySet().

Key Concepts:
• HashMap: Key-Value pairs, O(1) lookup, keys must be unique
• HashSet: Unique elements only, no duplicates, O(1) contains
• Both use hashCode() and equals() internally

Expected Output:
--- HashMap Demo --- Scores: {Alice=95, Bob=87, Charlie=92} Alice's score: 95 Contains Bob? true All entries: Alice -> 95 Bob -> 87 Charlie -> 92 --- HashSet Demo --- Unique names: [Alice, Bob, Charlie] Add duplicate 'Alice': false Contains 'Bob'? true After removing Bob: [Alice, Charlie]

Your Task: Master functional programming in Java using lambda expressions and the Stream API for elegant data processing.

Detailed Requirements:
1. Import required classes:
   import java.util.*;
   import java.util.stream.*;

2. Lambda Expression Syntax:
   • (params) -> expression - single expression
   • (params) -> { statements; } - code block
   • Example: list.forEach(x -> System.out.println(x));

3. Stream Operations:
   • filter(predicate) - select elements matching condition
   • map(function) - transform each element
   • sorted() - sort elements
   • collect(Collectors.toList()) - gather results
   • reduce() - combine elements into single result

4. Common patterns:
   • list.stream().filter(x -> x > 5).collect(Collectors.toList())
   • list.stream().map(x -> x * 2).toList()
   • list.stream().mapToInt(x -> x).sum()

Expected Output:
Original: [3, 1, 4, 1, 5, 9, 2, 6] Filtered (>3): [4, 5, 9, 6] Doubled: [8, 10, 18, 12] Sorted: [4, 5, 6, 9] Sum: 31 Names: [Alice, Bob, Charlie, David] Names starting with 'A' or 'C': [Alice, Charlie] Uppercase: [ALICE, CHARLIE]

Your Task: Learn Java multithreading fundamentals by creating threads, managing their lifecycle, and understanding basic synchronization.

Detailed Requirements:
1. Create thread by extending Thread class:
   class MyThread extends Thread { public void run() { } }
   Override the run() method with thread logic

2. Create thread using Runnable interface:
   class MyRunnable implements Runnable { public void run() { } }
   Thread t = new Thread(new MyRunnable());

3. Thread lifecycle methods:
   • start() - begin thread execution
   • join() - wait for thread to complete
   • sleep(millis) - pause execution
   • getName() - get thread name

4. Lambda shorthand:
   Thread t = new Thread(() -> { /* code */ });

Key Concepts:
• Thread = independent path of execution
• Main thread spawns child threads
• Threads run concurrently (may interleave)
• Use join() to ensure completion before continuing

Expected Output (order may vary):
Main thread starting... Thread-A: Count 0 Thread-B: Count 0 Thread-A: Count 1 Thread-B: Count 1 Thread-A: Count 2 Thread-B: Count 2 Thread-A finished! Thread-B finished! Lambda thread running... Main thread finished!