Java Streams: Unraveling flatMap() for Nested Lists

🚀 Day 2/100 – Understanding How Java Actually Runs Day 1 was about logic. Day 2 was about execution and internals. Instead of just writing programs, I focused on understanding what actually happens when Java code runs. Writing code is one thing. Understanding the runtime model is another. 📌 Deep Dive Today: 🔹 Java Execution Pipeline • .java → Compilation → .class (Bytecode) • Bytecode → JVM → Native Machine Code • JDK vs JRE vs JVM • What actually makes Java platform-independent 🔹 Boilerplate & Structure • Public class rules • main(String[] args) • File naming & compilation constraints 🔹 Variables & Memory • Stack-level understanding of primitives • Identifiers vs literals • Assignment & reassignment behavior 🔹 Data Types • Primitive vs Non-Primitive • Size & range awareness (byte → double) • Why Java is statically typed 🔹 Type Conversion & Promotion • Widening (implicit) • Narrowing (explicit) • Lossy conversion scenarios • Why byte * byte promotes to int 🔹 Input Handling • Scanner class • next(), nextLine(), nextInt(), nextFloat() • Buffer behavior 💻 Implemented & Tested: ✅ Sum & Product programs ✅ Area of a circle ✅ User-input-based programs ✅ Memory reassignment example ✅ Explicit & implicit type casting cases (Sharing handwritten notes 📖) 💡 Key Insight: Once you understand: Source Code → Bytecode → JVM → Execution You stop treating Java as syntax. You start treating it as a runtime system. That shift changes how you debug, design, and optimize. 🔁 System Update: Concept → Implement → Understand Runtime → Reflect No zero days. Learning under the guidance of Apna College & Shradha Khapra, focusing on mastering fundamentals before moving into complex DSA patterns. This is not just coding practice. It’s building execution-level clarity. Day 2 complete. Consistency compounds. #Day2 #100DaysOfCode #Java #JVM #DSAJourney #PlacementPreparation #LearningInPublic #ApnaCollege

“Where does data actually live in Java… Stack or Heap?” Not how to write the code. But what really happens in memory when the code runs. When a Java program runs, memory is mainly divided into two places. Stack and Heap. Here’s the simple way to think about it. The Stack stores method calls and local variables. Every time a method runs, a new stack frame is created. When the method finishes, that frame disappears. It’s fast, structured, and managed automatically. The Heap, on the other hand, is where objects actually live. Whenever you create something with new, the object goes into the heap. The stack only keeps the reference pointing to that object. So something like this: Person p = new Person(); What really happens is: ↳ p (reference) lives in the stack ↳ Person object lives in the heap This small distinction explains a lot of things developers struggle with: • why objects persist beyond a method call • how memory leaks happen • how garbage collection works • why references behave the way they do Sometimes the hardest part of software engineering isn’t writing code. It’s understanding what the runtime is doing behind the scenes. How do you usually explain Stack vs Heap to someone learning Java? #Java #SoftwareEngineering #Programming #JavaDeveloper #Coding

 Day 33: The 4 Faces of Java Methods – Mastering Data Flow & Logic 🏗️🔄 Today was all about "The Flow." I moved beyond simple methods to explore the four distinct ways we can structure logic in Java. Depending on whether we need to give information to a method or get something back, the syntax changes completely. Here is the "Method Matrix" I mastered today: 1. Method Without Parameter & Without Return Type 🛑 The simplest form. It just performs a static task. ▫️ Example: public void greet() { System.out.println("Hello!"); } ▫️ Usage: For fixed tasks like printing a menu or a header. 2. Method With Parameter & Without Return Type 📥 This allows us to pass data into the method to make it dynamic. ▫️ Example: public void printName(String name) { System.out.println(name); } ▫️ Usage: When you want to perform an action on specific data (like updating a database record). 3. Method Without Parameter & With Return Type 📤 The method does some internal work and sends a result back to the caller. ▫️ Example: public double getPiValue() { return 3.14; } ▫️ Usage: For fetching constant values or generated IDs. 4. Method With Parameter & With Return Type (The Pro Choice) 🔄 The most powerful and common form. It takes input, processes it, and returns the result. ▫️ Example: public int add(int a, int b) { return a + b; } ▫️ Usage: The backbone of Backend Logic. Essential for calculations and data transformations. Invoking the Logic: Method Calling 📞 I also practiced Method Invoking. I learned that if a method has a return type, I should store its result in a variable or use it directly. If it has parameters, I must pass the correct "arguments" in the right order. #JavaFullStack #CleanCode #JavaMethods #LogicBuilding #Day33 #LearningInPublic #BackendDeveloper #CodingJourney #SoftwareEngineering2026 10000 Coders Meghana M

