Mastering Java For Loop Fundamentals

Day 14 of my coding journey — Extracting Unique Words using Java Streams Today I explored a clean and efficient way to extract unique words from a string using Java Streams. Instead of writing multiple loops and conditional checks, I leveraged the power of functional programming: Grouped words using a frequency map Filtered out words that appear more than once Collected only truly unique words in a concise pipeline What I really liked about this approach is how readable and expressive the code becomes. It clearly shows what we want to achieve rather than how step-by-step. Key takeaway: Writing optimized code is not just about performance — it’s also about clarity, maintainability, and using the right abstractions. Every day I’m getting more comfortable thinking in terms of streams, transformations, and data flow. If you have alternative approaches or optimizations, I’d love to hear them. #Day14 #Java #CodingJourney #JavaStreams #BackendDevelopment #ProblemSolving #CleanCode

Day 73 of #90DaysDSAChallenge Solved LeetCode 451: Sort Characters By Frequency Learned an important Java design concept today. Problem Overview: The task was to sort characters in a string based on descending frequency. What confused me initially: Why create a separate Freq class instead of just using HashMap and PriorityQueue directly? Key Learning: PriorityQueue stores one complete object at a time. For this problem, each item needs two pieces of data together: Character Frequency Example: Instead of storing: e and 2 separately We package them as: Freq('e', 2) That custom class acts like a container holding both values in one object, so PriorityQueue can compare and sort them correctly. Why this matters: This taught me that custom classes in Java are often not about complexity, they simply bundle related data into one manageable unit. Alternative approach: We can also use Map.Entry<Character, Integer> instead of creating a custom class, but building Freq makes the logic easier to understand while learning. Today’s takeaway: Not every class is for business logic — sometimes it exists just to package data cleanly. #Java #90DaysDSAChallenge #LeetCode #PriorityQueue #HashMap #CodingJourney #ProblemSolving

Day 19 of #100DaysOfCode Solved “Base 7” problem today — a simple yet insightful exercise on number systems. 💡 Approach: Convert the integer into base 7 by repeatedly dividing by 7 and storing remainders. Handle negative numbers separately and reverse the result at the end. ⚡ Key Learning: Even easy problems strengthen fundamentals like loops, math logic, and edge case handling. Consistency > Complexity. #LeetCode #DSA #CodingJourney #Java #ProblemSolving #100DaysOfCode

In today’s session, we covered one of the most powerful features introduced in modern Java - the Stream API. We walked through a practical data processing pipeline and focused on understanding how to write clean, functional-style code while building step-by-step data transformation pipelines. Below is a simple diagram drawn illustrating the concept discussed during the session. #Java #JavaStreams #FunctionalProgramming #Coding #Learning #TechEducation

Most developers read files. Fewer actually process them efficiently. Here’s a simple but powerful example using Java Streams — counting the number of unique words in a file in just a few lines of code. What looks like a basic task actually highlights some important concepts: • Stream processing for large data • Functional programming with map/flatMap • Eliminating duplicates using distinct() • Writing clean, readable, and scalable code Instead of looping manually and managing data structures, this approach lets you express the logic declaratively. It’s not just about solving the problem — it’s about solving it the right way. Small improvements like this can make a big difference when working with large datasets or building production-grade systems. How would you optimize this further for very large files? #Java #JavaDeveloper #StreamsAPI #FunctionalProgramming #CleanCode #BackendDevelopment #SoftwareEngineering #Programming #DevelopersOfLinkedIn #CodingJourney #TechLearning #100DaysOfCode

Day 15/60 🚀 Multithreading Models Explained (Simple & Clear) This diagram shows how user threads (created by applications) are mapped to kernel threads (managed by the operating system). The way they are mapped defines the performance and behavior of a system. --- 💡 1. Many-to-One Model 👉 Multiple user threads → single kernel thread ✔ Fast and lightweight (managed in user space) ❌ If one thread blocks → entire process blocks ❌ No true parallelism (only one thread executes at a time) ➡️ Suitable for simple environments, but limited in performance --- 💡 2. One-to-One Model 👉 Each user thread → one kernel thread ✔ True parallelism (multiple threads run on multiple cores) ✔ Better responsiveness ❌ Higher overhead (more kernel resources required) ➡️ Used in most modern systems (like Java threading model) --- 💡 3. Many-to-Many Model 👉 Multiple user threads ↔ multiple kernel threads ✔ Combines benefits of both models ✔ Efficient resource utilization ✔ Allows concurrency + scalability ❌ More complex to implement ➡️ Used in advanced systems for high performance --- 🔥 Key Insight - User threads → managed by application - Kernel threads → managed by OS - Performance depends on how efficiently they are mapped --- ⚡ Simple Summary Many-to-One → Lightweight but limited One-to-One → Powerful but resource-heavy Many-to-Many → Balanced and scalable --- 📌 Why this matters Understanding these models helps in: ✔ Designing scalable systems ✔ Writing efficient concurrent programs ✔ Optimizing performance in backend applications --- #Java #Multithreading #Concurrency #OperatingSystems #Threading #BackendDevelopment #SoftwareEngineering #CoreJava #DistributedSystems #SystemDesign #Programming #TechConcepts #CodingJourney #DeveloperLife #LearnJava #InterviewPreparation #100DaysOfCode #CareerGrowth #WomenInTech #LinkedInLearning #CodeNewbie

