Java HashMap Internals: Understanding Hashing and Resizing

Day 1/30 – LeetCode #1 (Two Sum) | Java Kicked off my 30-day LeetCode challenge with Two Sum, focusing on writing a clean and efficient Java solution. My initial approach was the brute-force method using two nested loops to check all index pairs. While this approach is straightforward and logically correct, it runs in O(n²) time, which becomes inefficient as the input size grows. This made me pause and rethink the solution from a performance standpoint. The key realization was that the problem isn’t about comparing every pair, but about tracking previously seen values. By using a HashMap<Integer, Integer> to store each number along with its index, I was able to check whether the required complement already exists in constant time. This reduced the overall time complexity to O(n) while maintaining O(n) space complexity. What this problem reinforced for me: Optimizing code often starts with identifying unnecessary repeated work Java collections like HashMap are powerful when used intentionally A correct solution isn’t complete unless it’s also efficient This was a good reminder that strong problem-solving comes from understanding time–space tradeoffs, not just passing test cases. Looking forward to building consistency over the next 30 days. #LeetCode #Java #DSA #ProblemSolving #LearningInPublic #Consistency

Most Java devs know 𝐒𝐭𝐫𝐢𝐧𝐠 𝐢𝐬 “𝐢𝐦𝐦𝐮𝐭𝐚𝐛𝐥𝐞”. But very few understand what that REALLY means… and how JVM treats it internally 👇 When you write: 𝑺𝒕𝒓𝒊𝒏𝒈 𝒔 = "𝑯𝒆𝒍𝒍𝒐"; You’re not just creating an object. You’re using something called the String Pool in the JVM. 🔹 What is String Pool? The JVM stores commonly used string values in a special memory area. So instead of creating new objects, it reuses existing ones to: ✔ Save memory ✔ Improve performance ✔ Avoid duplicate strings Example: 𝑺𝒕𝒓𝒊𝒏𝒈 𝒂 = "𝑱𝒂𝒗𝒂"; 𝑺𝒕𝒓𝒊𝒏𝒈 𝒃 = "𝑱𝒂𝒗𝒂"; Both reference the same object , But… 𝑺𝒕𝒓𝒊𝒏𝒈 𝒄 = 𝒏𝒆𝒘 𝑺𝒕𝒓𝒊𝒏𝒈("𝑱𝒂𝒗𝒂"); This forces JVM to create a new object in Heap — no reuse, extra memory. 🔥 𝐖𝐡𝐲 𝐈𝐦𝐦𝐮𝐭𝐚𝐛𝐢𝐥𝐢𝐭𝐲 𝐌𝐚𝐭𝐭𝐞𝐫𝐬 Because strings are immutable: ✔ They are thread-safe ✔ They can be cached safely ✔ They’re stable for keys in HashMap ✔ Safe for security-sensitive code ⚠️ Misuse = Performance Issues ❌ Building strings in loops with + creates tons of garbage ✔ Use StringBuilder instead If you want to really understand Java — not just syntax — follow along. I’m posting daily JVM + core Java deep dives 😊 #java #jvm #stringpool #developers #blogs

Annotations in Java Do vs Don’t ⚠️ Annotations are powerful. But they are often misunderstood. This Do vs Don’t cheat sheet summarizes what actually works in real Java systems 👇 ✅ DO Use Annotations Correctly: • Use annotations to express intent • Treat annotations as hints to frameworks, not guarantees • Combine annotations with explicit logic • Understand where and when annotations apply • Keep validation and rules close to the code Annotations help frameworks help you. ❌ DON’T Common Mistakes: • Don’t assume annotations enforce correctness • Don’t rely on annotations for business rules • Don’t assume they always work at runtime • Don’t treat annotations as a replacement for testing • Don’t ignore execution paths and configuration Annotations can be bypassed more easily than most teams realize. 🧠 Simple mental model Annotations answer: 👉 How should the framework treat this code? They do not answer: 👉 Is this code correct? 🔑 Golden rule Annotations support correctness. They do not enforce it. Correctness still comes from: • clear boundaries • explicit validation • careful design • predictable control flow Annotations reduce boilerplate. They improve readability. But responsibility still lives in code, not metadata. 👇 Which annotation do you see most misunderstood in real projects? #Java #JavaIn2026 #CleanCode #SoftwareEngineering #BackendDevelopment

