Saragadam Divakar’s Post

🧵 ThreadLocal vs ScopedValue — What’s Changing in Modern Java 🚀 If you’ve been around Java for a while, you’ve probably used ThreadLocal — maybe to store user context, transaction info, or a request ID without passing it everywhere. It worked fine until virtual threads arrived. With millions of lightweight threads, ThreadLocal started showing its cracks: 💸 Memory-heavy (each thread carries its own copy) ⚠️ Error-prone (easy to forget to clear → memory leaks) 🔄 Mutable (any part of the code can change it anytime) 💡 ScopedValue — The Modern, Safer Alternative Scoped Values let you share immutable data across methods and threads — safely and efficiently. ✓ Immutable value ✓ Exists only within a defined “scope” ✓ Automatically cleaned up when scope ends ✓ Designed for virtual threads and structured concurrency 🔍 When Should You Use Each? ✅ Use ScopedValue when you need to share → User or request context (read-only) → Tracing or logging identifiers → Configuration or environment data → Context needed by child virtual threads ✅ Use ThreadLocal when you need → Thread-specific caches (like DateFormat or buffer) → Mutable data truly owned by a single thread 🧠 In Short ThreadLocal gave us flexibility. ScopedValue gives us discipline, safety, and scalability for the virtual-thread era. 📘 Introduced as preview in Java 20, finalized in Java 21, and now fully integrated with Structured Concurrency in Java 25. Time to modernize how we share context in Java — the future is scoped. ✨ #Java #ScopedValue #ThreadLocal #VirtualThreads #Java21 #Java25 #Programming #Developers

🔥 Tired of writing endless getters, setters, and constructors in Java? Say hello to Java Records — a modern feature that simplifies data modeling by removing all that boilerplate! 🚀 With Records, you can define a full data class in just one line — and Java automatically handles: ✅ equals() ✅ hashCode() ✅ toString() ✅ And immutability, by default 💪 The result? Developers report up to 40% smaller class sizes, leading to cleaner, faster, and more maintainable code. It’s all about writing less and doing more — focusing on logic instead of repetitive code. 💻 👉 Have you started using Java Records in your projects yet? Share your experience below ⬇️ #Java #Programming #javafullstack #JavaRecords #SoftwareDev #CodeEfficiency #CleanCode #DataModeling #JavaUpdates #DeveloperLife

LeetCode Question #199 — Binary Tree Right Side View Thrilled to share another Accepted Solution (100% Runtime 🚀) on LeetCode! This problem focuses on Binary Trees — specifically, how to capture the view of a tree from its right side 🌳➡️. I implemented a Modified Pre-Order Traversal (Root → Right → Left) in Java, ensuring that the first node at each level (from the right) gets recorded. 💡 Key Idea: Use recursion with a level tracker — when the current level equals the list size, it means we’re seeing the rightmost node for the first time. Here’s the performance snapshot: ⚙️ Runtime: 0 ms (Beats 100% of Java submissions) 💾 Memory: 42.4 MB Every problem like this sharpens my understanding of tree traversal patterns and depth-first search optimization. #LeetCode #Java #DataStructures #BinaryTree #ProblemSolving #CodingJourney #DSA #100PercentRuntime

How many times have you created a simple Java class just to hold some data (a DTO), and had to write a constructor, getters for every field, plus equals(), hashCode(), and toString()? This boilerplate code clutters our projects. Java 16 introduced a fantastic solution: Records. Records are a concise way to declare classes that are transparent carriers for immutable data. ➡️ The Old Way (Verbose POJO): // ~50 lines of code for a simple User class public final class User { private final String username; private final String email; // Constructor // Getters // equals() // hashCode() // toString() } ➡️ The Modern Way (Concise Record): public record User(String username, String email) {} That's it! One line. The Java compiler automatically generates all the boilerplate for you: private final fields, a public constructor, getters, and the equals(), hashCode(), and toString() methods. 💡 My Key Takeaway: Use Records whenever you need a simple, immutable data aggregate. It makes your code drastically cleaner and more readable, clearly stating the class's purpose. 📚 Dive Deeper: The official Java Enhancement Proposal (JEP 395) is the source of truth for Records: https://lnkd.in/gCVShCsR 🤔 What's your favorite modern Java feature that helps reduce boilerplate code? #Java #JEP #CleanCode #Productivity #Java17