Day 44-What I Learned In a Day(JAVA) Today I revised pattern programming in Java to strengthen my core logic and understanding of loops. What I practiced: • Star patterns • Number patterns • Pyramid patterns • Inverted patterns • Nested loop logic Pattern programming helped me improve: • Loop control (for/while) • Logical thinking • Understanding of rows & columns Every pattern I solve makes my logic stronger step by step. Consistency is the key #Java #CodingJourney #PatternProgramming #Learning #StudentDeveloper

🛡️ Day 50: The Power of Encapsulation – My Java Journey ☕ I’ve officially hit the 50-day mark! 🚀 Today was all about one of the most vital pillars of Object-Oriented Programming: Encapsulation. In simple terms? It’s about hiding the internal state of an object and requiring all interaction to happen through a "controlled interface." Why does this matter? Imagine a bank account where anyone could just reach in and change the balance variable. Total chaos! Encapsulation prevents this by making data private. 🔑 The Core Components: ▫️ Data Hiding: Using the private access modifier so variables are invisible to the outside world. The Gatekeepers (Getters & Setters): ▫️ Getters: Allow controlled Read-Only access. ▫️ Setters: Allow controlled Write-Only access—this is where the "Validation Logic" lives (e.g., “Don’t allow a negative balance update”). 🌟 The Major Advantages: ✅ Security: Your data is shielded from unauthorized or accidental modification. ✅ Flexibility: You can change the internal implementation without breaking the code that uses the class. ✅ Maintainability: Since data is accessed in one way (the methods), debugging becomes a breeze. 💡 My "Aha!" Moment: Encapsulation isn't just about "hiding" things; it’s about "Control." It turns a "dumb" data container into a "smart," self-protecting object. Day 50/100. Halfway there! The foundation is solid, and I’m ready for the next 50. 💻 Question for the Dev Community: When writing Setters, do you always include validation logic, or do you sometimes keep them simple for the sake of speed? Let's talk! 👇 #Java #Encapsulation #100DaysOfCode #ObjectOrientedProgramming #BackendEngineering #SoftwareDevelopment #CleanCode 10000 Coders Meghana M

Most of us use Generics. Very few actually understand why they exist. Before Generics, everything in Java Collections was treated like an Object. Which means: You could store anything. But when retrieving, you had to cast it back manually. And that’s where the problem started. Wrong cast = Runtime failure. With Generics, you define the type at compile time. Box<String> means only String goes in. Box<Integer> means only Integer goes in. No ambiguity, safe casting and no surprises at runtime. Now errors move from runtime to compile time Less production bugs. More predictable code. Better readability for teams. Generics are not just syntax like <T> They are a design contract. Which means “You can only use this structure in this way.” Stable, Simple and Impactful. #Java #SystemDesign #CleanCode #BackendDevelopment #Programming

Day 11 of Learning Java Streams Today I worked on a simple but insightful problem: Extract all digits from a string and calculate their sum. I first approached it in a more step-by-step (brute force style) using streams: Converted characters to objects Filtered digits Converted each digit to String Then to Integer Finally used reduce() to compute the sum While it worked, I realized it involved unnecessary conversions and overhead. Then I explored a more optimized approach: Stayed within IntStream Filtered digits directly Used Character.getNumericValue() Leveraged built-in sum() This made the solution cleaner, faster, and more efficient. Key Learning: Choosing the right stream type (IntStream vs Stream<T>) can significantly simplify logic and improve performance. Small improvements like avoiding unnecessary transformations can make code more readable and efficient. #Java #JavaStreams #CodingJourney #LearningInPublic #BackendDevelopment #ProblemSolving #100DaysOfCode