Stefano Fago’s Post

Java Heap Dumps might contain sensitive information; with hprof-redact, you can easily remove it. Learn more in this blog post: https://lnkd.in/dn5CUtst

⚙️ Java ThreadLocal — The Most Underrated Feature in Multithreading When I first heard about ThreadLocal, I honestly ignored it. I thought it was “advanced stuff” that only frameworks used 😅 But once I understood what it actually does… it made so many concepts click instantly. 🧠 What is ThreadLocal? (Simple) It gives each thread its own copy of a variable. Not shared. Not synchronized. Not fighting for locks. Just clean, isolated data per thread. ✔️ Like giving every worker their own notepad instead of sharing one. 💡 Where it truly helps ✔️ Avoiding shared state issues ✔️ Storing per-request data (userId, correlationId) ✔️ Database connection contexts ✔️ Logging trace IDs ✔️ Removing unnecessary synchronization blocks Frameworks like Spring & Hibernate use it heavily under the hood. 🔧 Tiny Example private static ThreadLocal<String> name = ThreadLocal.withInitial(() -> "Unknown"); public static void main(String[] args) {  Runnable task = () -> {  name.set(Thread.currentThread().getName());  System.out.println(name.get());  };  new Thread(task).start();  new Thread(task).start(); } Each thread prints its own value, even though the variable is “shared”. Magic ✨ But actually… just smart engineering. 🌱 My takeaway ThreadLocal is the perfect reminder that multithreading isn’t about complicated code. It’s about isolated data + clean design. Once I understood this, my concurrency bugs reduced dramatically. ♻️ Save & Repost this if it helped you understand Thradlocal better. 🔗 Follow Aman Mishra for more Backend real-talk and production lessons. 𝗜’𝘃𝗲 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗱 𝘁𝗵𝗼𝘀𝗲 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗠𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗚𝘂𝗶𝗱𝗲, 𝗰𝗼𝘃𝗲𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗲𝘅𝗮𝗰𝘁 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝘁𝗵𝗮𝘁 𝗸𝗲𝗲𝗽 𝘀𝗵𝗼𝘄𝗶𝗻𝗴 𝘂𝗽. 𝗢𝗳𝗳𝗲𝗿𝗶𝗻𝗴 5𝟬% 𝗼𝗳𝗳 𝗳𝗼𝗿 𝗮 𝗹𝗶𝗺𝗶𝘁𝗲𝗱 𝘁𝗶𝗺𝗲!👇 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗴𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/giGubpBt 𝗨𝘀𝗲 𝗰𝗼𝗱𝗲 𝗝𝗔𝗩𝗔𝟱𝟬

🚀 Grouping Anagrams Using Java (HashMap and Streams) I recently practiced a classic problem: Group Anagrams. Two words are anagrams if they contain the same characters in a different order. 🧩 Problem Given an array of strings, group the anagrams together. 📥 Sample Input ["eat", "tea", "tan", "ate", "nat", "bat"] 📤 Output [[eat, tea, ate], [tan, nat], [bat]] ⚙️ Approach I Used 1️⃣ For each word, convert it to a character array. 2️⃣ Sort the characters of the word. 3️⃣ Use the sorted word as a key in a HashMap. 4️⃣ Add the original word to the list corresponding to that key. Words that are anagrams will produce the same sorted key, so they naturally group together. 🚀 Java Stream Version I also implemented a Java Streams approach using Collectors.groupingBy() to achieve the same result in a more functional style. 💻 I’ve added my Java solution in the comments below. Please let me know if there are any other approaches I could try. #Java #Streams #DataStructures #ProblemSolving #CodingPractice #HashMap