Java 21: Record Patterns Make Code Cleaner Than Ever I’ve been using records for DTOs and value objects for a while now. They cut out a ton of boilerplate — but in Java 21, records got even better. You can now deconstruct a record directly in an if statement or switch expression. Before (manual unpacking): if (obj instanceof Point) { Point p = (Point) obj; int x = p.x(); int y = p.y(); System.out.println("x=" + x + ", y=" + y); } After (record pattern): if (obj instanceof Point(int x, int y)) { System.out.println("x=" + x + ", y=" + y); } No casts, no extra variables — just clean, direct access to the data. Why I like it: ✅ Fewer lines and fewer mistakes ✅ Great for pattern-based logic and DTOs ✅ Works beautifully with switch expressions Small change, big clarity. 👉 Have you tried record patterns yet? #Java #Java21 #Records #CleanCode #SoftwareEngineering #Refactoring

🚀 Java Level-Up Series #11: var Keyword — Local Variable Type Inference 💡 Introduced in Java 10, the var keyword lets you write cleaner, more concise code without sacrificing type safety. It doesn’t make Java dynamically typed it simply lets the compiler infer the variable type based on the assigned value. 🔍 What is var? var allows you to declare local variables without explicitly specifying the type the compiler automatically infers it from the initializer. 🧠 Still statically typed — the type is decided at compile time, not runtime. 💡 Why Use It? ✅ Less Boilerplate: No need to repeat long generic types (e.g., Map<String, List<Employee>> map = new HashMap<>();) ✅ Improves Readability: Focus on logic, not syntax ✅ Still Type-Safe: The compiler enforces type correctness ⚠️ When Not to Use var 🚫 When it reduces readability (e.g., var x = getData(); – what’s the type?) 🚫 For fields, method parameters, or return types (it only works for local variables) Sample Program :- #Java #Java10 #TypeInference #CleanCode #ProgrammingTips #DeveloperLife #JavaLevelUpSeries

Today, I explored the Stack class in Java — a data structure that follows the LIFO (Last In, First Out) principle. Here's what I practiced 👇 🧱 Key Stack Methods: push() → Adds an element to the top of the stack. pop() → Removes and returns the top element. peek() → Returns (but doesn’t remove) the top element. empty() → Checks if the stack is empty. search() → Returns the position of an element from the top (1-based index). 🧑💻 Output shows how each operation works in real-time — from adding elements to removing and peeking at the top! #Java #CollectionsFramework #Stack #CodingJourney #LearningJava #FullStackDeveloper

🔹 Day 32 – LeetCode Practice Problem: Reverse Words in a String (LeetCode #151) 📌 Problem Statement: Given an input string s, reverse the order of the words. A word is defined as a sequence of non-space characters separated by at least one space. Return the words in reverse order, joined by a single space — no extra spaces allowed. ✅ My Approach (Java): Used split() to separate words by spaces. Ignored extra spaces using \\s+ in regex. Reversed the array of words and joined them with a single space. Ensured no leading or trailing spaces appear in the final output. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(n) ⚡ Submission Results: Accepted ✅ Runtime: 12 ms (Beats 13.87%) Memory: 45.26 MB (Beats 16.33%) 💡 Reflection: This problem helped me refine my understanding of string manipulation and space handling in Java. Even though performance can be optimized, the logic was clean and easy to follow. #LeetCode #ProblemSolving #Java #DSA

Day 80 of #100DaysOfCode Solved Frequency Sort in Java 🔠 Approach Today's problem was to sort an array based on the frequency of its numbers. My initial solution was accepted, but it exposed a major efficiency gap! My strategy involved: Sorting the array first. Using nested loops to count the frequency of each number and store it in a HashMap. (Implied) Using the counts to perform the final custom sort. The core issue was the counting method: running a full loop inside another full loop to get the frequency. This quadratic $O(N^2)$ counting completely tanked the performance. ✅ Runtime: 29 ms (Beats 12.02%) ✅ Memory: 45.26 MB (Beats 5.86%) Another great lesson in algorithmic complexity! The difference between $O(N^2)$ and the optimal $O(N \log N)$ for this problem is massive. Time to refactor and implement the fast, single-pass $O(N)$ frequency count using getOrDefault! 💪 #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #Arrays #HashMap #Optimization #ProblemSolving