Java Stream API: Filtering and Mapping with Collectors

📝 Day 11/30 – LeetCode #26 (Remove Duplicates from Sorted Array) | Java A brute-force approach using extra space would work, but the constraint here is to modify the array in-place. Since the array is already sorted, duplicates always appear next to each other. Using a two-pointer approach, one pointer tracks the position of the last unique element while the other scans through the array. Whenever a new value is found, it is placed at the next valid position. This results in an O(n) solution with O(1) extra space. This problem reinforced how understanding input constraints can significantly simplify the solution. #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Consistency #LearningInPublic

1 Line of Code. Multiple Architectural Subsystems. Sub Seconds latency. We take the JVM for granted, but the journey of a simple System.out.println is more complex than we think. From security checks to Just-In-Time compilation, here is what’s actually happening under the hood when we run our life's first Java program, "Hello World!". We have seen this diagram thousands of times, but every time you go through its components, you will realize how much you don't know about how JVM works. #Java #JVM #SoftwareEngineering #helloworld

𝗗𝗮𝘆 𝟳/𝟮𝟬 — 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲🎯 Solved Longest Valid Parentheses ➤ Problem: Given a string of ‘(’ and ‘)’, determine the length of the longest well-formed (valid) parentheses substring. ➤ Approach: Used a clean and structured stack-based technique to identify valid boundaries efficiently. • Initialize the stack with -1 as the base index. • Push every '(' index onto the stack. • On encountering ')', pop to attempt a match. • If the stack becomes empty, push the current index as the new starting point. • Otherwise, compute the valid substring length using currentIndex − stackTop. Continuously update the maximum length. This ensures each character is processed in a single pass, maintaining optimal efficiency. #LeetCode #Java #DSA #TwoPointers #ArrayManipulation #ProblemSolving #20DaysChallenge #Consistency

50DaysOfStreams – Day 4 ✅ Day 4: Find the First Non-Repeated Character in a String 🧩 Problem: Given a string, find the first non-repeating character using Java Streams. Solution: String input = "swiss"; Optional<Character> result = input.chars() .mapToObj(c -> (char) c) .collect(Collectors.groupingBy( Function.identity(), LinkedHashMap::new, Collectors.counting() )) .entrySet() .stream() .filter(entry -> entry.getValue() == 1) .map(Map.Entry::getKey) .findFirst(); result.ifPresent(System.out::println); Output: w 🛠 Concepts Used: chars() mapToObj() groupingBy() LinkedHashMap (to maintain order) findFirst() See you tomorrow for Day 5 🔥 #Java #Streams #FunctionalProgramming #CodingChallenge #BackendDevelopment #LearningInPublic

𝗧𝗵𝗲 𝗝𝗮𝘃𝗮 𝗠𝗲𝗺𝗼𝗿𝘆 𝗠𝗼𝗱𝗲𝗹 𝗜𝘀 𝗪𝗵𝘆 𝗬𝗼𝘂𝗿 𝗖𝗼𝗱𝗲 “𝗦𝗼𝗺𝗲𝘁𝗶𝗺𝗲𝘀” 𝗕𝗿𝗲𝗮𝗸𝘀 If your multithreaded Java code: • works locally • fails randomly in prod • behaves differently under load The issue is often not logic. It’s the Java Memory Model (JMM). Here’s the uncomfortable truth 👇 In Java, visibility is not guaranteed unless you make it explicit. • One thread can update a variable • Another thread may still see the old value • Even if the code “looks correct” Why? Because CPU caches, reordering, and compiler optimizations are allowed by the JMM. That’s why: • volatile exists • synchronized exists • final has special guarantees • Atomic* classes matter They don’t just protect data — they create happens-before relationships. Without happens-before, your code has undefined behavior at runtime. Multithreading bugs are dangerous because: ❌ they don’t fail fast ❌ they don’t fail consistently ❌ logs don’t help much Concurrency works only when you respect the memory model — not just the syntax. #Java #JavaConcurrency #JavaMemoryModel #AdvancedJava #BackendEngineering #SystemDesign

📝 Day 16/30 – LeetCode #15 (3Sum) | Java This problem extends the two-sum pattern and introduces duplicate handling as the main challenge. A brute-force approach would require checking all triplets, resulting in O(n³) time complexity. By sorting the array and fixing one element, I applied a two-pointer approach on the remaining part of the array. Careful duplicate skipping ensured unique triplets while maintaining efficiency. This optimized the solution to O(n²) time. This problem reinforced how sorting combined with pointer logic can drastically reduce complexity. #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Consistency #LearningInPublic

📘 LeetCode Daily — Balanced Binary Tree Checked tree balance by recursively comparing left and right subtree heights at every node. The solution worked, but it clearly showed how repeated height calculations increase time complexity—an important reminder that correct logic isn’t always optimal logic. Solid recursion practice and a good lead-in to optimization. #LeetCode #BinaryTree #Recursion #DSA #Java

📝 Day 17/30 – LeetCode #238 (Product of Array Except Self) | Java The straightforward solution using division fails due to edge cases involving zeros and is explicitly disallowed. A brute-force approach would also be inefficient with O(n²) time complexity. By computing prefix products and suffix products, I was able to calculate the result for each index without using division. Each element in the output array represents the product of all numbers before and after it, resulting in an O(n) time solution with constant extra space. This problem highlighted how breaking a problem into directional passes can simplify complex constraints. #LeetCode #Java #DSA #Arrays #PrefixSum #ProblemSolving #Consistency #LearningInPublic

🚨 Parallel Streams are not always your friend 🚨 Parallel streams in Java look tempting. More cores. More threads. Faster execution… right? Not always. Recently, I ran into a production issue that reminded me why parallelStream() needs extra care. ⚠️ ArrayList + parallelStream() = risky ArrayList is not thread-safe. When multiple threads add elements at the same time, things can break. What I observed: ❌ Missing elements ❌ Inconsistent list size ❌ Occasional ArrayIndexOutOfBoundsException 🧠 What actually goes wrong (see diagram) Multiple threads read the same internal size All try to write at the same index One thread resizes the array while others keep writing 💥 Race condition → corrupted state → exception ✅ Better approaches Avoid shared mutable state: List<Result> results = items.parallelStream().map(this::process).toList(); Or simply: items.stream().map(this::process).toList(); 💡 Takeaway Parallel streams are powerful, but: ❌ Unsafe with ArrayList mutation ❌ Easy to misuse, hard to debug ❌ Not always faster Parallelism is a tool, not a default choice. Sometimes, boring and sequential wins. #Java #ParallelStreams #Concurrency #ArrayList #RaceCondition #Performance #LessonsLearned

#Day5 – Variables & Java Memory Architecture 🥶 I explored the structure of JRE (Java Runtime Environment) inside RAM and learned how it is divided into: -Code Segment -Heap Segment -Stack Segment -Static Segment #ZeroToFullStackJourney This clarity helped me to understand where variables live and how objects are managed internally. 🔹 Instance Variables ✔ Declared directly inside a class ✔ Stored in Heap Memory ✔ Belong to an object (instance) ✔ Automatically receive default values ✔ Require object creation for access 🔹 Local Variables ✔ Declared inside a method ✔ Stored in Stack Memory ✔ Do not get default values ✔ Must be initialized before usage ✔ Limited to method scope TAP Academy Harshit T #Java #JVM #HeapMemory #StackMemory #InstanceVariables #LocalVariables #ProgrammingFundamentals #MemoryArchitecture #DeveloperGrowth