Hamza Abqar’s Post

Day 18 of Java : From Primitives to Proper Structure 🚀🧠 Today was a mix of small concepts… but each one added serious depth. 🔄 Autoboxing & Unboxing Java automatically converts: int → Integer (Autoboxing) Integer → int (Unboxing) No extra effort… Java handles it behind the scenes. 🎭 Abstract Classes (Deeper Understanding) Can’t create objects directly. But can define structure + some logic. They can have: • Abstract methods • Normal methods • Constructors • Static members Feels like a blueprint with some built-in logic. 📦 POJO Classes Simple. Clean. Useful. Just: • Private variables • Getters & Setters • Constructors Used everywhere to represent data. ⚠ One Public Class Rule Only one public class per file. And file name = class name. Because Java likes clarity, not confusion. Big realization today? Java is not just about writing code… it’s about structure, rules, and clean design. Day 18 and things are getting more practical every day 🚀🔥 Special thanks to Aditya Tandon Sir & Rohit Negi Sir🙌 #Java #CoreJava #OOP #Programming #LearningJourney #Developers #BuildInPublic

✨ DAY-41: 🌳 Dependency Injection Made Simple (with a Tree 🌱) Ever wondered how Dependency Injection in Java works? Here’s a simple way to visualize it 👇 Imagine a tree 🌳 (your main class – "TreeComponent") 👉 With Dependency Injection: The tree doesn’t create its own resources. Instead, it receives what it needs — like: • 💧 WaterService • 🌱 SoilService • ☀️ SunlightService Everything is clean, organized, and easy to manage ✅ 👉 Without Dependency Injection: The tree tries to handle everything on its own 😵 Roots get tangled, resources are tightly coupled, and maintenance becomes messy ❌ 💡 Key Takeaway: Dependency Injection = Loose Coupling + Better Flexibility + Easy Testing This is why frameworks like Spring make development powerful and scalable 🚀 Keep learning, keep growing! 🌿 #Java #DependencyInjection #SpringFramework #CleanCode #ProgrammingConcepts #BackendDevelopment #LearningJourney

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

🚀 Day 11: Scope & Memory – Mastering Variable Types in Java 🧠📍 Today’s focus was on understanding where data lives in a program—a crucial step toward writing efficient and predictable code. In Java, the way a variable is declared directly impacts its scope, lifetime, and memory allocation. Here’s how I broke it down: 🔹 1. Local Variables – Temporary Workers ⏱️ • Declared inside methods • Accessible only within that method • Created when the method starts, destroyed when it ends • ⚠️ Must be initialized before use (no default values) 🔹 2. Instance Variables – Object Properties 🏠 • Declared inside a class, outside methods • Require an object to access • Each object gets its own copy • Changes in one object do NOT affect another 🔹 3. Static Variables – Shared Data 🌐 • Declared with the static keyword • Belong to the class, not objects • Accessed using the class name (no object needed) • Only one copy exists, shared across all instances 💡 Key Takeaway: Variable scope is more than just visibility—it’s about memory management and data control. Knowing where and how variables exist helps in building optimized and scalable applications. Step by step, I’m strengthening my foundation in Java and moving closer to writing production-level code. 💻 #JavaFullStack #CoreJava #CodingJourney #VariableScope #MemoryManagement #Day11 #LearningInPublic

In my previous post, I introduced Classes and Objects — the foundation of 𝐎𝐛𝐣𝐞𝐜𝐭-𝐎𝐫𝐢𝐞𝐧𝐭𝐞𝐝 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 (𝐎𝐎𝐏) in Java. But a structure alone isn’t enough. A mobile phone isn’t useful just because it exists 📱 It becomes useful when it can make calls, send messages, or play music. That behavior is what methods bring to a class. ⚙️ 𝐌𝐞𝐭𝐡𝐨𝐝𝐬 A method is a 𝒃𝒍𝒐𝒄𝒌 𝒐𝒇 𝒄𝒐𝒅𝒆 that performs a specific task. Instead of writing the same logic again and again, we define it once inside a method and simply call it whenever needed. This makes programs: ✔ cleaner ✔ reusable ✔ easier to maintain 🔹 Common Types of Methods in Java • No parameters, no return value • With parameters, no return value • No parameters, with return value • With parameters, with return value Each type helps a program interact with data in different ways. I’ve attached simple examples for each type of method in the code snippet below 👇 Next, I’ll explore Constructors — how objects receive their initial values the moment they are created. #Java #CoreJava #OOP #Methods #Programming #LearningJourney #BuildInPublic

