Refactor Temporary Fields with Extract Class

🚀 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

Day 70 - Next Greater Node Understanding how to find the next larger value for each node using stack optimization. Approach: • Convert linked list → array for easy indexing • Use a stack to track indices • Compare current value with stack top • Update results when a greater value is found Key Insight: Monotonic stack helps avoid unnecessary comparisons Time Complexity: O(n) Space Complexity: O(n) #Day70 #LeetCode #Java #CodingPractice #TechJourney #DSA #LinkedList

Day 57 of #100DaysOfLeetCode Today’s problem focused on finding the minimum distance between a target element and a given index in an array. I solved it using a simple and efficient approach: Traversed the array once Checked for target occurrences Calculated distance using absolute difference Maintained the minimum value throughout Runtime: 0 ms (Beats 100%) Optimized space usage Key takeaway: Even straightforward iteration can lead to highly optimized solutions when combined with the right logic. #LeetCode #Java #DataStructures #Algorithms #100DaysOfCode #CodingJourney #ProblemSolving

Day 9:- Conditional Statements A Journey with Frontlines EduTech (FLM) and Fayaz S Conditional statements 👉 if- else If -else is a conditional statement used to execute different blocks of code base on a condition. if statement:- -- It excute code only if the condition is true -- if the condition is true.it prints the message -- id false nothing happens Example:- { int age = 18; if(age >=18); System.out.println("he is major"); } If-else :- It executes one block if the condition is true and another block if it is false. Syntax:- if(condition){ System.out.println(block); } else{ // else block } if-else-if:- It is used multiple conditions are checking. Syntax:- if(condition) { // Code } else if(condition 2) { // Code } else { // Code } #Corejava #ConditionalStatements #java #frontlinesmediaedutech

🚨 Adding indexes blindly can hurt performance Most advice says: “Add index → query becomes fast” Not always true. 💥 Real case: Added index on a frequently updated column Result? 👉 Write performance dropped significantly Why? Indexes slow down INSERT/UPDATE operations ✅ Fix: - Indexed only read-heavy columns - Avoided over-indexing 💡 Takeaway: Indexes are powerful—but expensive. Use them where reads dominate. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering  #Microservices #JPA #RESTAPI  #DeveloperLife #CareerGrowth

Day 72 of #100DaysOfCode Problem: Convert Sorted Array to Height-Balanced BST Today I learned how to efficiently convert a sorted array into a balanced Binary Search Tree using Divide & Conquer. Key Insight: Pick the middle element as the root to maintain balance. Recursively build: Left subtree from left half Right subtree from right half This ensures: Optimal height Faster search operations ⏱ Time Complexity: O(n) 📦 Space Complexity: O(log n) Consistency is the real game changer #DSA #Java #BinaryTree #LeetCode #CodingJourney

Day 72/100 Completed ✅ 🚀 Solved LeetCode – Matrix Diagonal Sum (Java) ⚡ Implemented an efficient approach to calculate the sum of both primary and secondary diagonals of a square matrix in a single traversal. Avoided double-counting the center element by handling the odd-sized matrix case separately. 🧠 Key Learnings: • Efficient diagonal traversal in a matrix • Handling overlapping elements (center in odd n) • Writing optimal O(n) solutions instead of nested loops • Clean and concise index-based logic 💯 This problem improved my understanding of matrix patterns and how to optimize traversal by reducing unnecessary iterations. 🔗 Profile: https://lnkd.in/gaJmKdrA #leetcode #datastructures #algorithms #java #matrix #arrays #problemSolving #100DaysOfCode 🚀

🚀 Day 52 of #100DaysOfLeetCode Solved: Daily Temperatures (Monotonic Stack) Today’s focus was on understanding how to optimize from a brute-force O(n²) approach to an efficient O(n) solution using a stack. Key takeaways: Learned how to identify “next greater element” patterns Understood how monotonic stacks help avoid redundant work Practiced writing clean and optimized code Consistency is starting to pay off. Onto the next one. #DSA #Java #CodingJourney #LeetCode #ProblemSolving

Understanding the distinctions between @Component, @Service, and @Repository is crucial for writing clean and maintainable code in Spring. 🔹 @Component: This is a generic bean used for any Spring-managed component. 🔹 @Service: This annotation is specifically used for the business logic layer. 🔹 @Repository: This is designated for the database access layer (DAO). Grasping these annotations enhances code organization and clarity. #Java #SpringBoot #BackendDeveloper #Microservices #Coding

Day 73 - Merge K Sorted Lists Understanding how to merge multiple sorted lists using an optimized approach. Approach: • Use a priority queue (min-heap) • Add the head of each list • Extract the smallest node • Add its next node back to heap • Repeat until heap is empty Key Insight: Heap helps always pick the smallest element among k lists efficiently Time Complexity: O(N log k) Space Complexity: O(k) #Day73 #LeetCode #Java #CodingPractice #TechJourney #DSA #LinkedList