BridgeLabz-Training

📅 Week 1: Git, GitHub & Java Programming Fundamentals

---

📌 Day 1 – Git & GitHub Setup

(Date: 15-Dec-2025)

✅ Tasks Completed

• Installed and configured Git
• Created a GitHub repository
• Created the required project folder structure

• 📂 Folder Structure

BridgeLabz-Training/
│
├── core-java-practice/
│   ├── gcr-codebase/
│   │   ├── arrays/
│   │   ├── control-flow/
│   │   ├── extras/
│   │   ├── method/
│   │   ├── programming-elements/
│   │   ├── programming-prerequisite/
│   │   └── strings/
│   │
│   ├── leet-code-codebase/
│   ├── scenario-based/
│   │── README.md

• Learned basic Git commands:
  • git init
  • git status
  • git add
  • git commit
  • git push
• Successfully pushed files to the remote repository

---

📅 Day 2 – Git Practice & Basic Java Programs

(Date: 16-Dec-2025)

✅ Tasks Completed

• Practiced the Git workflow to understand commits and version control
• Solved basic Java programs to understand syntax and structure
• Added, committed, and pushed Java files to GitHub

🔗 Code Link

👉 Day 2 – Basic Java Programs

📅 Day 3 – Programming Elements in Java

(Date: 17-Dec-2025)

✅ Topics Covered

• Variables and Data Types
• Operators
• User Input and Output

🧪 Practice Work

• Solved practice problems based on programming fundamentals
• Committed and pushed solutions to the repository

🔗 Code Link

👉 Day 3 – Programming Elements

📅 Day 4 – Java Control Flows

(Date: 18-Dec-2025)

✅ Topics Covered

• Boolean data type
• Boolean expressions and logical operators
• Conditional statements (if, else if, else)
• Loops (for, while)
• switch, break, and continue

🧪 Practice Work

• Solved practice problems based on control flow logic
• Committed and pushed solutions to the repository

🔗 Code Link

👉 Day 4 – Java Control Flows

📅 Day 5 – Java Arrays

(Date: 19-Dec-2025)

✅ Topics Covered

• Creating, accessing, and modifying arrays
• Using for loop and array length
• Multi-dimensional and 2D arrays

🧪 Practice Work

• Solved practice problems using arrays
• Followed best programming practices
• Committed and pushed solutions to the repository

🔗 Code Link

👉 Day 5 – Java Arrays

📅 Day 6 – Java Methods

(Date: 20-Dec-2025)

✅ Topics Covered

• User-defined and reusable methods
• Passing parameters and returning values
• Recursive methods
• Static and library methods

🧪 Practice Work

• Solved practice problems using methods
• Committed and pushed solutions to the repository

🔗 Code Link

👉 Day 6 – Java Methods

📅 Day 7 – Java Strings & Exception Handling

(Date: 22-Dec-2025)

✅ Topics Covered

• Creating and manipulating strings
• String arrays and built-in methods
• Exception types and hierarchy

🧪 Practice Work

• Solved practice problems using strings
• Committed and pushed solutions to the repository

🔗 Code Link

👉 Day 7 – Java Strings

📌 Day 8 – Extras

(Date: 24-Dec-2025)

✅ Overview

• Practiced string handling and common string methods
• Learned functions, parameter passing, and return values
• Used built-in utilities like Random and Math
• Introduced date and time handling using modern Java APIs
• Followed best practices for organizing code into functions

🧪 Hands-on Practice

• Solved programs using strings, built-in functions, and date-time
• Organized code into reusable methods
• Committed and pushed the code to the repository

🔗 Code Link

👉 Day 8 – Extras

📅 Week 2: Object-Oriented Programming

📌 Day 1 – Leetcode Practice & Introduction to OOP

(Date: 26-Dec-2025)

✅ Overview

• Solved LeetCode problems to improve logic and optimization
• Practiced scenario-based Java programs for real-world understanding
• Revised core Java concepts through hands-on coding
• Explored procedural programming and understood its limitations
• Compared procedural vs object-oriented programming paradigms
• Learned why OOP is widely used in modern software development

📘 Core Concepts Covered

• Class and Object
• Encapsulation and Abstraction
• Inheritance
• Polymorphism

🧪 Hands-on Practice