𝐯𝐚𝐫 𝐤𝐞𝐲𝐰𝐨𝐫𝐝 𝐢𝐧 𝐉𝐚𝐯𝐚 Introduced in Java 10, the var reserved type name is a game-changer for reducing boilerplate code—but it comes with specific "rules of the road." Is it a keyword? Technically, no! It’s a 𝐫𝐞𝐬𝐞𝐫𝐯𝐞𝐝 𝐭𝐲𝐩𝐞 𝐧𝐚𝐦𝐞 that uses 𝐓𝐲𝐩𝐞 𝐈𝐧𝐟𝐞𝐫𝐞𝐧𝐜𝐞 to automatically detect data types based on the context. Here is a quick cheat sheet on the Dos and Don'ts: 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐮𝐬𝐞 '𝐯𝐚𝐫': 𝐋𝐨𝐜𝐚𝐥 𝐕𝐚𝐫𝐢𝐚𝐛𝐥𝐞𝐬: Use it inside methods, blocks, or constructors. 𝐒𝐭𝐚𝐧𝐝𝐚𝐫𝐝 𝐃𝐚𝐭𝐚 𝐓𝐲𝐩𝐞𝐬: Works for int, double, String, etc., as long as an initializer is present. 𝐂𝐥𝐞𝐚𝐧𝐢𝐧𝐠 𝐮𝐩 𝐆𝐞𝐧𝐞𝐫𝐢𝐜𝐬: Turn long declarations into clean, readable lines. 𝐖𝐡𝐞𝐫𝐞 '𝐯𝐚𝐫' 𝐢𝐬 𝐍𝐎𝐓 𝐚𝐥𝐥𝐨𝐰𝐞𝐝: 𝐈𝐧𝐬𝐭𝐚𝐧𝐜𝐞 𝐕𝐚𝐫𝐢𝐚𝐛𝐥𝐞𝐬: You cannot use it for class-level fields. 𝐌𝐢𝐬𝐬𝐢𝐧𝐠 𝐈𝐧𝐢𝐭𝐢𝐚𝐥𝐢𝐳𝐞𝐫𝐬: You can't just declare var x;. The compiler needs to see the value immediately. 𝐍𝐮𝐥𝐥 𝐕𝐚𝐥𝐮𝐞𝐬: var x = null; won't work because the compiler can't infer a type from null. 𝐋𝐚𝐦𝐛𝐝𝐚𝐬: These need an explicit target type, so var is a no-go here. 𝐌𝐞𝐭𝐡𝐨𝐝 𝐒𝐩𝐞𝐜𝐬: It cannot be used for method parameters or return types.  𝐓𝐡𝐞 𝐆𝐨𝐥𝐝𝐞𝐧 𝐑𝐮𝐥𝐞: var is meant to improve 𝐫𝐞𝐚𝐝𝐚𝐛𝐢𝐥𝐢𝐭𝐲. If using it makes the code harder to understand, stick to explicit types! Special thanks to Syed Zabi Ulla Sir for the clear breakdown and guidance on these core Java concepts! #Java #Programming #CodingTips #BackendDevelopment #Java10 #SoftwareEngineering #CleanCode

🚀 Java Revision Journey – Day 21 Today I revised Streams in Java, one of the most powerful features introduced in Java 8 for handling data efficiently. 📝 Stream API Overview A Stream is a sequence of objects used to process data from collections, arrays, or I/O operations using a pipeline of operations. 📌 Key Uses: • Filtering data • Mapping/transforming data • Sorting and reducing • Writing clean and functional-style code 💻 Key Features • Not a data structure (works on data sources) • Does not modify original data • Supports method chaining (pipeline) • Uses lazy evaluation (intermediate ops) • Ends with terminal operations ⚙️ Types of Operations 1️⃣ Intermediate Operations (return Stream) • map() → transform • filter() → condition • sorted() → order • flatMap() → flatten • distinct() → unique • peek() → debug 2️⃣ Terminal Operations (produce result) • collect() → result • forEach() → iterate • reduce() → combine • count() → total • findFirst() → first • allMatch() → check all • anyMatch() → check any 💡 Benefits of Streams • Cleaner and more readable code • Supports parallel processing • Efficient data handling • Reduces boilerplate loops 📌 Streams are widely used in data processing, backend development, and handling large datasets efficiently. Continuing to strengthen my Java fundamentals step by step 💪 #Java #JavaLearning #Streams #Java8 #JavaDeveloper #BackendDevelopment #Programming #JavaRevisionJourney 🚀

🚀 Day 99 of My 100 Days LeetCode Challenge | Java Today’s problem was all about randomization and linked list traversal — a nice break from heavy DP and matrices. The challenge was to design a system that returns a random node’s value from a singly linked list, ensuring that every node has an equal probability of being chosen. Since linked lists don’t allow direct indexing, the key idea was to first determine the size of the list, and then generate a random index to fetch the corresponding node. This approach ensures uniform randomness while keeping the implementation simple and efficient. ✅ Problem Solved: Linked List Random Node ✔️ All test cases passed (8/8) ⏱️ Runtime: 11 ms 🧠 Approach: Linked List Traversal + Randomization 🧩 Key Learnings: ● Randomization problems require ensuring uniform probability distribution. ● Linked lists limit direct access, so traversal becomes essential. ● Precomputing size can simplify random selection. ● Sometimes simple approaches are the most effective. ● Understanding data structure limitations helps design better solutions. This problem highlighted how probability + data structures can come together in elegant ways. 🔥 Day 99 complete — sharpening my understanding of randomization and linked list behavior. #LeetCode #100DaysOfCode #Java #LinkedList #Randomization #Algorithms #ProblemSolving #DSA #CodingJourney #Consistency

Most people try to solve 3Sum using 3 nested loops. That solution works... but it's O(n³) and too slow. Today I learned how to reduce it to O(n²). 🚀 Day 81/365 — DSA Challenge Solved: 3Sum 🧠 The Idea Steps: 1. Sort the array 2. Fix one number 3. Use two pointers to find the other two numbers 4. Skip duplicates to avoid repeating triplets ⏱ Complexity Approach & Time 3 loops -> O(n³) Sort + Two pointers -> O(n²) Big improvement. 💡 What I learned today Whenever you see: • Sorted array • Pair sum • Triplet sum • Target sum Think: Sort + Two Pointers Day 81/365 complete. Still learning. Still coding. Code: https://lnkd.in/dad5sZfu #DSA #Java #LeetCode #LearningInPublic #100DaysOfCode #365Days365DSAProblems

𝗙𝗿𝗼𝗺 𝟱𝟬 𝗟𝗶𝗻𝗲𝘀 𝘁𝗼 𝟭: 𝗠𝘆 𝗝𝗼𝘂𝗿𝗻𝗲𝘆 𝘄𝗶𝘁𝗵 𝗝𝗮𝘃𝗮 𝗜𝗺𝗺𝘂𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆 🚀 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