Java Switch Expression vs Traditional Switch Statement

Leetcode Problem || Complement of Base 10 Integer(1009) 🚀 The Bitwise Complement problem using Java. 🔹 Idea: The complement of a number means flipping all bits in its binary representation (0 → 1 and 1 → 0). Instead of manually converting the number to binary, I used a bit manipulation trick: 1️⃣ Find the highest set bit using Integer.highestOneBit(n) 2️⃣ Create a mask with all bits set to 1 up to that position 3️⃣ Use XOR (^) with the mask to flip the bits #LeetCode #Java #BitManipulation #CodingPractice #ProblemSolving #SoftwareDevelopment

I used to think equals() and == in Java were basically the same. They’re not. == checks if two references point to the same memory location. equals() checks if two objects are logically equal. That difference looks small. Until your HashMap stops working properly. In Java, if you override equals(), you must also override hashCode(). Because collections like HashMap use hashCode() first to find the bucket, and then equals() to confirm the match. Forget one of them… and your object becomes “invisible” inside the map. One small contract. One big lesson. #Java #BackendDevelopment #SoftwareEngineering #Programming

🧵 Mastering Thread Lifecycle & State Transitions in Java 🚀 Understanding thread states is crucial for writing efficient, bug-free concurrent applications. Here's a quick breakdown: 6 Thread States in Java: 1️⃣ NEW – Thread created but not started 2️⃣ RUNNABLE – Executing or ready to execute 3️⃣ BLOCKED – Waiting for monitor lock 4️⃣ WAITING – Waiting indefinitely for another thread 5️⃣ TIMED_WAITING – Waiting for a specified time 6️⃣ TERMINATED – Execution completed Key Transitions: • start() → NEW → RUNNABLE • sleep()/wait(timeout) → RUNNABLE → TIMED_WAITING • wait() → RUNNABLE → WAITING • I/O or lock acquisition → RUNNABLE → BLOCKED • notify()/notifyAll() → WAITING → RUNNABLE Q1: What's the difference between BLOCKED and WAITING states? A: BLOCKED occurs when a thread is waiting to acquire a monitor lock. WAITING happens when a thread waits indefinitely for another thread to perform a specific action (like notify() or join()). BLOCKED is lock-specific, WAITING is action-specific. Q2: Can a thread transition directly from WAITING to RUNNABLE without entering BLOCKED? A: Yes! When notify()/notifyAll() is called, the waiting thread moves directly to RUNNABLE state. It only enters BLOCKED if it needs to reacquire a lock that's held by another thread. Q3: How does yield() affect thread state? A: yield() is a hint to the scheduler that current thread is willing to pause its execution. The thread remains in RUNNABLE state and may immediately resume running—no state change occurs. It's just a suggestion, not guaranteed behavior. 💡 Pro Tip: Use jstack or visualvm to monitor thread states in production applications—invaluable for debugging deadlocks and performance issues! What threading challenges have you faced recently? 👇 #Java #Multithreading #Concurrency #Programming #SoftwareEngineering

Why Java isn't just "Write Once, Run Anywhere"—It’s "Check Once, Execute Twice." Most developers know that Java has a Compile-time and a Runtime. But internally, the "Brain" of Java switches focus during these two phases. 🚀 The Core Difference: Compile-time (The Architect): Works strictly on the Reference Type. Runtime (The Builder): Works strictly on the Actual Object Type. Let’s break down the internals: 🔹 Compile-time (The Static Phase): The Compiler (javac) is like a strict security guard. It only looks at the "Label" (Reference Type). If you have Animal myDog = new Dog();, the compiler only sees Animal. It checks if the method you are calling exists in the Animal class. It doesn't care what is actually sitting in memory yet. 🔹 Runtime (The Dynamic Phase): The JVM (Java Virtual Machine) is the executor. It looks at the actual memory heap. It sees the new Dog() object. When you call makeSound(), the JVM uses Dynamic Method Dispatch to look up the method in the Dog class, even if the reference was Animal. Key Takeaway: If your code doesn't pass the "Reference Check" at compile-time, it will never get to the "Object Execution" at runtime. #Java #Programming #Backend #SoftwareEngineering #JVM #CodingTips