• Implemented and tested Java solutions
• Solved LeetCode and scenario-based problems
• Implemented a sample program using the procedural approach
• Committed and pushed the code to the repository

🔗 Code Links

👉 Leet code practice
👉 Introduction to OOP

📌 Day 2 – Constructors & Access Modifiers Best Practices

(Date: 27-Dec-2025)

✅ Overview

• Learned best practices for designing clean and efficient constructors
• Understood the importance of using the this keyword to avoid ambiguity
• Explored how to apply access modifiers to ensure proper encapsulation
• Followed the principle of least privilege in class design

📘 Key Concepts

• Constructor best practices and overloading
• Usage of this keyword
• Encapsulation in constructors
• Access modifiers: private, protected, public, and package-private
• Getters and setters for controlled access
• Avoiding data leaks with mutable objects

🧪 Hands-on Practice

• Implemented classes using constructor overloading and proper access control
• Committed and pushed the code to the repository

🔗 Code Link

👉 Day 10 – Constructors & Access Modifiers

📌 Day 3 – Java Keywords & Scenario-Based Practice

(Date: 29-Dec-2025)

✅ Overview

• Solved scenario-based problems using Java control flow
• Practiced conditional statements, loops, and formatted output
• Learned key Java keywords for better code structure
• Used Eclipse IDE for implementing and testing programs

📘 Key Concepts

• Control flow & formatted output
• this, static, final keywords
• instanceof operator

🔗 Code Links

👉 Scenario-Based Practice
👉 Keywords & Operators

📌 Day 4 – OOP Design Principles & Scenario-Based Java Practice

(Date: 30-Dec-2025)

✅ Overview

• Studied and submitted Object-Oriented Design Principles
• Practiced UML diagrams for system design
• Solved multiple scenario-based Java programs
• Applied arrays, loops, and conditional statements
• Focused on clean and readable code structure

🧩 Problems Solved

• Temperature Logger
• Train Reservation Queue
• Fitness Challenge Tracker
• Movie Ticket Booking App
• Library Reminder App

🔗 Code Links

👉 OOP Design Principles
👉 Scenario-Based Practice

📌 Day 5 – Inheritance & Core Java Scenario-Based Practice

(Date: 31-Dec-2025)

✅ Overview

• Practiced core Java scenario-based problems
• Worked with loops, conditional logic, and user interaction
• Studied Inheritance concepts and their role in code reusability
• Understood how inheritance supports polymorphism in Java
• Focused on writing structured and readable console programs

📘 Topics Covered

• Inheritance
• Method overriding
• Constructor inheritance
• Polymorphism and inheritance
• Access modifiers and inheritance

🧩 Problems Solved

• Digital Watch Simulation
• Online Quiz Application
• Currency Exchange Kiosk
• Bus Route Distance Tracker
• Festival Lucky Draw

🔗 Code Links

👉 Scenario-Based Practice
👉 Inheritance in Java

📌 Day 6 – Encapsulation, Interface, Abstract Classes, Polymorphism & Scenario-Based Problem Solving approch

(Date: 01-Jan-2026)

✅ Overview

• Learned core object-oriented concepts used in real-world applications
• Understood encapsulation, interfaces, abstract classes, and polymorphism
• Learned a structured approach to solve scenario-based Java problems
• Practiced identifying entities, behaviors, and relationships before coding
• Focused on breaking complex problems into smaller logical components

📘 Topics Covered

• Encapsulation
• Interfaces
• Abstract Classes
• Polymorphism
• Approach to solve oops scenario-based problems

🔗 Code Link

👉 Java OOP Practice

📅 Week 3: Data Structures

📌 Day 1 – Linked Lists & Scenario-Based Practice

(Date: 02-Jan-2026)

✅ Overview

• Studied Linked Lists as a core data structure for dynamic data handling
• Understood node connections and pointer management
• Compared Singly, Doubly, and Circular linked lists
• Practiced insertion, deletion, and traversal operations
• Applied linked list concepts in scenario-based OOP problems

📘 Concepts Covered

• Singly Linked List
• Doubly Linked List
• Circular Linked List

🧩 Scenario-Based Problems Practiced

• Hospital Patient Management System
• Vehicle Rental Application
• University Course Enrollment System
• E-Wallet Application
• Smart Home Automation System