Most confusing fundamental concepts in Java: == vs equals(). Key Learnings: • == operator  - Compares references for objects (memory location)  - Compares values for primitives  - For objects, it checks whether both references point to the same object • equals() method  - Defined in Object class  - Default behavior compares references  - Many classes like String, Integer, wrapper classes, and collections override equals() to compare actual values/content • Why this matters  - Two objects can be different in memory but still be logically equal  - Example:   new String("Java") == new String("Java") → false   new String("Java").equals("Java") → true • Important rule  - If a class overrides equals(), it should also override hashCode()  - This is critical for correct behavior in HashMap and HashSet Final takeaway: Use == for primitive comparison. Use equals() for object content comparison. Always know which equals() implementation is being executed. Strong fundamentals make debugging easier and code more reliable. #Java #CoreJava #Equals #HashCode #Programming #SoftwareEngineering #LearningJourney #100DaysOfLearning

📘 Day 9 – Advanced Java: Inheritance & Object-Oriented Hierarchy Inheritance in Java is more than code reuse — it’s about designing scalable, maintainable, and extensible systems. 🔍 Today’s deep dive included: ✅ Why inheritance matters in enterprise applications ✅ IS-A vs HAS-A relationships (real-world modeling) ✅ Constructor execution order in the JVM ✅ Types of inheritance in Java (single, multilevel, hierarchical) ✅ Method overriding rules & covariant return types ✅ How JVM selects methods at runtime (v-table concept) 💡 Key Insight: A strong understanding of inheritance is the foundation for mastering polymorphism, frameworks like Spring & Hibernate, and clean architecture design. 🚀 Next up: Day 10 – Polymorphism (Compile-time vs Runtime) #Java #AdvancedJava #OOP #Inheritance #JavaDeveloper #Programming #SoftwareEngineering #LearningJourney #PabitraTechnology

🧠 Java Lesson from Production — Log Less, Log Smarter Early in my career, I believed more logs meant better observability. Production taught me the opposite. Too many logs usually result in: • Huge log volumes • Important signals getting buried • Higher storage and processing costs Example: noisy logging 👇 log.info ("User request received: {}", request); log.info ("Calling service A"); log.info ("Service A response: {}", response); This explains what the code is doing — but not what the system is experiencing. A better approach is logging at system boundaries: log.info ("CreateUser request started, userId={}", userId); try {   createUser(user); } catch (Exception e) {   log.error("CreateUser failed, userId={}", userId, e);   throw e; } Now logs answer real questions: • What started? • What failed? • Why did it fail? Production lesson: Logs are for understanding failures, not narrating code execution. Happy Coding !!! #Java #SpringBoot #BackendEngineering #Microservices #ProductionLessons

Java☕ — HashMap vs ConcurrentHashMap clarified 🔥 Earlier, I thought: “HashMap works fine… why another map?” Then I learned about multi-threading. #Java_Code Map<String, Integer> map = new HashMap<>(); ❌ Not thread-safe #Java_Code Map<String, Integer> map = new ConcurrentHashMap<>(); ✅ Thread-safe The difference is not syntax — it’s behavior. 📌HashMap 📝Faster 📝Unsafe in multi-threading 📌ConcurrentHashMap 📝Thread-safe 📝Uses bucket-level locking 📝No ConcurrentModificationException Big realization for me: Thread safety is not optional in real applications. If multiple threads touch shared data — design matters. #Java #ConcurrentHashMap #Multithreading #BackendDevelopment #LearningJava