So far, we used : Runnable But Runnable has a limitation: ❌ It cannot return a result ❌ It cannot throw checked exceptions That’s where Callable comes in. Callable<Integer> task = () -> 10 + 20; Unlike Runnable: ✅ It returns a value ✅ It can throw exceptions Now combine it with ExecutorService: import java.util.concurrent.*; ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<Integer> task = () -> 10 + 20; Future<Integer> future = executor.submit(task); System.out.println("Doing other work..."); Integer result = future.get(); // waits if needed System.out.println("Result: " + result); executor.shutdown(); What is Future? A Future represents the result of an asynchronous computation. It allows you to: • Check if task is done → isDone() • Cancel task → cancel() • Get result → get() Important: future.get(); This blocks until result is ready. So even in concurrency, blocking can still happen. The Big Idea Instead of: Run → Wait → Continue We now: Run → Do other work → Collect result later That’s asynchronous thinking. Today was about: • Difference between Runnable & Callable • What Future represents • How asynchronous execution works Modern systems don’t wait. They schedule, continue, and respond when ready. And now… so can your Java programs. #Java #Concurrency #Callable #Future #Multithreading #AsynchronousProgramming #LearningInPublic

☕ Java 1.0 → 1.4 wasn’t just a version timeline. It was the moment software engineering grew up. Between 1996 and 2002, Java introduced ideas that quietly shaped how modern systems are built. While many languages focused on syntax, Java focused on architecture. 🔹 The JVM changed the rules Software stopped belonging to a single machine. “Write Once, Run Anywhere” wasn’t marketing — it was a new philosophy of portability. ♻️ Garbage Collection removed an entire class of memory failures Developers could think about logic, not cleanup. This improved reliability at enterprise scale. 🧠 Built-in OOP, multithreading, exception handling Java encouraged structured thinking. Systems became predictable, maintainable, and team-friendly. 🗄️ JDBC connected software to real-world data This is where Java stepped fully into enterprise territory. ⚡ assert + NIO pushed performance and debugging forward Speed and safety began to coexist. 👉 The impact was bigger than features. Java proved large systems could be: • portable • stable • secure • scalable • long-living Many critical systems running today still rest on foundations laid in this era. This is why Java isn’t just a language — it’s a lesson in engineering discipline. Sharing this infographic as part of my learning series 👇 Understanding the roots helps build the future. 👉 LinkedIn: https://lnkd.in/gfJAR-Q3 #Java #SoftwareArchitecture #SystemDesign #EngineeringMindset #BackendDevelopment #TechEvolution #DeveloperGrowth

🚀 Java Learning Journey – Day 4 Deep Dive into Stack, Heap & References Today was a big clarity day. Instead of just writing Java code, I focused on understanding what actually happens in memory when a program runs. Here’s what I learned: 🧠 1️⃣ Stack vs Heap Stack stores method calls and local variables. Heap stores objects created using new. Every method call creates a new stack frame. When a method finishes, its stack frame is removed. Understanding this made method execution much clearer. 🔎 2️⃣ Primitive vs Reference Primitive values (int, double, etc.) are stored directly in stack. Reference variables are stored in stack. The actual object they refer to is stored in heap. Example: Person p1 = new Person(); p1 → Stack Person object → Heap ♻️ 3️⃣ Object Reachability & Garbage Collection An object becomes eligible for Garbage Collection when: No references point to it anymore. Reassigning or nullifying references can make objects unreachable. This clarified a lot of confusion around memory leaks and object lifecycle. 💡 Biggest Realization Java memory is not magic. Once you understand: Stack frames Reference copying Object reachability Everything becomes predictable and logical. #Java #LearningJourney #JavaMemoryModel #BackendDevelopment #SoftwareEngineering #Day4

Day 44/100 | Building Consistency 🗽 Showing up every day. Learning, growing, and improving. Today I went back to the basics that actually matter: understanding how Java code runs behind the scenes. It’s not just writing code — it’s knowing what happens after you press Run. Java Execution Flow (simple & powerful): 1️⃣ HelloWorld.java → Written by us (human-readable source code) 2️⃣ Java Compiler (javac) → Converts source code into bytecode 3️⃣ HelloWorld.class → Platform-independent bytecode 4️⃣ JVM (Java Virtual Machine) → Translates bytecode into machine code 5️⃣ Output runs on the system 🚀 This is why Java is called: “Write Once, Run Anywhere.” The JVM is the real hero here — it handles memory, security, portability, and execution. Day 44 reminded me: 👉 Strong developers don’t skip fundamentals. 👉 Understanding execution makes debugging, optimization, and backend work much easier. Still showing up. Still building clarity. Still learning Java the right way. 💪☕ #Day44 #Java #JVM #JavaBasics #BackendJourney #Consistency #LearningInPublic #CodeLife

