============================================================
  IT6003 - Advanced Java Programming
  Lab Session 2: Generics & Lambda Expressions
  State University of Zanzibar (SUZA)
============================================================

OBJECTIVES:
- Create and use generic classes and methods
- Understand bounded type parameters and wildcards
- Write lambda expressions for functional interfaces
- Use built-in functional interfaces (Predicate, Function, Consumer, Supplier)
- Apply method references

============================================================
PART A: Generics [30 minutes]
============================================================

Exercise 1: Generic Box Class
-------------------------------
a) Create a generic class Box<T> with:
   - private T item;
   - void set(T item), T get(), boolean isEmpty()
b) Create Box<String>, Box<Integer>, Box<Student>.
c) Try to put a String in Box<Integer> - observe compile error.

Exercise 2: Generic Pair
--------------------------
a) Create a generic class Pair<K, V> with:
   - K getKey(), V getValue()
   - toString() returning "(key, value)"
   - swap() returning new Pair<V, K>
b) Create Pair<String, Integer> for name-age pairs.
c) Create Pair<String, List<String>> for name-courses mapping.

Exercise 3: Generic Methods
-----------------------------
a) Write: static <T> void printArray(T[] array)
b) Write: static <T extends Comparable<T>> T findMax(T[] array)
c) Write: static <T> int countOccurrences(T[] array, T target)
d) Write: static <T> List<T> arrayToList(T[] array)
e) Test each with Integer[], String[], and Double[] arrays.

Exercise 4: Bounded Types and Wildcards
-----------------------------------------
a) Write: static <T extends Number> double sum(List<T> list)
   - Should work with List<Integer>, List<Double>, List<Float>
b) Write: static void printList(List<?> list)  // unbounded
c) Write: static double total(List<? extends Number> list)  // upper bound
d) Write: static void addNumbers(List<? super Integer> list)  // lower bound
e) Test each method and observe which calls compile and which don't.

============================================================
PART B: Lambda Expressions [30 minutes]
============================================================

Exercise 5: Basic Lambda Syntax
----------------------------------
a) Define a functional interface: MathOperation with double operate(double a, double b)
b) Create lambda implementations for: add, subtract, multiply, divide, power
c) Store them in variables and call each.
d) Create a method: double calculate(double a, double b, MathOperation op)
e) Call calculate() with inline lambda expressions.

Exercise 6: Built-in Functional Interfaces
---------------------------------------------
Given: List<String> names = Arrays.asList("Ali", "Fatma", "Hassan", "Amina", "Omar", "Zainab");

a) Predicate<String>: filter names longer than 4 characters
b) Predicate<String>: filter names starting with "A"
c) Chain predicates: names starting with "A" AND longer than 3 chars
d) Function<String, Integer>: convert each name to its length
e) Function<String, String>: convert to uppercase
f) Consumer<String>: print each name with "Hello, " prefix
g) Supplier<String>: generate random names from the list

Exercise 7: Method References
-------------------------------
a) Use String::toUpperCase as a method reference with map()
b) Use System.out::println as a method reference with forEach()
c) Use Integer::parseInt to convert List<String> to List<Integer>
d) Use String::new (constructor reference) with a stream
e) Create a static method and use ClassName::methodName reference

Exercise 8: Comparator with Lambda
-------------------------------------
Given a list of Student objects (name, gpa, regNo):
a) Sort by name: (a, b) -> a.getName().compareTo(b.getName())
b) Sort by GPA descending: Comparator.comparingDouble(Student::getGpa).reversed()
c) Sort by name length, then alphabetically: use thenComparing()
d) Use Comparator.comparing() with method reference
e) Use Comparator.nullsFirst() and Comparator.nullsLast()

============================================================
PART C: Combining Generics and Lambdas [30 minutes]
============================================================

Exercise 9: Generic Filter Method
------------------------------------
a) Write: static <T> List<T> filter(List<T> list, Predicate<T> predicate)
b) Use it to filter List<Integer> (keep even numbers)
c) Use it to filter List<String> (keep strings with length > 5)
d) Use it to filter List<Student> (keep GPA > 3.0)

Exercise 10: Generic Transform Method
----------------------------------------
a) Write: static <T, R> List<R> transform(List<T> list, Function<T, R> mapper)
b) Transform List<String> to List<Integer> (string lengths)
c) Transform List<Student> to List<String> (student names)
d) Transform List<Integer> to List<String> (number to words)

Exercise 11: Generic forEach
------------------------------
a) Write: static <T> void forEach(List<T> list, Consumer<T> action)
b) Print all elements
c) Print elements with index: "0: Ali, 1: Fatma, ..."
d) Write elements to a file (Consumer that writes to BufferedWriter)

Exercise 12: Functional Pipeline
-----------------------------------
Build a data processing pipeline:
a) Given List<String> of mixed text: names, numbers, and empty strings
b) Step 1: Filter out empty/null strings (Predicate)
c) Step 2: Trim whitespace (Function)
d) Step 3: Convert to uppercase (Function)
e) Step 4: Sort by length (Comparator)
f) Step 5: Print each with index (Consumer)
g) Chain all steps using compose() and andThen()

============================================================
PART D: Challenge [30 minutes]
============================================================

Exercise 13: Generic Repository
----------------------------------
a) Define interface: Repository<T, ID> with save, findById, findAll, delete
b) Define interface: Identifiable<ID> with ID getId()
c) Implement GenericRepository<T extends Identifiable<ID>, ID>
   using HashMap internally
d) Create Employee implements Identifiable<Integer>
e) Create repository and perform CRUD operations
f) Add a findBy(Predicate<T>) method that uses lambdas for flexible queries

============================================================
SUBMISSION:
Submit all .java files in a folder named Lab02_RegNo/
============================================================