🔗 Code Links

👉 Linked Lists Practice
👉 Scenario-Based OOP Practice

📌 Day 2 – Stack, Queue, HashMap & Scenario-Based OOP Practice

(Date: 03-Jan-2026)

✅ Overview

• Learned core data structures used in Java
• Practiced Stack (LIFO) and Queue (FIFO) operations
• Studied HashMap and basics of hashing functions
• Applied OOP principles through real-world, scenario-based problems
• Focused on clean design and business logic implementation

📘 Topics Covered

• Stack
• Queue
• HashMap
• Hashing Function
• Encapsulation, Inheritance, Interfaces, Polymorphism

🧩 Scenarios Practiced

• CabbyGo – Ride-Hailing Application
• MyBank – Customer Account Management System

🔗 Code Links

👉 Stack & Queue Practice
👉 HashMap Practice
👉 Scenario-Based OOP Practice

📌 Day 3 – Sorting Algorithms & Scenario-Based OOP Practice

(Date: 06-Jan-2026)

✅ Overview

• Implemented common sorting algorithms and understood their working
• Applied sorting to real-world data scenarios
• Practiced advanced OOP concepts through story-based applications
• Focused on clean design, encapsulation, and polymorphism

🧩 Problems & Scenarios Practiced

• Sorting Algorithms: Bubble, Insertion, Merge, Quick, Selection, Heap, Counting
• CampusConnect – College Information System
• SwiftCart – Grocery Shopping Application

🔗 Code Links

👉 Sorting Algorithms Practice
👉 Scenario-Based OOP Practice

📌 Day 4 – Java Strings, File I/O, Searching & Scenario-Based OOP

(Date: 06-Jan-2026)

✅ Overview

• Practiced mutable strings using StringBuilder and StringBuffer
• Worked with basic file reading using Java I/O classes
• Implemented Linear Search and Binary Search
• Solved advanced, real-world OOP scenarios
• Applied inheritance, interfaces, encapsulation, and polymorphism

📘 Topics Covered

• StringBuilder, StringBuffer
• FileReader, InputStreamReader
• Linear Search, Binary Search

🧩 Scenarios Practiced

• EduMentor – Personalized Learning Platform
• FitTrack – Personal Fitness Tracker
• PetPal – Virtual Pet Care App
• EventEase – Event Management Platform

🔗 Code Links

👉 Strings, File I/O & Searching Practice
👉 Scenario-Based OOP Practice

📌 Day 5 – Runtime Analysis & Scenario-Based OOP Practice

(Date: 07-Jan-2026)

✅ Overview

• Learned Big-O notation for time and space complexity analysis
• Compared Linear vs Binary Search on large datasets
• Analyzed sorting algorithms: Bubble, Merge, and Quick Sort
• Evaluated performance of String, StringBuilder, and StringBuffer
• Studied lookup efficiency using Array, HashSet, and TreeSet
• Built real-world Java applications using OOP principles
• Applied encapsulation, inheritance, interfaces, and polymorphism
• Focused on secure data handling and business logic design

🧩 Scenarios Practiced

• LoanBuddy – Loan Approval Automation
• BookBazaar – Digital Bookstore
• ParkEase – Smart Parking System

🔗 Code Links

👉 Runtime Analysis Practice
👉 Scenario-Based OOP Practice

📌 Day 6 – Scenario-Based OOP Applications

(Date: 08-Jan-2026)

✅ Overview

• Designed real-world Java applications using OOP principles
• Applied encapsulation, inheritance, interfaces, and polymorphism
• Focused on business logic, data security, and clean class design

🧩 Scenarios Practiced

• MediStore – Pharmacy Inventory & Sales System
• TourMate – Travel Itinerary Planner

🔗 Code Link

👉 Day 6 – Scenario-Based OOP Practice

📌 Day 7 – Scenario-Based OOP Applications

(Date: 09-Jan-2026)

✅ Overview

• Designed real-world Java applications using OOP principles
• Applied encapsulation, inheritance, interfaces, and polymorphism
• Focused on clean business logic and controlled data access

🧩 Scenarios Practiced

• Artify – Digital Art Marketplace
• FoodLoop – Restaurant Ordering System
• SkillForge – Online Learning Portal