🚀 Day 31 of Importance of Static block, Static variables and Static methods Today, I explored one of the most important concepts in Java – Static Keyword 🔥 🔹 Static Variables Belong to the class, not to objects. Only one copy is created and shared among all instances. Memory is allocated only once when the class is loaded. Accessed using the class name. 🔹 Static Methods Belong to the class rather than an object. Can be called without creating an object. Mostly used for utility methods. Cannot directly access non-static instance variables. 🔹 Static Block Executes when the class is loaded into memory. Used to initialize static variables. Runs before constructors. Executes only once. Static members are shared resources of a class. They improve memory efficiency and are perfect for common data or utility logic. Understanding how static works also helped me visualize JVM memory concepts like Class Area, Stack, and Heap. #Day31 #Java #LearningJourney #StaticKeyword #Programming #BackendDevelopment

Day 6/100 – LeetCode Challenge 🚀 Problem: #189 Rotate Array   Difficulty: Medium   Language: Java   Approach: Array Reversal Technique   Time Complexity: O(n)   Space Complexity: O(1) 🔍 Key Insight: Instead of shifting elements one by one, the array can be rotated efficiently using a three-step reversal strategy. Steps: 1️⃣ Reverse the entire array   2️⃣ Reverse the first k elements   3️⃣ Reverse the remaining elements  This achieves the required rotation in-place with constant extra space. 🧠 Solution Brief: Calculated k % n to handle cases where k is greater than array length.   Reversed the entire array first.   Then reversed the first k elements and the remaining n-k elements.   This sequence correctly rotates the array to the right. 📌 What I Learned: Understanding patterns like array reversal can simplify problems that initially seem complex.   Optimizing from brute force shifting to an in-place O(n) solution improves efficiency. #LeetCode #Day6 #100DaysOfCode #Java #DSA #Arrays #RotateArray #ProblemSolving #CodingJourney

Hook Blocking I/O mixed with thread-per-request code is still the leading cause of unpredictable tail latency I see in Java services. On Java 21+ you don’t need a full reactive rewrite to fix it — you need a targeted, measurable plan. Body — A practical 3-step path

Ever wondered what happens behind the scenes when you hit "Run" in Java? 🤔 Let’s break down how the JVM actually executes your code: 1️⃣ Compile – Your .java source code is compiled into bytecode (.class files) by the Java compiler. 2️⃣ Class Load – The JVM loads these classes into memory using the ClassLoader subsystem. 3️⃣ Bytecode Verify – Bytecode is checked for security and correctness. 4️⃣ Interpreter + JIT – The interpreter runs the bytecode line by line. Frequently used code gets compiled into native machine code by the JIT (Just-In-Time) compiler for faster execution. 5️⃣ Execute – The native code runs on the underlying hardware. 🎯 Result? Platform independence + high performance. Q1: Why does Java need both an interpreter and a JIT compiler? A: The interpreter starts execution quickly without waiting for compilation. The JIT compiler optimizes hot paths at runtime, giving the best of both startup speed and long-term performance. Q2: Is bytecode really platform-independent? A: Yes! Bytecode runs on any device with a JVM, which acts as an abstraction layer. The JVM itself is platform-specific, but your code doesn't have to be. Q3: What happens if bytecode fails verification? A: The JVM throws a VerifyError and won't execute the code. This prevents malicious or corrupt code from harming the system. #Java #JVM #Programming #SoftwareEngineering #TechExplained

💡 Enums were too limited, inheritance was too open. So, Sealed Classes fixed both. 🔒 What are Sealed Classes? Sealed classes let you restrict which classes can extend or implement a class/interface. Instead of anyone extending your class, you explicitly allow only specific subclasses. ✅ Why this matters? • Better domain modeling (especially in DDD) • Exhaustive pattern matching (no missing cases in switch) • More secure APIs (no unintended subclassing) • Cleaner architecture boundaries 🧠 Example: public sealed class Payment permits UpiPayment, CardPayment {} public final class UpiPayment extends Payment {} public final class CardPayment extends Payment {} ————————————————————————— No random developer can extend Payment. Java compiler enforces your design rules. 💡 Think of Sealed Classes as: Enums + Inheritance + Compile-time safety Java is evolving fast, Sealed Classes are a big step towards safer and more expressive APIs. Are you using Sealed Classes in production yet? 👇 #Java #Java17 #SealedClasses #BackendDevelopment #Microservices #SystemDesign #Programming

In Java, a class is not final, but we need to restrict the creation of a child class. How is it possible? By declaring each constructor as private, we can stop the child classes. eg: # parent class class P{ private P(){} } # child class class C extends P{ public C(){ super(); // ---> tries to call parent's constructor } } super() will attempt to call the parent no-arg constructor, but since it is private, the compiler throws an error. So even though the class is not final, inheritance becomes impossible. Would love to know if there are other ways to restrict child class creation! #java #oops #constructer