🔹 In Java, the Map hierarchy forms the foundation for key-value data structures: Map interface → HashMap, LinkedHashMap, TreeMap. Each has its own behavior and use-case in terms of ordering, and sorting. Many developers use HashMap daily, but do you know what happens behind the scenes? Let’s decode it 👇 HashMap Internals: Beyond Simple Key-Value Storage 1️⃣ Buckets & Nodes HashMap stores entries in an array of buckets. Each bucket contains nodes, and each node holds a key-value pair. 2️⃣ Hashing: The Core Mechanism Every key generates a hash code, which is used to compute the bucket index: index = (n - 1) & hash This ensures efficient data distribution and fast access. 3️⃣ Collision Handling When multiple keys map to the same bucket → collision occurs. Java handles collisions using: Linked List (Java < 8) Red-Black Tree (Java 8+, when bucket size > 8) 4️⃣ Insertion & Retrieval Insertion (put): hash → bucket → insert/update node Retrieval (get): hash → bucket → traverse nodes → match key 5️⃣ Resize & Load Factor Default capacity = 16, load factor = 0.75 When size > capacity × load factor, HashMap resizes (doubles capacity) to maintain performance 💡 Performance Insights Average case: O(1) ✅ Worst case: O(log n) after Java 8 ✅ Takeaway: A well-implemented hashCode() and equals() is key to fast, reliable HashMap performance. #Java #HashMap #DataStructures #Programming #SoftwareEngineering #CodingTips #DeveloperInsights

I've been exploring transactional data structures in Java over the past few weeks specifically, different ways to implement a transactional map with varying isolation levels and concurrency strategies. I ended up researching and building 6 implementations: Optimistic, Pessimistic, Read Uncommitted, Copy-on-Write, Flat Combined, and MVCC. Each one makes different tradeoffs around when locks are acquired, whether readers block writers, and how conflicts are handled. Write up and repository is linked below if you're curious GitHub: https://lnkd.in/dw9rTnCy Writeup: https://lnkd.in/dkU3Yfaw

🛑 A Quick Java Memory Guide Understanding the Java Memory Model is non-negotiable for writing performant, bug-free code. If you don’t know where your data lives, you don’t really know Java. Here is the breakdown of Stack vs Heap: 🧠 The Stack (LIFO - Last In, First Out) · What lives here: Primitive values (int, double) and references to objects (pointers). · Scope: Each thread has its own private stack. Variables exist only as long as their method is running. · Access Speed: Very fast. · Management: Automatically freed when methods finish. 🗄️ The Heap (The Common Storage) · What lives here: The actual objects themselves (all instances of classes). · Scope: Shared across the entire application. · Access Speed: Slower than the stack due to global access. · Management: Managed by the Garbage Collector (GC). 💡 The Golden Rule: The reference is on the Stack, but the object it points to is on the Heap. Map<String, String> myMap = new HashMap<>(); (Stack: myMap) --> (Heap: HashMap object) 👇 Q1: If I declare int id = 5; inside a method, where is this value stored? A1: Stack. It's a local primitive variable, so it lives directly in the stack frame. Q2: I created an array: int[] data = new int[100];. The array holds primitives. Is the data stored on the Stack or Heap? A2: Heap. The array itself is an object in Java. The reference data lives on the Stack, but the 100 integers are stored contiguously on the Heap. Q3: What happens to memory if I pass this object reference to another method? A3: A copy of the reference is passed (passed by value). Both methods now have a pointer (on their respective stacks) to the same single object on the Heap. ♻️ Repost if you found this helpful! Follow me for more Java wisdom. #Java #Programming #SoftwareEngineering #MemoryManagement #Coding

Java records are one of my favorite modern additions to the language because they make simple data modeling much cleaner and more explicit. They were introduced as a preview feature in Java 14 and became a standard feature in Java 16. In practice, they let us declare immutable, data‑carrier types in a single line, while the compiler generates constructor, accessors, `equals`, `hashCode`, and `toString` for us. This pushes us to design small, focused value objects instead of bloated POJOs. What I really like is how records express intent: when you see `record OrderId(String value) {}`, you immediately know it is a small, immutable value type. That clarity improves readability in large codebases and makes modeling domain concepts more straightforward. Immutability by default also helps with concurrency and functional style, since we do not need to worry about unexpected state changes spread across the code. The community reception has been largely positive. Many Java developers see records as long‑awaited “built‑in Lombok `@Data` / Kotlin data classes / Scala case classes” for the Java world. Framework support (for example for JSON DTOs, HTTP APIs, and projections) has grown fast, which encourages using records for DTOs, value objects, and other data‑centric parts of the application. This also aligns nicely with pattern matching improvements, making deconstruction of records more expressive and safe. Of course, records are not a silver bullet. They are a great default for immutable data, but they are not ideal for entities that require rich lifecycle behavior or heavy mutability, and changing record components is a breaking change for public APIs. Still, for most modern Java applications, using records for simple, immutable data structures feels like a clear step forward in clarity, safety, and conciseness. #java #javaprogramming #javarecords #softwareengineering #cleanarchitecture #immutability #backenddevelopment #codingbestpractices #dtos #domainmodeling