🔗 Code Link

👉 Day 7 – Scenario-Based OOP Practice

📌 Day 8 – Scenario-Based Data Structures Practice

(Date: 10-Jan-2026)

✅ Overview

• Solved real-world scenario-based problems using data structures
• Applied Linked Lists, Stacks, Queues, and HashMaps
• Focused on efficient insertion, deletion, and traversal
• Designed solutions using clean and modular logic

🧩 Scenarios Practiced

• BookShelf – Library Organizer
• BrowserBuddy – Tab History Manager
• AmbulanceRoute – Emergency Patient Navigation

🔗 Code Link

👉 Day 8 – DSA Scenario-Based Practice

📌 Day 9 – Scenario-Based Practice (DSA & OOP)

(Date: 12-Jan-2026)

✅ Overview

• Practiced real-world problems using Data Structures and OOP concepts
• Implemented linked lists, stacks, queues, and hashmap-based logic
• Applied inheritance, interfaces, encapsulation, and polymorphism

---

🧩 DSA Scenarios Practiced

• CallCenter – Customer Queue Manager
• TrainCompanion – Compartment Navigation System
• TextEditor – Undo/Redo Functionality
• TrafficManager – Roundabout Vehicle Flow
• BookShelf – Library Organizer

---

🧩 OOP Scenarios Practiced

• HomeNest – Smart Home Device Manager
• BudgetWise – Personal Finance Tracker
• GameBox – Mobile Game Distribution Platform

---

🔗 Code Links

👉 DSA Scenario Practice 👉 OOP Scenario Practice

📌 Day 10 – Scenario-Based Practice (DSA & OOP)

(Date: 13-Jan-2026)

✅ Overview

• Practiced real-world applications using Data Structures and OOP
• Implemented Queue, Stack, Linked List, HashMap-based logic
• Designed systems using inheritance, interfaces, and polymorphism
• Learned basics of annotations and reflection in Java

---

🧩 DSA Scenarios Practiced

• SmartCheckout – Supermarket Billing Queue
• ParcelTracker – Delivery Chain Management
• ExamProctor – Online Exam Review System

🧩 OOP Scenarios Practiced

• PayXpress – Utility Bill Payment System
• EcoWing Bird Sanctuary – Behavior & Tracking System

📘 Concepts Applied

• Linked Lists, Stack, Queue, HashMap
• Inheritance & Interfaces
• Polymorphism & Encapsulation
• Custom Annotations & Reflection

🔗 Code Links

👉 DSA Scenario Practice 👉 OOP Scenario Practice

📘 Week 4 – Collections & Generics Practice

---

📌 Day 1 – Java Generics & Sorting Algorithms

(Date: 15-Jan-2026)

✅ Overview

• Learned Java Generics best practices for type safety and reusability
• Worked with generic classes, methods, bounded types, and wildcards
• Avoided common pitfalls like raw types and type erasure
• Practiced scenario-based sorting algorithms with real-world use cases

---

📘 Java Generics Concepts Covered

• Generic classes and generic methods
• Upper bounded (? extends T) and lower bounded (? super T) wildcards
• Bounded type parameters (<T extends Class>)
• Avoiding raw types and type erasure
• Using generics with collections

---

🧩 Sorting Algorithm Scenarios Practiced

• HospitalQueue – Patient Sorting by Criticality (Bubble Sort)
• SmartShelf – Real-Time Book Arrangement (Insertion Sort)
• ZipZipMart – Daily Sales Summary Report (Merge Sort)
• EventManager – Ticket Price Optimizer (Quick Sort)
• ExamCell – Student Rank Generator (Merge Sort)

---

🔗 Code Links

👉 Java Generics Practice
👉 Sorting Algorithms Practice

📌 Day 2 – Collections Framework & Sorting Practice

(Date: 16-Jan-2026)

✅ Overview

• Learned the Java Collections Framework and its core interfaces
• Understood List, Set, Queue, Deque, and Map implementations
• Practiced scenario-based sorting algorithms
• Chose appropriate sorting techniques based on data size

🧩 Sorting Scenarios

• RoboWarehouse – Insertion Sort
• CinemaHouse – Bubble Sort
• CropMonitor – Quick Sort

