Pramod Suthar’s Post

𝗙𝗿𝗼𝗺 𝟱𝟬 𝗟𝗶𝗻𝗲𝘀 𝘁𝗼 𝟭: 𝗠𝘆 𝗝𝗼𝘂𝗿𝗻𝗲𝘆 𝘄𝗶𝘁𝗵 𝗝𝗮𝘃𝗮 𝗜𝗺𝗺𝘂𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆 🚀 I used to think creating a safe, immutable class in Java was a chore. It turns out, I was just doing it the "old" way. Here is how I moved from complex boilerplate to clean, modern Java: Phase 1: The Traditional Way (The 5 Steps) 📝 To make a standard class truly immutable, you need to follow these strict rules: final class: Stop anyone from extending and changing your logic. private final fields: Lock your variables so they can’t be reassigned. No Setters: If you don’t provide a setX() method, the data can’t change! Defensive Copying: If you have a List, copy it in the constructor so the caller can’t change it from the outside. Boilerplate: Manually write equals(), hashCode(), and toString(). (Total: ~50 lines of code for one simple object! 😫) Phase 2: The "Record" Revolution (The 1-Line Way) ⚡ Since Java 14, we can replace all that manual work with a Record. 𝐩𝐮𝐛𝐥𝐢𝐜 𝐫𝐞𝐜𝐨𝐫𝐝 𝐔𝐬𝐞𝐫(𝐒𝐭𝐫𝐢𝐧𝐠 𝐧𝐚𝐦𝐞, 𝐋𝐢𝐬𝐭<𝐒𝐭𝐫𝐢𝐧𝐠> 𝐠𝐫𝐚𝐝𝐞𝐬) {} Why this is a game-changer: It is final by default. Fields are private final by default. equals(), hashCode(), and toString() are generated for you. Phase 3: The Final Level (Deep Immutability) ❄️ Wait! Even in a Record, a List is still mutable. To make it 100% safe, use a Compact Constructor: 𝐩𝐮𝐛𝐥𝐢𝐜 𝐫𝐞𝐜𝐨𝐫𝐝 𝐔𝐬𝐞𝐫(𝐒𝐭𝐫𝐢𝐧𝐠 𝐧𝐚𝐦𝐞, 𝐋𝐢𝐬𝐭<𝐒𝐭𝐫𝐢𝐧𝐠> 𝐠𝐫𝐚𝐝𝐞𝐬) {   𝐩𝐮𝐛𝐥𝐢𝐜 𝐔𝐬𝐞𝐫 {     𝐠𝐫𝐚𝐝𝐞𝐬 = 𝐋𝐢𝐬𝐭.𝐜𝐨𝐩𝐲𝐎𝐟(𝐠𝐫𝐚𝐝𝐞𝐬); // 𝐍𝐨𝐰 𝐢𝐭'𝐬 𝐭𝐫𝐮𝐥𝐲 𝐟𝐫𝐨𝐳𝐞𝐧!   } } The Result? ✅ Thread Safety: No more race conditions. ✅ Clean Code: You focus on the data, not the "ceremony." ✅ Peace of Mind: Your objects won't change behind your back. #Java #SoftwareEngineering #CleanCode #JavaRecords #ProgrammingTips #LearningInPublic

🚀 𝗔𝗿𝗿𝗮𝘆𝗟𝗶𝘀𝘁 𝘃𝘀 𝗟𝗶𝗻𝗸𝗲𝗱𝗟𝗶𝘀𝘁 — 𝗪𝗵𝗶𝗰𝗵 𝗢𝗻𝗲 𝗦𝗵𝗼𝘂𝗹𝗱 𝗪𝗲 𝗨𝘀𝗲? While revising the Java Collection Framework, I realized something important. We often use ArrayList by default. But do we really understand when to use LinkedList instead? Both implement the List interface, but internally they are completely different. 🔹 𝗔𝗿𝗿𝗮𝘆𝗟𝗶𝘀𝘁 ArrayList is backed by a dynamic array. That means: • Accessing elements using index is very fast • But inserting or deleting in the middle requires shifting elements So it works best when: ✔ We mostly read data ✔ Random access is frequent 🔹 𝗟𝗶𝗻𝗸𝗲𝗱𝗟𝗶𝘀𝘁 LinkedList is backed by a doubly linked list. That means: • Insertion and deletion are faster • Accessing elements by index is slower So it works best when: ✔ We frequently add/remove elements ✔ We modify data often 𝗦𝗶𝗺𝗽𝗹𝗲 𝗖𝗼𝗱𝗲 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 ->List<Integer> list1 = new ArrayList<>(); ->List<Integer> list2 = new LinkedList<>(); Same interface. Different internal working. Different performance behavior. 💡 𝗪𝗵𝗮𝘁 𝗜 𝗟𝗲𝗮𝗿𝗻𝗲𝗱 Choosing the right data structure is not about syntax. It’s about understanding the use case. The more I revise Collections, the more I realize that fundamentals matter more than memorizing methods. #Java #CollectionFramework #ArrayList #LinkedList #Programming #DSA #LearningJourney

🚀 Day 12 – Understanding Arrays & Implementing Searching Techniques in Java Today’s focus was on mastering Arrays and implementing searching problems using methods in Core Java.this session helped me understand how data is stored, accessed, and processed efficiently using array structures — one of the most fundamental concepts in programming. Instead of writing everything inside main(), I practiced solving problems using properly defined methods to keep the logic clean and reusable. 🧩 What I Worked On: • Creating and initializing arrays • Taking array input from users • Traversing arrays using loops 🛠 Concepts Applied: ✔ Arrays (Declaration, Initialization, Traversal) ✔ Method Creation & Reusability ✔ Parameter Passing (Array as Argument) ✔ Return Statements ✔ Looping Constructs Key Learning Outcomes: • Understood how arrays manage multiple data values efficiently • Learned how to pass arrays to methods • Strengthened searching logic using structured programming • Improved code readability with modular design • Practiced writing clean, maintainable programs Arrays are a foundational step toward mastering Data Structures and Algorithms, and today strengthened that base significantly. Step by step building strong Core Java fundamentals before moving into advanced data structures and backend development #100DaysOfCode #Java #CoreJava #Arrays #DataStructures #ProblemSolving #JavaDeveloper #BackendDevelopment #CodingJourney

🚀 Day 15/30 – Java DSA Challenge 🔎 Problem 67: 225. Implement Stack using Queues (LeetCode – Easy) Continuing Day 15 with another foundational data structure problem — implementing a Stack (LIFO) using only Queue (FIFO) operations. This problem strengthens core understanding of: ✅ Stack vs Queue behavior ✅ Data Structure simulation ✅ Queue rotation logic ✅ LIFO implementation under constraints 🧠 Problem Summary We must design a stack using only standard queue operations: push(x) pop() top() empty() ⚠ Constraint: Only queue operations like add (push to back), poll (remove from front), peek, size, and isEmpty are allowed. 💡 Key Insight Stack → Last In First Out (LIFO) Queue → First In First Out (FIFO) To simulate LIFO behavior using FIFO: 👉 After every push, rotate the queue so the newly added element moves to the front. That ensures: pop() removes the most recently added element top() always returns the latest element 🔄 Approach Used 1️⃣ Use a single queue 2️⃣ On push(x): Add element to queue Rotate all previous elements behind it 3️⃣ pop() → simply poll from queue 4️⃣ top() → peek front 5️⃣ empty() → check if queue is empty ⏱ Complexity Analysis Push: O(N) Pop: O(1) Top: O(1) Space Complexity: O(N) 📌 Concepts Strengthened ✔ Stack fundamentals ✔ Queue manipulation ✔ Data structure transformation ✔ Logical thinking under constraints 📈 Learning Reflection Even though the problem is labeled Easy, it tests conceptual clarity. When constraints change, true understanding of data structures helps you adapt — not just memorize implementations. ✅ Day 15 Progress Update 🔥 67 Problems Solved in 30 Days DSA Challenge Consistency + Concept Clarity = Long-Term Mastery 🚀 #Day15 #30DaysOfDSA #Java #LeetCode #Stack #Queue #DataStructures #ProblemSolving #InterviewPreparation #CodingJourney

Loops work. But they don’t always express intent clearly. That’s where 𝗦𝘁𝗿𝗲𝗮𝗺𝘀 𝗔𝗣𝗜 changed Java. Instead of telling the system how to iterate, you describe what you want. Example: List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); names.stream() .filter(name -> name.startsWith("A")) .map(String::toUpperCase) .forEach(System.out::println); This reads like a pipeline: • Take a collection • Filter it • Transform it • Consume it No explicit loop. No temporary variables. No manual indexing. Streams encourage: • Functional-style thinking • Declarative code • Cleaner data transformation They also introduce: • Lambda expressions • Method references • Lazy evaluation Today was about: • Understanding 𝘀𝘁𝗿𝗲𝗮𝗺() • Difference between intermediate and terminal operations • Writing expressive and readable data pipelines Modern Java isn’t about writing more code. It’s about writing clearer code. #Java #Streams #FunctionalProgramming #CleanCode #SoftwareEngineering #LearningInPublic

Day 50 — LeetCode Progress (Java) Problem: Range Sum Query – Immutable Required: Design a data structure that can return the sum of elements between indices left and right (inclusive) efficiently for multiple queries. Idea: Precompute a prefix sum array so each query can be answered in O(1) time instead of recalculating sums repeatedly. Approach: Build a prefix array where: prefix[i] = sum of elements from index 0 to i During initialization: Traverse the array once Keep a running sum and store it in prefix For each query sumRange(left, right): If left == 0 → return prefix[right] Else → return prefix[right] - prefix[left - 1] Time Complexity: Preprocessing: O(n) Query: O(1) Space Complexity: O(n) #LeetCode #DSA #Java #PrefixSum #Algorithms #CodingJourney #100DaysOfCode

Day 75 - LeetCode Journey Solved LeetCode 21: Merge Two Sorted Lists in Java ✅ Moving from Strings to Linked Lists! Today’s challenge was about maintaining order while merging two separate data structures into one seamless, sorted list. The Approach: 1) Dummy Node Strategy: Started with a "dummy" node to act as the foundation of the new list, which simplifies edge cases where the head might change. 2) Iterative Comparison: Used a while loop to compare the values of the current nodes in both lists, always attaching the smaller value to our result list. 3) Pointer Management: Carefully advanced the pointers for both the source lists and the new merged list to ensure no data was lost. 4) Cleanup: Once one list was exhausted, I simply appended the remainder of the other list—since they are already sorted, no further comparisons were needed! Key Takeaways: ->Memory Efficiency: Merged the lists in-place by re-linking existing nodes rather than creating new ones. ->100% Runtime: Achieved a 0 ms runtime by focusing on a clean iterative approach. ->Pointer Logic: Reinforced the importance of keeping track of "next" references to prevent breaking the chain. Every pointer moved correctly is a step closer to mastering Linked Lists. Consistency is doing its work! 💪 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingPractice #InterviewPreparation #Consistency #DailyCoding

