Java HashMap Implementation: hashCode, equals, and collision handling

Multithreading in Java finally clicked for me when I stopped memorizing it… and started visualizing it. 🧠 Here’s the simplest way to understand it: Imagine your application is doing only ONE task at a time. ➡️ Slow ➡️ Blocking ➡️ Poor performance Now introduce multithreading 👇 Multiple tasks run simultaneously: ✔ One thread handles API requests ✔ One processes data ✔ One writes logs Result? Faster and more efficient applications 🚀 But here’s what I learned the hard way: Multithreading is powerful… but dangerous if not handled properly. Common issues I faced: Race conditions Deadlocks Unexpected bugs What helped me: ✔ Proper synchronization ✔ Understanding thread lifecycle ✔ Using ExecutorService instead of manual threads Lesson: Multithreading is not just about speed — it’s about control and correctness. 💬 Have you faced any tricky bugs with multithreading? #Java #Multithreading #BackendDevelopment #SoftwareEngineering #Coding

Java Collections seem straightforward… until edge cases start showing up in real-world code. Here are a few more collection behaviors worth knowing 👇 • Null handling in collections HashMap allows one null key, Hashtable allows none — small difference, big impact. • contains() vs containsKey() Using the wrong one in Map can lead to incorrect checks. • Size vs Capacity (ArrayList) size() is actual elements, capacity is internal storage — confusion can lead to performance issues. • remove() ambiguity in List remove(1) removes by index, not value — use remove(Integer.valueOf(1)) for value. • equals() & hashCode() importance Custom objects in HashSet/HashMap need proper overrides or duplicates may appear. • Iteration order assumptions HashMap order is unpredictable — don’t rely on it unless using LinkedHashMap or TreeMap. • Immutable collections (List.of) They throw UnsupportedOperationException on modification — common runtime surprise. Small collection details like these often lead to big debugging sessions. #Java #BackendDevelopment #Programming

Day 9 – Java Streams Practice Series Today, I worked on finding the first repeated character in a string using Java Streams. Approach: Converted the string into a stream of characters Used Collectors.groupingBy() with LinkedHashMap to preserve insertion order Counted occurrences of each character Filtered characters with frequency greater than 1 Retrieved the first repeated character using findFirst() Key Learning: Using LinkedHashMap is important because it maintains the order of elements, which helps in identifying the first repeated character correctly. Why this matters: This problem helps strengthen concepts like stream transformations, grouping, counting, and order preservation in collections. Consistent practice is helping me build a deeper understanding of Java Streams and problem-solving. #Java #JavaStreams #CodingPractice #DataStructures #ProblemSolving #BackendDevelopment #100DaysOfCode

🚀 Day 8/30 — LeetCode Challenge Solved "Swap Nodes in Pairs" on LeetCode using Java. This problem focuses on "rearranging node connections", not just swapping values — making pointer handling critical. Used a dummy node approach to simplify edge cases and ensure smooth pair-wise swapping. ✅ Key takeaway: Linked list problems are less about logic and more about **precise pointer management** — one wrong link can break the entire structure. #LeetCode #Java #LinkedList #DataStructures #ProblemSolving #Consistency

Generics in Java always felt simple… until wildcards came in. Recently spent some time understanding how ?, ? extends, and ? super actually work. It looks small, but it completely changes how you design flexible and type-safe code. So I made a short PPT to break it down in a way that’s easier to understand. No heavy theory, just trying to make the concept clear. This is one of those topics that feels confusing at first, but once it clicks, it actually makes a lot of sense. Still exploring Java deeper, one concept at a time… let’s see where it goes. #Java #Generics

Day 5 - Java Set Interface internal working !! 👉 Set is a collection that cannot contain duplicate values and un-ordered collection and internally using HashMap. 👉 Set has three implementations HashSet, TreeSet and LinkedHashSet. 👉 add(E element) When we add a value, internally adds a value in 'map' by calling put(E, o); E - Key & o - dummy Object #java #Backend #coding #learning #springboot #developer

Every Java object starts with a Constructor — and today in class I learned exactly how it works! 🔧 A Constructor is a special method that is automatically called when an object is created. It has the same name as the class and has no return type — not even void. Its main job is to initialize the object's values at the time of creation. #JavaProgramming #Constructor #OOP #ObjectOrientedProgramming #CodeNewbie #LearnToCode #SoftwareDevelopment #JavaBeginners

Java Streams Series – Day 7 Today I explored an efficient approach to check whether a string is a palindrome using Java Streams. Instead of using traditional loops or reversing the string, this approach applies a functional style to compare characters from both ends, progressing toward the center. By iterating through only half of the string, it maintains optimal performance while keeping the implementation concise and readable. This reinforces how Java Streams can help write clean, declarative, and efficient code for common problems. #Java #JavaStreams #CleanCode #FunctionalProgramming #100DaysOfCode

Day 92 - LeetCode Journey Solved LeetCode 143: Reorder List in Java ✅ This problem looks tricky at first, but once you break it into steps, it becomes clean and elegant. The idea is simple: 1️⃣ Find the middle of the list (slow-fast pointers) 2️⃣ Reverse the second half 3️⃣ Merge both halves alternately That’s it. Three steps, one solid solution. Key takeaways: • Mastering slow & fast pointer technique • In-place reversal of linked list • Merging two lists efficiently • Breaking complex problems into smaller parts ✅ All test cases passed ⚡ O(n) time and O(1) space Problems like this build real confidence in linked lists 💯 #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

Most Java devs write code every day without knowing what happens beneath it. This one diagram changed how I think about Java forever. 👇 Here's the complete internal working of the JVM + Garbage Collector — explained visually: 🔵 Class Loader → Loads your .class bytecode. Verifies it. Prepares it. Resolves it. All before execution begins. 🟣 Method Area → Stores class-level data, static variables & method code. Shared across all threads. 🟠 Heap (The heart of GC) ↳ Young Gen (Eden + Survivor) → New objects born here ↳ Old Gen → Long-lived objects promoted here ↳ Metaspace → Class metadata (replaced PermGen in Java 8+) 🟢 JVM Stack → Every thread gets its own stack. Every method call = one Stack Frame. 🔴 Execution Engine ↳ Interpreter → reads bytecode (slow start) ↳ JIT Compiler → converts hot code to native (blazing fast) ↳ Garbage Collector → watches Heap, frees dead objects automatically ♻️ Repost to help a Java developer in your network. Someone needs this today. #Java #JVM #GarbageCollection #JavaDeveloper #BackendDevelopment #SpringBoot #InterviewPrep #JavaInterview #Microservices #SoftwareEngineering #Coding #Programming