🔗 Code Links

👉 Collections Practice
👉 Sorting Practice

📌 Day 3 – OOP & Scenario-Based Sorting Practice

(Date: 17-Jan-2026)

✅ Overview

• Practiced real-world OOP scenario-based problems
• Applied classes, objects, constructors, and encapsulation
• Modeled systems using composition and interfaces
• Practiced sorting algorithms using story-driven scenarios
• Focused on choosing the right algorithm based on data size and behavior

🧩 OOP Scenarios Practiced

• GeoMeasure – Line Comparison System
• Bag-n-Ball – Toy Storage Organizer

🧩 Sorting Scenarios Practiced

• ArtExpo – Sort Artists by Registration Time (Insertion Sort)
• FleetManager – Vehicle Maintenance Scheduler (Merge Sort)
• IceCreamRush – Sorting Flavors by Popularity (Bubble Sort)
• SmartLibrary – Auto-Sort Borrowed Books (Insertion Sort)

📘 Concepts Applied

• Classes and Objects
• Constructors and this keyword
• Encapsulation and getters/setters
• Composition (has-a relationship)
• Interfaces
• Bubble, Insertion, and Merge Sort

🔗 Code Links

👉 OOP Scenario Practice
👉 Sorting Scenario Practice

📌 Day 4 – Java I/O Streams, DSA & OOP Practice

(Date: 19-Jan-2026)

✅ Overview

• Learned Java I/O Streams for file and data handling
• Understood byte streams vs character streams
• Practiced DSA sorting algorithms using real-world scenarios
• Built an OOP-based application using core Java concepts

📘 Java I/O Streams Practiced

• FileInputStream & FileOutputStream
• FileReader & FileWriter
• BufferedInputStream & BufferedOutputStream
• BufferedReader & BufferedWriter
• ObjectInputStream & ObjectOutputStream
• ByteArrayInputStream & ByteArrayOutputStream
• InputStreamReader & OutputStreamWriter

📊 DSA Sorting Scenarios

• RoboWarehouse – Insertion Sort
• CinemaHouse – Bubble Sort
• CropMonitor – Quick Sort

📇 OOP Practice

• Address Book System – Contact Management Application
• Add, edit, delete contacts
• Search contacts by city or state
• Display contacts sorted alphabetically
• Duplicate contact validation

🔗 Code Links

👉 Java I/O Streams Practice
👉 DSA Sorting Practice
👉 OOP Address Book System

📌 Day 5 – Exception Handling & DSA Sorting Practice

(Date: 20-Jan-2026)

✅ Overview

• Learned Exception Handling in Java for writing safe and robust code
• Understood how to handle runtime and compile-time errors
• Practiced creating and using custom exceptions
• Solved DSA sorting problems using real-world scenarios
• Selected sorting algorithms based on performance and data size

📘 Exception Handling Topics Covered

• Checked and Unchecked Exceptions
• try-catch blocks
• try-catch-finally blocks
• try-with-resources
• throw and throws
• Creating custom exceptions
• Extending the Exception class
• Defining constructors for exceptions

📊 DSA Sorting Scenarios

• EduResults – Rank Sheet Generator (Merge Sort)
• FlashDealz – Product Sorting by Discount (Quick Sort)
• FitnessTracker – Daily Step Count Ranking (Bubble Sort)

🔗 Code Links

👉 Exception Handling Practice
👉 DSA Sorting Practice

📌 Day 6 – Regex & JUnit Testing with DSA Practice

(Date: 21-Jan-2026)

✅ Overview

• Learned Regular Expressions (Regex) for pattern matching and validation
• Practiced common validation patterns like email, password, and phone number
• Worked with Java Regex API using Pattern and Matcher
• Introduced to JUnit Framework for unit testing
• Wrote basic test cases using annotations and assertions
• Practiced DSA scenario-based problems as additional learning

📘 Regex & JUnit Topics

• Regex meta characters and quantifiers
• Common patterns: Email, Password, Phone Number
• Java Regex API: Pattern and Matcher
• Regex methods: find(), matches(), replaceAll()
• JUnit basics, annotations, and assertions

📊 DSA Scenario-Based Questions