💡 Understanding the Boolean Concept in Programming The Boolean data type represents a logical value: true or false. It is fundamental for implementing conditional logic, control flow, and decision-making in programming. Boolean values are typically produced through relational and logical operations such as: Relational operators: >, <, ==, !=, >=, <= Logical operators: && (AND), || (OR), ! (NOT) 🔹 Example in Java: int age = 20; boolean isEligible = age >= 18; if(isEligible && age < 60){ System.out.println("Eligible for registration"); } In this example, the Boolean expression evaluates conditions and controls the execution flow of the program. Boolean logic plays a critical role in algorithms, validations, filtering data, and controlling application behavior. #Java #ProgrammingConcepts #BooleanLogic #CodingJourney #SoftwareDevelopment 🚀

🚀 JAVA EVOLUTION: FROM VERBOSE MODELING TO ELEGANT PRECISION If you are still modeling your data using the Java 8 mindset, you are missing out on the most significant productivity boost in the ecosystem. The jump from Java 8 to Java 21+ completely changed how we design our domain models. 🔹 The Old Way (Java 8) Remember writing 50 lines of code for a simple "User" class? We needed: • Private fields, Getters, and Setters. • Manual equals(), hashCode(), and toString(). • Complex inheritance for simple data variations. 🔹 The Modern Way (Java 21+) Now, Java is built for Data-Oriented Programming. Here are the features that changed the game: ✅ Records (The Boilerplate Killer): A single line "public record User(String name, int age) {}" gives you everything. It’s immutable, thread-safe, and crystal clear. ✅ Sealed Classes (Strict Hierarchy): Define exactly which classes can extend your model. This makes your domain logic much safer and easier to reason about. ✅ Pattern Matching: Combined with Records, the switch statement is now a powerful tool for deconstructing data structures directly. Why does this matter? Writing modern, clean code shows you are up-to-date with industry standards. It transforms your backend from a "spaghetti" of classes into a precise architectural model. #Java #BackendDevelopment #CleanCode #SoftwareArchitecture #Java21 #Programming #FullStack

Deep Dive into Java Fundamentals: Collections & Wrapper Classes ☕️ Today was all about strengthening the bedrock of my Java knowledge. I spent the day exploring the theoretical foundations of the Collection Interface, the Collections Utility Class, and Wrapper Classes. Understanding the "why" behind these concepts is just as important as the "how." Here’s a quick breakdown of my key takeaways: Collection vs. Collections: Clarified the distinction between the root interface for data structures and the utility class used for polymorphic algorithms (sorting, searching, etc.). Wrapper Classes: Diving into how Java wraps primitive data types into objects, enabling them to be used within the Collections Framework through Autoboxing and Unboxing. Data Structure Architecture: Looking at how different implementations (List, Set, Queue) handle data differently under the hood. Building a solid theoretical base is essential for writing efficient, scalable code. Back to the IDE to put these theories into practice! #Java #SoftwareDevelopment #JavaFullStack #CodingJourney #BackendDevelopment #ContinuousLearning