Understanding Nested For Loops in Java Programming Basics

🚀 𝗗𝗔𝗬 𝟭𝟭: 𝗡𝗘𝗦𝗧𝗘𝗗 𝗙𝗢𝗥 𝗟𝗢𝗢𝗣𝗦 – 𝗠𝗔𝗞𝗜𝗡𝗚 𝗦𝗘𝗡𝗦𝗘 𝗢𝗙 𝗣𝗔𝗧𝗧𝗘𝗥𝗡𝗦 🚀 Day 11 was all about Nested for Loops , and this topic changed how I look at pattern programs completely 💡 Earlier, I used to see patterns as something to memorise.   Today I realized they are simply about understanding loop flow. 🔹 𝗪𝗛𝗔𝗧 𝗗𝗢𝗘𝗦 𝗡𝗘𝗦𝗧𝗘𝗗 𝗙𝗢𝗥 𝗟𝗢𝗢𝗣 𝗠𝗘𝗔𝗡?   Nested for loop means writing one for loop inside another. • The outer loop decides how many times the structure repeats.   • The inner loop decides what gets printed in each repetition. In simple words:   👉 One outer loop run = one complete inner loop run. 🔹 𝗨𝗡𝗗𝗘𝗥𝗦𝗧𝗔𝗡𝗗𝗜𝗡𝗚 𝗧𝗛𝗘 𝗙𝗟𝗢𝗪   A simple way to think: • Outer loop → number of lines   • Inner loop → content inside each line  If the outer loop runs 5 times and the inner loop runs 4 times,   the inner code executes 20 times. 🔹 𝗣𝗥𝗔𝗖𝗧𝗜𝗖𝗔𝗟 𝗨𝗦𝗘 𝗖𝗔𝗦𝗘𝗦   Nested loops are commonly used when: • Printing star or number patterns   • Working with tables   • Handling matrix-style problems  Whenever there is a row–column structure, nested loops are involved. 🔹 𝗟𝗘𝗦𝗦𝗢𝗡𝗦 𝗜 𝗟𝗘𝗔𝗥𝗡𝗘𝗗 𝗧𝗢𝗗𝗔𝗬   • Patterns don’t need memorization   • Dry-running helps more than writing code directly   • Understanding the loop flow saves a lot of confusion  ✨ 𝗞𝗘𝗬 𝗧𝗔𝗞𝗘𝗔𝗪𝗔𝗬   Nested loops become easy once we stop focusing on symbols and start focusing on logic. One concept at a time. One step at a time 🚀 #Java #CoreJava #NestedLoops #ForLoop #JavaLearning #LearningInPublic #100DaysOfCode