• TailorShop – Sorting Orders by Delivery Deadline (Insertion Sort)
• MedWarehouse – Sorting Medicines by Expiry (Merge Sort)
• University Digital Record System (BST Operations)
• E-Commerce Product Inventory (BST using SKU)
• Music App – Organize Songs by Track ID (BST Traversal)

🔗 Code Links

👉 Regex Practice
👉 JUnit Practice
👉 DSA Scenario-Based Practice

📌 Day 7 – Annotations, Reflection & AVL Tree Practice

(Date: 22-Jan-2026)

✅ Overview

• Learned Java Annotations and their role in modern applications
• Created and used custom annotations
• Explored Reflection API for runtime class inspection
• Understood how Annotations and Reflection work together
• Learned and implemented AVL Tree (self-balancing Binary Search Tree)
• Practiced insertion, deletion, and ordered traversal
• Focused on maintaining balance using rotations

📘 Annotations & Reflection Topics

🔹 Annotations

• Introduction to Annotations
• Common Built-in Annotations
• Creating Custom Annotations
• Advanced Custom Annotations
• Real-World Use Cases
• Annotation Processing Tools

🔹 Reflection

• Understanding Reflection
• Using Reflection in Java
• Annotations and Reflection

🌳 AVL Tree Questions

• Gaming App – Real-Time Leaderboard (AVL Tree Operations)
• Online Ticket Booking – Events Sorted by Time (AVL Tree)
• Hospital Queue Management (AVL Tree by Arrival Time)

🔗 Code Links

👉 Annotations Practice
👉 Reflection Practice
👉 AVL Tree Practice

📘 Week 5 – Java IO Stream Practice

---

📌 Day 1 – CSV Data Handling & Scenario-Based Java Practice

(Date: 23-Jan-2026)

✅ Overview

• Learned CSV (Comma-Separated Values) file handling using Java I/O Streams
• Read, wrote, and processed CSV files using Core Java and OpenCSV
• Parsed CSV data into Java Objects
• Applied Regex-based validation
• Solved real-world scenario-based problems using Collections, Generics, I/O Streams, and Regex
• Focused on writing robust and reusable Java code

---

📘 Topics Covered

🔹 CSV Data Handling

• Introduction to CSV format
• Reading CSV files using BufferedReader
• Writing CSV files using BufferedWriter
• Parsing CSV data into Java Objects
• Data validation using Regex

🔹 Scenario-Based Java Practice

• ResumeAnalyzer – Smart Resume Filtering System
• TravelLog – Trip Organizer for Backpackers
• FeedbackGuru – Smart Survey Analyzer
• CodeRepoCleaner – Java File Scanner and Organizer
• ExamScanner – Digital Answer Sheet Validator

---

🎯 Key Concepts

• Java I/O Streams
• Collections (List, Set, Map, PriorityQueue)
• Generics
• Regular Expressions
• Exception Handling
• Stream API for filtering and sorting

---

🔗 Code Links

👉 CSV Data Handling Practice
👉 Scenario-Based Java Practice

📌 Day 2 – JSON Handling & Scenario-Based Java Practice

(Date: 24-Jan-2026)

✅ Overview

• Learned JSON (JavaScript Object Notation) for data exchange
• Understood JSON structure: objects, arrays, and nested data
• Created JSON using org.json, Gson, and Jackson
• Read, wrote, and parsed JSON files in Java
• Performed JSON Schema validation
• Solved real-world scenario-based problems using I/O, Collections, Generics, and Regex
• Focused on building robust and scalable Java solutions

---

📘 Topics Covered

🔹 JSON Handling

• JSON syntax and key-value structure
• Data types: String, Number, Boolean, Array, Object, null
• Nested JSON objects and arrays
• Creating JSON using org.json, Gson, and Jackson
• Reading JSON into Java POJOs
• Writing Java objects to JSON files
• Dynamic JSON parsing using JsonNode
• JSON Schema validation

🔹 Scenario-Based Java Practice

• MedInventory – Smart Hospital Inventory Tracker
• ChatLogParser – Messaging Pattern Analyzer
• SongVault – Personal Music Library Manager
• ExamResultUploader – Bulk Marks Processing
• DealTracker – E-Commerce Discount Validator

---

🎯 Key Concepts

