Java Method References vs Lambdas Cleaner Alternative

🔥 Day 61/100 — #100DaysDSAChallenge Today I worked on a classic problem: Implement Queue using Stacks. 💡 The key idea We use two stacks: 1. One stack for input (push operations) 2. One stack for output (pop/peek operations) When we need to remove an element: If the output stack is empty, we move all elements from input stack to output stack This reverses the order Now the oldest element is on top and ready to be removed ⚙️ Complexity ⏱️ Amortized Time: O(1) 💾 Space: O(n) 🧠 What I learned today Today’s lesson was about reversing data flow to achieve a different behavior. #Java #DSA #Stack #Queue #LeetCode #ConsistencyCurve

🚀 Day 7 – Exception Handling: More Than Just try-catch Today I focused on how exception handling should be used in real applications—not just syntax. try { int result = 10 / 0; } catch (Exception e) { System.out.println("Error occurred"); } This works… but is it the right approach? 🤔 👉 Catching generic "Exception" is usually a bad practice 💡 Better approach: ✔ Catch specific exceptions (like "ArithmeticException") ✔ Helps in debugging and handling issues more precisely ⚠️ Another insight: Avoid using exceptions for normal flow control Example: if (value != null) { value.process(); } 👉 is better than relying on exceptions 💡 Key takeaway: - Exceptions are for unexpected scenarios, not regular logic - Proper handling improves readability, debugging, and reliability Small changes here can make a big difference in production code. #Java #BackendDevelopment #ExceptionHandling #CleanCode #LearningInPublic

👉Arrays vs ArrayLists. Looks similar. But difference matters! Many people start with Arrays. Fixed size. Simple syntax. Everything feels under control. Then comes ArrayList. Dynamic size. Easy to use. No need to worry about capacity. Sounds like ArrayList is better, right? Not always. That’s where the realisation comes in. 👉Arrays are faster. They use fixed memory. Better when size is known. 👉ArrayLists are flexible. They resize automatically. But come with slight overhead. Same data. Different behavior. And that difference shows up in performance. The real takeaway is simple. ✨Use Arrays when size is fixed and performance matters. ✨Use ArrayList when flexibility is needed. Don’t just learn syntax — understand use cases. 👉Because in the end, choosing the right structure > writing more code. 👉 When do you prefer Arrays over ArrayList? #DSA #Java #CodingJourney #SoftwareDevelopment #CareerGrowth

I used to run parallel tasks using ExecutorService… But something always felt incomplete 🤔 Yes, tasks were running concurrently… But how do you know when ALL of them are done? That’s when I discovered the combo: 👉 ExecutorService + CountDownLatch And honestly, this is where multithreading started to make real sense. ⸻ 💡 The idea is simple: • ExecutorService → runs tasks in parallel ⚡ • CountDownLatch → makes sure you wait for all of them ⏳ ⸻ 🔥 Real flow: 1. Create a thread pool using ExecutorService 2. Initialize CountDownLatch with count = number of tasks 3. Submit tasks 4. Each task calls countDown() when done 5. Main thread calls await() 👉 Boom — main thread continues only when everything is finished ✅ ⸻ 🧠 Why this matters: ✔ Clean coordination between threads ✔ No messy shared variables ✔ Perfect for parallel API calls, batch processing, etc. ⸻ Before this, I was just “running threads” Now I’m actually controlling concurrency That’s a big difference. ⸻ If you’re learning backend or system design, this combo is 🔥 Simple tools… powerful impact. Have you used this pattern in real projects? 👇 #Java #Multithreading #ExecutorService #CountDownLatch #BackendDevelopment #LearningInPublic

Day 19 of #Leetcode150DaysChallenge Today’s problem: 237. Delete Node in a Linked List Instead of deleting the node directly, we copy the value of the next node into the current node and then skip the next node. This way, the current node effectively becomes the next node, and the original next node gets removed. #LeetCode #DataStructures #Java #ProblemSolving

Have you ever debugged a production issue where logs show the same error everywhere… but you still can’t figure out what actually failed? I used to make this mistake a lot — catch exception → log error → throw again Service logs Repository logs Controller logs Same exception 3–4 times. Just noise. Then I changed one simple thing: don’t log where you’re just throwing the exception. Now I follow this: Service/Repository → just throw or wrap the exception Log only once at the boundary (API / consumer) Always add context We often don’t pay much attention to logging, but it plays a crucial role when debugging a system. You need clarity on where to log, what to log, and where not to. Now instead of messy logs, I get one clear error log with full context. Debugging feels less like guessing and more like tracing a story. Less logs. Better logs. That’s the real strategy. #BackendDevelopment #Microservices #SystemDesign #Java #SpringBoot #Logging #SoftwareEngineering #CleanCode