When I first started programming, I had a very simple mental model: 𝗦𝗮𝗺𝗲 𝗶𝗻𝗽𝘂𝘁 → 𝘀𝗮𝗺𝗲 𝗼𝘂𝘁𝗽𝘂𝘁. It felt almost like math. ⁉️ So I couldn’t understand how a program could sometimes 𝘣𝘦𝘩𝘢𝘷𝘦 𝘥𝘪𝘧𝘧𝘦𝘳𝘦𝘯𝘵𝘭𝘺 𝘸𝘪𝘵𝘩 𝘵𝘩𝘦 𝘦𝘹𝘢𝘤𝘵 𝘴𝘢𝘮𝘦 𝘥𝘢𝘵𝘢. Then I ran into multithreading. And I realized that in concurrent systems, 𝘵𝘪𝘮𝘦 𝘣𝘦𝘤𝘰𝘮𝘦𝘴 𝘱𝘢𝘳𝘵 𝘰𝘧 𝘵𝘩𝘦 𝘪𝘯𝘱𝘶𝘵. Two threads executing the same code can produce different results depending on timing. Not because the logic is wrong but because execution order isn’t guaranteed. ❌ 𝘊𝘰𝘳𝘳𝘦𝘤𝘵-𝘭𝘰𝘰𝘬𝘪𝘯𝘨 𝘤𝘰𝘥𝘦 𝘥𝘰𝘦𝘴𝘯’𝘵 𝘢𝘭𝘸𝘢𝘺𝘴 𝘮𝘦𝘢𝘯 𝘤𝘰𝘳𝘳𝘦𝘤𝘵 𝘣𝘦𝘩𝘢𝘷𝘪𝘰𝘳. 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗲𝘅𝗮𝗺𝗽𝗹𝗲 𝘄𝗵𝗲𝗿𝗲 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗰𝗼𝗺𝗲𝘀 𝗶𝗻 For example, something as simple as: 𝗰𝗼𝘂𝗻𝘁𝗲𝗿++; isn’t atomic. 𝗜𝘁’𝘀 𝗿𝗲𝗮𝗱 → 𝗺𝗼𝗱𝗶𝗳𝘆 → 𝘄𝗿𝗶𝘁𝗲. If two threads interleave those steps, the result changes. That was the moment I stopped thinking of programs as just logic. They are 𝗹𝗼𝗴𝗶𝗰 + 𝘁𝗶𝗺𝗲 + 𝘀𝗵𝗮𝗿𝗲𝗱 𝘀𝘁𝗮𝘁𝗲. 𝗕𝘂𝘁 𝘄𝗵𝗮𝘁 𝗶𝘀 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴❓ At a basic level, it means running multiple threads inside one program. Instead of doing tasks one by one, the program can be doing 𝘴𝘦𝘷𝘦𝘳𝘢𝘭 𝘵𝘢𝘴𝘬𝘴 𝘢𝘵 𝘵𝘩𝘦 𝘴𝘢𝘮𝘦 𝘵𝘪𝘮𝘦. Why do we use it? 🟢 𝗧𝗼 𝘂𝘀𝗲 𝗺𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗖𝗣𝗨 𝗰𝗼𝗿𝗲𝘀 🟢 𝗧𝗼 𝗶𝗺𝗽𝗿𝗼𝘃𝗲 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 🟢 𝗧𝗼 𝗸𝗲𝗲𝗽 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝘃𝗲 🟢 𝗧𝗼 𝗿𝘂𝗻 𝗯𝗮𝗰𝗸𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗮𝘀𝗸𝘀 Sounds simple but... ...once threads start sharing memory, things get complicated. You can run into: 🟡 𝗥𝗮𝗰𝗲 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀 🟡 𝗗𝗮𝘁𝗮 𝗶𝗻𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗶𝗲𝘀 🟡 𝗗𝗲𝗮𝗱𝗹𝗼𝗰𝗸𝘀 🟡 𝗩𝗶𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗶𝘀𝘀𝘂𝗲𝘀 It changes how you think about correctness. Now it’s not only “𝘸𝘩𝘢𝘵 𝘩𝘢𝘱𝘱𝘦𝘯𝘴” but also “𝘸𝘩𝘦𝘯 𝘪𝘵 𝘩𝘢𝘱𝘱𝘦𝘯𝘴”. #Java #Multithreading #SoftwareEngineering #Backend #Programming

Writing methods is powerful. But real Java begins when you understand classes. A class is not just a file. It’s a blueprint. When you write: public class Car { String model; int speed; void accelerate() { speed++; } } You’re defining: • What something has (state / fields) • What something does (behavior / methods) That’s object-oriented thinking. Instead of writing loose functions, you start modeling real-world entities. This shift matters. Procedural thinking asks: “How do I solve this step by step?” Object-oriented thinking asks: “What is responsible for this behavior?” That small shift improves: • Code organization • Scalability • Maintainability Today was about: • Understanding what a class really represents • The difference between state and behavior • Thinking in objects instead of instructions Structure is not restriction. It’s preparation for complexity. #Java #OOP #Classes #SoftwareDesign #Programming #LearningInPublic