• Java I/O Streams
• JSON Object & JSON Array
• ObjectMapper usage
• Collections (List, Set, Map, TreeMap, PriorityQueue)
• Generics and Interfaces
• Regular Expressions
• Custom Exception Handling
• Java Streams and Comparators

---

🔗 Code Links

👉 JSON Handling Practice
👉 Scenario-Based Java Practice

📘 Week 6 – Java 8 and Its Features

---

📌 Day 1 – Java 8 Features & Scenario-Based Practice

(Date: 27-Jan-2026)

✅ Overview

• Learned core Java 8 functional programming features
• Understood Lambda Expressions and their syntax variations
• Explored Functional Interfaces and predefined interfaces
• Practiced writing clean and maintainable functional-style code
• Solved real-world scenario-based problems using Annotations, Reflection, CSV, and JSON
• Focused on structured data processing and metadata validation

---

📘 Topics Covered

🔹 Lambda Expressions

• Syntax forms (no parameter, single parameter, multiple parameters)
• Target typing & type inference
• Closures and effectively final variables
• Difference between lambda and anonymous class
• Practical use cases with Runnable, Comparator, Predicate

---

🔹 Functional Interfaces

• Definition (Single Abstract Method – SAM)
• @FunctionalInterface annotation
• Creating custom functional interfaces
• Predefined interfaces:
  • Consumer<T>
  • Supplier<T>
  • Function<T,R>
  • Predicate<T>
  • Comparator<T>
  • Runnable
• SAM conversion and lambda usage

---

🔹 Scenario-Based Practice

• HealthCheckPro – API Metadata Validator (Annotations + Reflection)
• MarkMate – Student Marksheet Generator (CSV + JSON)
• EventTracker – Auto Audit System (Annotations + Reflection + JSON)

---

🎯 Key Concepts

• Functional Programming in Java
• Clean and concise lambda implementations
• Contract-based interface design
• Custom Annotations and Reflection usage
• CSV and JSON data handling
• Exception handling for robust systems

---

🔗 Code Links

👉 Lambda Expressions Practice

👉 Functional Interfaces Practice

👉 Scenario-Based Practice (Annotations, Reflection, CSV & JSON)

📌 Day 2 – Stream API, Collectors & Real-Time Practice

(Date: 28-Jan-2026)

✅ Overview

• Explored Java Stream API in depth
• Practiced Intermediate and Terminal operations
• Understood Stateless vs Stateful operations
• Learned about Ordered vs Unordered streams
• Worked with Parallel Streams
• Compared forEach() in Iterable vs Stream
• Implemented real-time problems using Streams, Collectors, and Java 8 features

---

📘 Topics Covered

🔹 Stream API – Intermediate Operations

• filter()
• map()
• flatMap()
• distinct()
• sorted()
• peek()
• limit()
• skip()

🔹 Stream API – Terminal Operations

• collect()
• forEach()
• reduce()
• count()
• anyMatch()
• allMatch()
• noneMatch()

🔹 Stream Characteristics

• Stateless vs Stateful Operations
• Ordered vs Unordered Streams
• Parallel Streams
• forEach() – Iterable vs Stream difference

---

🔹 Collectors – Roles & Capabilities

• Collectors.toList()
• Collectors.toSet()
• Collectors.groupingBy()
• Collectors.partitioningBy()
• Collectors.counting()
• Collectors.averagingInt()
• Collectors.summingDouble()
• Collectors.mapping()

---

🔹 Real-Time Scenario-Based Problems

• Employee Data Analysis (21+ Stream Queries)
• Student Data Analysis (Filtering, Grouping, Ranking, Partitioning)
• Lambda Expression real-time cases
• Functional Interface real-time use cases
• Optional class real-world scenarios

---

🔹 Workshop

Smart City Transport & Service Management System

• Applied Stream API for filtering and grouping
• Used Collectors for aggregation
• Implemented ranking and department-based analytics
• Designed clean and efficient stream pipelines

---

🎯 Key Concepts

• Functional Programming in Java
• Data aggregation and transformation
• Ranking and analytics using Streams
• Null-safe operations using Optional
• Writing scalable and maintainable stream pipelines

---

🔗 Code Links

👉 Stream API Practice

👉 Collectors Practice

👉 Scenario-Based Stream Problems

👉 Workshop – Smart City System