☕ 𝗛𝗼𝘄 𝗝𝗮𝘃𝗮 𝗖𝗼𝗺𝗽𝗶𝗹𝗲𝘀 𝗦𝗼𝘂𝗿𝗰𝗲 𝗖𝗼𝗱𝗲 𝘁𝗼 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 Ever wondered what happens after you write Java code? Let’s break it down step by step 👇 🧑💻 𝗔𝘁 𝗖𝗼𝗺𝗽𝗶𝗹𝗲 𝗧𝗶𝗺𝗲 1️⃣ 𝗪𝗿𝗶𝘁𝗲 𝗖𝗼𝗱𝗲 You write Java code in a .java file using classes, methods, and objects. 2️⃣ 𝗟𝗲𝘅𝗶𝗰𝗮𝗹 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 The compiler (javac) scans the source and converts it into tokens ➡️ keywords, identifiers, literals, symbols. 3️⃣ 𝗦𝘆𝗻𝘁𝗮𝘅 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 Checks if the code follows Java grammar rules and builds a Parse Tree 🌳 4️⃣ 𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 Validates data types, variable declarations, and rule correctness ➡️ catches type mismatches and invalid references. 5️⃣ 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 Generates platform-independent bytecode stored in a .class file. 6️⃣ 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻 Applies basic optimizations to improve execution efficiency ⚡ ⚙️ 𝗔𝘁 𝗥𝘂𝗻𝘁𝗶𝗺𝗲 (𝗜𝗻𝘀𝗶𝗱𝗲 𝘁𝗵𝗲 𝗝𝗩𝗠) 7️⃣ 𝗖𝗹𝗮𝘀𝘀 𝗟𝗼𝗮𝗱𝗲𝗿 Loads .class files into memory. 8️⃣ 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 𝗩𝗲𝗿𝗶𝗳𝗶𝗲𝗿 Ensures safety and prevents illegal or malicious operations 🔒 9️⃣ 𝗜𝗻𝘁𝗲𝗿𝗽𝗿𝗲𝘁𝗲𝗿 / 𝗝𝗜𝗧 𝗖𝗼𝗺𝗽𝗶𝗹𝗲𝗿 Converts bytecode into native machine code ➡️ JIT boosts performance by compiling hot code paths 🚀 ✅ 𝗧𝗵𝗲 𝗥𝗲𝘀𝘂𝗹𝘁 ✔️ Platform independence ✔️ Secure execution ✔️ Automatic memory management ✔️ Runtime performance optimization 𝗪𝗿𝗶𝘁𝗲 𝗼𝗻𝗰𝗲, 𝗿𝘂𝗻 𝗮𝗻𝘆𝘄𝗵𝗲𝗿𝗲 isn’t magic — it’s the JVM at work ☕💡 Which part of the Java compilation process did you first learn about? 👇 #Java #JVM #Bytecode #JavaInternals #SoftwareEngineering #BackendDevelopment

📘 Today I Learned: Why HashSet Has No Index in Java Today I learned something interesting about HashSet in Java. When we write: HashSet<Integer> set = new HashSet<>(); it looks simple, but internally Java does something important. 🔍 What Happens Internally? HashSet is backed by a HashMap. That means each element you add to a HashSet is actually stored as a key inside a HashMap, with a dummy value. So conceptually, it becomes something like: HashMap<Integer, Object> map; 🗂 How Elements Are Stored Elements are not stored in order and not stored by index. Instead, each element: Generates a hashCode() Gets placed into a bucket based on that hash Example (simplified): Bucket 2 → 2 Bucket 10 → 10 Bucket 15 → 15 Each bucket can hold one or more elements if collisions happen. ❓ Why There Is No Index Because elements live in hash-based buckets, not in sequential positions like: 0, 1, 2, 3... So operations like: set.get(0); don’t make sense for a HashSet. 🔁 How We Access Elements Instead We use iteration: for (int x : set) { System.out.println(x); } This gives sequential access, without exposing how data is stored internally. 🌱 Key Learning HashSet trades index-based access for fast lookups and clean abstraction using hashing. If we need: Index → List Insertion order → LinkedHashSet Sorted order → TreeSet Learning these small internal details really helps in understanding why Java collections behave the way they do, not just how to use them. #Java #LearningInPublic #JavaCollections #HashSet #BackendDevelopment #SoftwareEngineering