𝗗𝗮𝘆 𝟱𝟲/𝟭𝟬𝟬 — 𝗕𝗮𝗰𝗸 𝘁𝗼 𝘁𝗵𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗰𝘀 Day 56. Valid Parentheses. The problem everyone sees on Day 1 of learning stacks. Except this time? I actually get why it works. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟮𝟬: Valid Parentheses (Easy) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Given a string of brackets: (), {}, []. Check if they're properly matched and nested. Examples: "()" → Valid "([)]" → Invalid (wrong order) "{[]}" → Valid (properly nested) 𝗧𝗵𝗲 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: Stack. That's it. Push opening brackets. When you see a closing bracket, check if it matches the stack top. If yes, pop. If no, invalid. Empty stack at the end = valid. First time I saw this problem, I thought "why use a stack?" Now I see it—LIFO matches the nesting structure perfectly. 𝗪𝗵𝘆 𝗜𝘁 𝗠𝗮𝘁𝘁𝗲𝗿𝘀: This isn't just about parentheses. It's about recognizing when a problem needs LIFO behavior. Compilers use this. Code editors use this. Expression parsing uses this. Pattern recognition >> memorization. 𝗖𝗼𝗱𝗲: https://lnkd.in/gdCu84Ja 56 down. 44 to go. 𝗗𝗮𝘆 𝟱𝟲/𝟭𝟬𝟬 ✅ #100DaysOfCode #LeetCode #Stack #DataStructures #Algorithms #ProblemSolving #CodingInterview #Programming #Java #PatternRecognition

🚀 𝗗𝗔𝗬 𝟭𝟮: 𝗔𝗣𝗣𝗟𝗬𝗜𝗡𝗚 𝗡𝗘𝗦𝗧𝗘𝗗 𝗙𝗢𝗥 𝗟𝗢𝗢𝗣𝗦 𝗧𝗢 𝗣𝗔𝗧𝗧𝗘𝗥𝗡𝗦 🚀 After understanding Nested for Loops on Day 11, today I focused on applying the concept through simple pattern programs ⭐ This is where the real clarity started. 🔹 𝗙𝗥𝗢𝗠 𝗖𝗢𝗡𝗖𝗘𝗣𝗧 𝗧𝗢 𝗖𝗢𝗗𝗘 💡 Yesterday I understood: • Outer loop → controls rows   • Inner loop → controls columns  Today I applied that knowledge to print a simple pattern like: * ** *** **** Instead of memorizing it, I asked myself: 👉 How many rows are required?   👉 How many stars in each row?   👉 When should the line break happen? Once these answers were clear, writing the nested loop became easy. 🔹 𝗪𝗛𝗔𝗧 𝗜 𝗥𝗘𝗔𝗟𝗜𝗭𝗘𝗗 🧠 Patterns are not about stars. They are about understanding how loops repeat work in a structured way. For every single iteration of the outer loop, the inner loop runs completely. That repetition creates the visual structure. ✨ 𝗞𝗘𝗬 𝗟𝗘𝗔𝗥𝗡𝗜𝗡𝗚 🚀 When the structure of loops is clear, patterns become logical instead of confusing. Small improvements every day lead to strong fundamentals. #Java #CoreJava #NestedForLoop #PatternPrograms #JavaLearning #LearningInPublic #100DaysOfCode