🚀 Day 11 – Mastering Methods, Return Statements & Logical Problem Solving in Java Today’s focus was on writing cleaner, reusable, and structured Java code using methods, arguments, and return statements. Instead of solving problems in a single block inside main(), I concentrated on breaking logic into well-defined methods — making the code more modular and closer to real-world application design. 🧩 What I Worked On: Solved multiple logical challenges with different difficulty levels, including: • Multiplication Table Generator • Sum of Odd Numbers from 1 to N • Factorial Calculator using Functions • Sum of Digits of an Integer • Additional number-based logical problems Each solution was implemented using proper method creation and structured flow control. 🛠 Concepts Applied: ✔ Method Creation & Reusability ✔ Return Statements for Result Handling ✔ Parameter Passing (Arguments) ✔ Looping Constructs (for / while) ✔ Conditional Logic (if-else) ✔ Clean Code Organization ✔ Console-Based Program Execution 🔎 Key Learning Outcomes: • Understood how to design reusable methods instead of writing repetitive code • Improved logical thinking by solving multi-step problems • Learned proper separation of concerns inside small applications • Strengthened foundation in function-based programming • Practiced writing readable and maintainable code This day helped me move from just “writing code” to structuring code properly. Building strong Core Java fundamentals step by step before advancing into Collections Framework, Exception Handling, and Backend Development 🚀 #100DaysOfCode #Java #CoreJava #ProblemSolving #JavaDeveloper #SoftwareDevelopment #BackendDevelopment #CodingJourney

🚀 **Java Records – Writing Less Code, Doing More** One of the most useful features introduced in Java is **Records**. They help developers create immutable data classes with minimal boilerplate. 🔹 **What is a Java Record?** A *record* is a special type of class designed to hold immutable data. Java automatically generates common methods like: * `constructor` * `getters` * `toString()` * `equals()` * `hashCode()` 📌 **Example:** ```java public record User(String name, int age) {} ``` That's it! Java automatically creates: * `name()` and `age()` accessor methods * `equals()` and `hashCode()` * `toString()` * constructor 🔹 **Why use Records?** ✅ Less boilerplate code ✅ Immutable by default ✅ Cleaner and more readable models ✅ Perfect for DTOs and data carriers 🔹 **Behind the scenes** The above record behaves roughly like writing a full class with fields, constructor, getters, equals, hashCode, and toString — but with just one line. 💡 Records are a great example of how **Java continues to evolve to make developers more productive.** Are you using Records in your projects yet? #Java #JavaDeveloper #Programming #SoftwareDevelopment #Coding #Tech

🚀 Day 16 – Java Full Stack Journey | Methods (All 4 Types) & Memory Execution Deep Dive Today was about mastering one of the most powerful concepts in Java: 👉 Methods 👉 Parameters vs Arguments 👉 Stack & Heap execution flow Not just writing methods — but understanding how they execute inside memory. 🔹 The 4 Types of Methods in Java 1️⃣ No Input – No Output public void greet() { System.out.println("Hello World"); } 2️⃣ No Input – With Output public int add() { return 50 + 40; } 3️⃣ With Input – No Output public void add(int a, int b) { int c = a + b; System.out.println(c); } 4️⃣ With Input – With Output public int add(int a, int b) { return a + b; } This is the most commonly used type in real-world applications. 🔹 Important Terminologies ✔ Parameters → Variables declared in method signature ✔ Arguments → Values passed during method call Example: add(50, 40); int a, int b → Parameters 50, 40 → Arguments 🔹 What Happens in Memory? When a method is called: 1️⃣ A Stack Frame is created 2️⃣ Local variables are stored inside the stack 3️⃣ Objects are created inside the Heap 4️⃣ After execution → Stack frame is removed 5️⃣ Objects without references → Become Garbage 6️⃣ Garbage Collector cleans them automatically This follows LIFO (Last In, First Out) principle. Understanding this makes debugging and interviews much easier. 🔹 Real Power of Methods Instead of rewriting logic multiple times: printSquare(n); printSquare(n2); printSquare(n3); You write the logic once, reuse it multiple times. ✔ Code Reusability ✔ Clean Structure ✔ Reduced Code Duplication ✔ Better Maintainability 💡 Biggest Learning Today Java is not about memorizing syntax. It’s about: Understanding execution flow Knowing how memory behaves Writing reusable, structured logic These fundamentals build the foundation for: OOPS → Exception Handling → Collections → Multithreading → Real Projects Strong basics = Strong developer. Day 16 Complete ✔ #Day16 #Java #CoreJava #Methods #StackAndHeap #JVM #GarbageCollection #OOPS #FullStackJourney #LearningInPublic TAP Academy