🔍 Deep Dive: Internals of HashMap in Java HashMap is one of the most widely used data structures in Java, but have you ever wondered how it works under the hood? Let’s break it down. 🧩 Core Structure - Internally, a HashMap is backed by an array of buckets. - Each bucket stores entries as Nodes (key, value, hash, next). - Before Java 8: collisions were handled using linked lists. - From Java 8 onwards: if collisions in a bucket exceed a threshold (default 8), the list is converted into a balanced Red-Black Tree for faster lookups. ⚙️ Hashing & Indexing - When you insert a key-value pair, the hashCode() of the key is computed. - This ensures uniform distribution of keys across buckets. 🚀 Performance - Average time complexity for put() and get() is O(1), assuming a good hash function. - Worst case (all keys collide into one bucket): - Before Java 8 → O(n) due to linked list traversal. - After Java 8 → O(log n) thanks to tree-based buckets. 🛠️ Key Design Choices - Load Factor (default 0.75): controls when the HashMap resizes. - Rehashing: when capacity × load factor is exceeded, the array doubles in size and entries are redistributed. - Null Handling: HashMap allows one null key and multiple null values. 💡 Takeaway HashMap is a brilliant example of balancing speed, memory efficiency, and collision handling. Its evolution from linked lists to trees highlights how Java adapts to real-world performance needs. What’s your favorite use case of HashMap in production systems? #Java #Collections #ScalableSystems

🚀 **Java Records – Writing Less Code, Doing More** One of the most useful features introduced in Java is **Records**. They help developers create immutable data classes with minimal boilerplate. 🔹 **What is a Java Record?** A *record* is a special type of class designed to hold immutable data. Java automatically generates common methods like: * `constructor` * `getters` * `toString()` * `equals()` * `hashCode()` 📌 **Example:** ```java public record User(String name, int age) {} ``` That's it! Java automatically creates: * `name()` and `age()` accessor methods * `equals()` and `hashCode()` * `toString()` * constructor 🔹 **Why use Records?** ✅ Less boilerplate code ✅ Immutable by default ✅ Cleaner and more readable models ✅ Perfect for DTOs and data carriers 🔹 **Behind the scenes** The above record behaves roughly like writing a full class with fields, constructor, getters, equals, hashCode, and toString — but with just one line. 💡 Records are a great example of how **Java continues to evolve to make developers more productive.** Are you using Records in your projects yet? #Java #JavaDeveloper #Programming #SoftwareDevelopment #Coding #Tech

💡 Most developers use "HashMap" every day… but very few understand what happens internally. Let’s break it down. When you write: "map.put("userId", user);" Java does 4 important things internally 👇 1️⃣ Hash Calculation Java calculates a hash using the key’s "hashCode()". Then it applies a bit operation to spread the hash: "hash = key.hashCode() ^ (hash >>> 16)" This improves distribution across buckets. --- 2️⃣ Bucket Index The index is calculated using: "index = (n - 1) & hash" This bit operation is faster than using "%". --- 3️⃣ Collision Handling If two keys map to the same bucket: • Before Java 8 → Linked List • Java 8+ → Balanced Red-Black Tree (after threshold) Why? Because lookup improves from: O(n) → O(log n) --- 4️⃣ Resize Operation When the load factor (0.75) is reached: The HashMap doubles its capacity and rehashes all entries. This is why sudden performance drops can happen during resizing. --- 💡 Takeaway Understanding these internals helps you: ✔ Design better keys ✔ Avoid performance issues ✔ Debug production problems faster Good developers know the API. Great developers understand what happens under the hood. #Java #HashMap #JavaInternals #SoftwareEngineering #BackendDevelopment