✅ Solution — LeetCode 739. Daily Temperatures (Java) 🧠 Idea (Monotonic Stack) We use a stack to store indices of days. The stack keeps temperatures in decreasing order. When we find a warmer temperature, we: Pop the previous index from stack Calculate the difference in days Store it in the result array 💻 Java Code class Solution { public int[] dailyTemperatures(int[] temperatures) { int n = temperatures.length; int[] res = new int[n]; Stack<Integer> stack = new Stack<>(); for(int i = 0; i < n; i++){ while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){ int prev = stack.pop(); res[prev] = i - prev; } stack.push(i); } return res; } } ⏱ Time Complexity O(n) Each element is pushed and popped once. 💾 Space Complexity O(n) 🚀 100 Days of Learning & Problem Solving – Day 79 🚀 📅 Day 79 / 100 Continuing my #100DaysOfLeetCode journey by exploring the Monotonic Stack pattern today. ✅ Today’s Progress: 🔹 Solved LeetCode 739 – Daily Temperatures 🔹 Implemented the monotonic stack technique for efficient comparisons 🔹 Practiced solving “next greater element” type problems 🔹 Improved understanding of stack-based problem-solving patterns 🧠 Key Learnings: ✔️ Using stacks to track unresolved elements ✔️ Identifying the “next greater element” pattern ✔️ Avoiding brute-force nested loops with a linear-time solution ✔️ Writing efficient solutions with better time complexity Problems like this show how the right data structure can reduce complexity dramatically. From nested loops to linear time — the power of patterns 🚀 📌 Alongside DSA, I continue focusing on: ✔️ Strengthening core programming fundamentals ✔️ Recognizing reusable problem-solving patterns ✔️ Writing clean and efficient code ✔️ Staying consistent with daily practice Learning every day, improving one problem at a time 💪 #100DaysOfLearning #LeetCode #DSA #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

Loops exist because repetition is unavoidable in real programs. But the real skill isn’t writing loops. It’s 𝗰𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗶𝗻𝗴 𝗿𝗲𝗽𝗲𝘁𝗶𝘁𝗶𝗼𝗻. Java gives you 𝒇𝒐𝒓, 𝒘𝒉𝒊𝒍𝒆, and 𝒅𝒐-𝒘𝒉𝒊𝒍𝒆 because not all repetition is the same. Most beginners pick a loop randomly. Experienced developers choose based on intent. A 𝙛𝙤𝙧 loop says: 𝘐 𝘬𝘯𝘰𝘸 𝘩𝘰𝘸 𝘮𝘢𝘯𝘺 𝘵𝘪𝘮𝘦𝘴 𝘵𝘩𝘪𝘴 𝘸𝘪𝘭𝘭 𝘳𝘶𝘯. A 𝙬𝙝𝙞𝙡𝙚 loop says:  𝘐 𝘥𝘰𝘯’𝘵 𝘬𝘯𝘰𝘸 𝘸𝘩𝘦𝘯 𝘵𝘩𝘪𝘴 𝘸𝘪𝘭𝘭 𝘴𝘵𝘰𝘱, 𝘣𝘶𝘵 𝘐 𝘬𝘯𝘰𝘸 𝘵𝘩𝘦 𝘤𝘰𝘯𝘥𝘪𝘵𝘪𝘰𝘯. A 𝙙𝙤-𝙬𝙝𝙞𝙡𝙚 loop says: 𝘛𝘩𝘪𝘴 𝘮𝘶𝘴𝘵 𝘳𝘶𝘯 𝘢𝘵 𝘭𝘦𝘢𝘴𝘵 𝘰𝘯𝘤𝘦. That distinction matters. Choosing the right loop makes code easier to read, easier to debug, and harder to misuse. Infinite loops, off-by-one errors, and performance issues often come from ignoring intent. Today was about: • Understanding when each loop makes sense • Avoiding common loop mistakes • Writing repetition that communicates purpose Good loops don’t just run. They explain themselves. #Java #Loops #ControlFlow #CleanCode #Programming #SoftwareEngineering #LearningInPublic

🚀 Day 19 of Learning Today wasn’t easy, but it was productive. Covered: • Abstract & Inner Classes • Interfaces (why we actually need them) • Enums & Annotations • Functional Interface & Lambda Expressions • Exception Handling (try-catch, hierarchy, throw) Some concepts were confusing at first — especially abstraction and lambdas — but breaking them into small parts helped. Slow progress is still progress. #Java #LearningJourney #BackendDevelopment #Consistency #spring