🚀 Developed a basic REST API using Spring Boot to handle HTTP requests and responses. 🔹 What I implemented: Created a REST Controller using @RestController Used @RequestMapping to define base URL (/api) Built a GET API using @GetMapping("/student") 🔹 API Endpoint: http://localhost:8080/api/student 🔹 Output: "Student data" 🔹 Key Learnings: How Spring Boot handles HTTP requests Understanding request → controller → response flow Basics of REST API development Excited to move next into POST APIs and sending real data using @RequestBody 🔥 #SpringBoot #Java #BackendDevelopment #LearningJourney #CSE 

🚀 Day 26 – Lambda Performance: Clean Code vs High Performance Lambdas made Java expressive and concise — but not always free. As architects, we must balance readability with performance, especially in high-throughput systems. Here’s what you should know before using lambdas everywhere: 🔹 1. Lambdas Are Not Always Zero-Cost Stateless lambdas → optimized & reused Stateful lambdas → may create new objects ➡ Can impact memory & GC under heavy load. 🔹 2. Beware in Tight Loops list.forEach(x -> process(x)); ➡ Looks clean, but traditional loops can be faster in hot paths ➡ Avoid lambdas in performance-critical loops. 🔹 3. Autoboxing Overhead Stream<Integer> vs IntStream ➡ Boxing/unboxing adds CPU + memory overhead ➡ Prefer primitive streams (IntStream, LongStream). 🔹 4. Streams vs Loops – Choose Wisely Streams → readable, declarative Loops → better control & performance ➡ Use streams for clarity, loops for critical performance paths. 🔹 5. Parallel Streams Are Not Magic list.parallelStream() ➡ Works well for large, CPU-bound tasks ❌ Can degrade performance for: - Small datasets - I/O operations - Shared resources ➡ Always benchmark before using. 🔹 6. Method References Are Faster & Cleaner list.forEach(System.out::println); ➡ Slightly better readability and sometimes better optimization. 🔹 7. Avoid Complex Lambda Chains stream().filter().map().flatMap().reduce() ➡ Hard to debug ➡ Can impact performance ➡ Break into smaller steps when needed. 🔹 8. JVM Optimizations Help — But Don’t Rely Blindly JIT can optimize lambdas heavily, but: ➡ Not guaranteed in all scenarios ➡ Performance depends on usage patterns 🔥 Architect’s Takeaway Lambdas are powerful — but use them intentionally. ✔ Prefer clarity in most cases ✔ Optimize only where needed ✔ Measure before optimizing Because in real systems: 👉 Readable code wins… until performance becomes critical. 💬 Where do you draw the line between readability and performance when using lambdas? #100DaysOfJavaArchitecture #Java #Lambdas #Performance #JavaPerformance #SystemDesign #CleanCode #TechLeadership

Day 77/100 Completed ✅ 🚀 Solved LeetCode – Search a 2D Matrix II (Java) ⚡ Implemented an efficient approach by starting from the top-right corner of the matrix and eliminating rows or columns based on comparison with the target. This reduces the search space at every step, achieving O(m + n) time complexity. 🧠 Key Learnings: • Smart traversal in a sorted 2D matrix • Eliminating search space using row & column properties • Moving left (col--) when value is greater • Moving down (row++) when value is smaller • Better than brute-force (O(m × n)) approach 💯 This problem improved my understanding of matrix traversal strategies and how to optimize searching using sorted properties. 🔗 Profile: https://lnkd.in/gaJmKdrA #leetcode #datastructures #algorithms #java #matrix #problemSolving #optimization #arrays #100DaysOfCode 🚀

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝗧𝗶𝗽 - 𝐌𝐢𝐬𝐬𝐢𝐧𝐠 𝐕𝐚𝐥𝐮𝐞𝐬 🔥 💎 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝘃𝘀 𝗢𝗽𝘁𝗶𝗼𝗻𝗮𝗹 💡 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 are designed for truly exceptional, unexpected errors that occur outside normal program flow. When thrown, they propagate up the call stack until caught by an appropriate handler. ✔ Exceptions should never be used for routine control flow due to significant performance costs from stack unwinding and object creation. 🔥 𝗢𝗽𝘁𝗶𝗼𝗻𝗮𝗹 provides an explicit alternative for representing absence of a value. It wraps a value that may or may not be present, making null-safe code more expressive and functional. ✔ Optional is ideal for modeling "value might be missing" scenarios and works seamlessly with streams and lambda expressions. ✅ 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗘𝗮𝗰𝗵 ◾ 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀: Rare failures like I/O errors, database connection issues, or invalid business transactions. ◾ 𝗢𝗽𝘁𝗶𝗼𝗻𝗮𝗹: Expected absence like cache misses, lookup results not found, or optional configuration values. ◾ 𝗛𝘆𝗯𝗿𝗶𝗱 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: Use both strategically for optimal code clarity and performance. 🤔 Which approach do you prefer for handling missing values? #java #springboot #programming #softwareengineering #softwaredevelopment