🚀 𝗪𝗵𝘆 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲𝘀 𝗶𝗻 𝗝𝗮𝘃𝗮 𝗠𝘂𝘀𝘁 𝗛𝗮𝘃𝗲 𝗢𝗻𝗹𝘆 𝗢𝗻𝗲 𝗠𝗲𝘁𝗵𝗼𝗱 In 𝗝𝗮𝘃𝗮 8, functional interfaces were introduced to support 𝗹𝗮𝗺𝗯𝗱𝗮 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 and enable a more functional programming style. A 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 is simply an interface that contains 𝗲𝘅𝗮𝗰𝘁𝗹𝘆 𝗼𝗻𝗲 𝗮𝗯𝘀𝘁𝗿𝗮𝗰𝘁 𝗺𝗲𝘁𝗵𝗼𝗱. But why only one? Because 𝗹𝗮𝗺𝗯𝗱𝗮 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 𝗻𝗲𝗲𝗱 𝗮 𝘀𝗶𝗻𝗴𝗹𝗲 𝘁𝗮𝗿𝗴𝗲𝘁 𝗯𝗲𝗵𝗮𝘃𝗶𝗼𝗿. When the interface has just one abstract method, the compiler knows exactly which method the lambda is implementing. 💡 𝗘𝘅𝗮𝗺𝗽𝗹𝗲: @𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗖𝗮𝗹𝗰𝘂𝗹𝗮𝘁𝗼𝗿 {     𝗶𝗻𝘁 𝗼𝗽𝗲𝗿𝗮𝘁𝗲(𝗶𝗻𝘁 𝗮, 𝗶𝗻𝘁 𝗯); } 𝗖𝗮𝗹𝗰𝘂𝗹𝗮𝘁𝗼𝗿 𝗮𝗱𝗱 = (𝗮, 𝗯) -> 𝗮 + 𝗯; Here, the lambda (𝗮, 𝗯) -> 𝗮 + 𝗯 automatically implements the 𝗼𝗽𝗲𝗿𝗮𝘁𝗲 method. If the interface had multiple abstract methods, the compiler wouldn’t know which method the lambda should represent, making lambdas ambiguous. ⚡ 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Functional interfaces allow 𝗰𝗹𝗲𝗮𝗻𝗲𝗿 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲 𝗰𝗼𝗻𝗰𝗶𝘀𝗲 𝗰𝗼𝗱𝗲, enabling powerful features like: - Lambda expressions - Method references - Stream API All built on the simplicity of 𝗼𝗻𝗲 𝘀𝗶𝗻𝗴𝗹𝗲 𝗮𝗯𝘀𝘁𝗿𝗮𝗰𝘁 𝗺𝗲𝘁𝗵𝗼𝗱. #Java #Java8 #FunctionalProgramming #LambdaExpressions #SoftwareDevelopment

Back on track after a short health break — consistency continues 💪 Day 12 of #100DaysOfCode 🚀 👉 LeetCode #15 – 3Sum (Medium) This problem really tests how well you can optimize brute-force thinking into an efficient solution. 🔹 Approach: First, sort the array Fix one element at a time Use two pointers (left & right) to find pairs with sum -nums[i] Carefully skip duplicates to avoid repeated triplets ⏱ Complexity: Time: O(n²) Space: O(1) (excluding output) 📌 Key Learnings: Sorting can simplify complex problems Two-pointer technique shines after sorting Handling duplicates is as important as core logic Medium problems demand clarity + patience, not shortcuts 💡 Takeaway: Optimization isn’t about writing less code — it’s about thinking smarter, step by step. Building strong DSA fundamentals in Java, one problem at a time. #LearnInPublic #DSA #Java #LeetCode #TwoPointers #ProblemSolving #CodingJourney #SoftwareEngineering #100DaysOfCode