Mastering Virtual Threads for Java Interviews

Day 90 of #100DaysOfCode Solved Squares of a Sorted Array in Java 🔠 Approach The task was to take an array of integers sorted in non-decreasing order, square each number, and then return the result array also sorted in non-decreasing order. Brute-Force Method The solution implemented here is a straightforward two-step brute-force approach: Squaring: I iterated through the input array nums and replaced each element with its square (i.e., nums[i] * nums[i]). This handles both positive and negative numbers correctly. Sorting: After squaring all elements, I used Java's built-in Arrays.sort(nums) method to sort the entire array. While correct, this approach has a time complexity dominated by the sorting step, which is O(NlogN), where N is the number of elements. The runtime of 10 ms shows that a more efficient, two-pointer approach (which can solve this in O(N) time) is generally preferred for optimal performance. #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #Array #Sorting #ProblemSolving

🚀 Day 18/100 of #100DaysOfCode ✅ Solved “Isomorphic Strings” (LeetCode #205) using Java! 🧩 Problem: Given two strings s and t, determine if they are isomorphic. 👉 Two strings are isomorphic if characters in one string can be replaced to get the other — while keeping order and unique mapping intact. 🧠 Approach: Used a HashMap to store the mapping of characters from s → t. Checked if each character in s has a consistent mapping in t. Also ensured that no two characters in s map to the same character in t. ✨ Example: s = "egg", t = "add" → true (e→a, g→d) s = "foo", t = "bar" → false 📈 Complexity: Time: O(n) Space: O(n) 💡 Key Learnings: Understood how to maintain one-to-one character mapping using a HashMap. Reinforced logic building for pattern matching between strings. 💻 Tech Used: Java | HashMap | Problem Solving #LeetCode #100DaysOfCode #Java #ProblemSolving #DSA #CodingJourney #LearnByDoing #DevCommunity

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

/** Understanding the Thread Life Cycle in Java **/ If you’ve ever worked with multithreading, you’ve probably heard terms like Runnable, Waiting, or Terminated. But what really happens behind the scenes when a thread runs in Java? 🤔 Let’s break it down 👇 1️⃣ New When a thread is created (using Thread t = new Thread()), it’s in the New state. It exists, but it hasn’t started yet. 2️⃣ Runnable After calling t.start(), the thread moves to the Runnable state — it’s ready to run and waiting for the CPU to allocate time for it. 3️⃣ Running When the CPU picks it up, the thread goes into the Running state. This is where your code inside the run() method actually executes. 4️⃣ Waiting / Blocked / Timed Waiting A thread can be temporarily paused due to I/O operations, sleep(), wait(), or synchronization locks. It’s basically saying, “I’ll wait until the condition is right to continue.” 5️⃣ Terminated (Dead) Once the run() method finishes executing, the thread enters the Terminated state — its job is done! 💡 In short: A Java thread goes from being born → ready → active → waiting → dead. Understanding this life cycle helps you write cleaner, safer, and more efficient concurrent code. There is a vital keyword called synchronized to maintain consistency for multithreading. How do you usually debug or handle thread synchronization issues in your projects? 🔍 #Java #Multithreading #ThreadLifeCycle #Concurrency #Programming #BackendDevelopment #SoftwareEngineering

Day 28/100 – #100DaysOfCode 🚀 | #Java #LeetCode #DynamicProgramming ✅ Problem Solved: Scramble String 🔀 🧩 Problem Summary: Given two strings s1 and s2, determine whether one is a scrambled version of the other. A string is scrambled by recursively dividing it into two non-empty substrings and swapping them. 💡 Approach Used: Implemented Recursion + Memoization using a HashMap for overlapping subproblems. Used character frequency checks to prune unnecessary recursion calls. Used Java’s BiFunction with inline helper logic for recursion. ⚙️ Time Complexity: O(n⁴) (due to substring operations and recursion) 📦 Space Complexity: O(n²) ✨ Takeaway: Even complex recursive problems can be optimized efficiently with Memoization and early pruning. 🚀 #Java #LeetCode #DynamicProgramming #Recursion #ProblemSolving #100DaysOfCode #CodingChallenge

💡Did you know that Generics simplify your code in Java, even if you don't use them directly? If you’ve ever worked with Java Collections, you’ve already used one of the language’s most powerful features: Generics. But why are they so important? 1. Type Safety Generics allow you to specify the type of objects a collection or class can work with. This drastically reduces ClassCastException and other runtime surprises, leading to more stable applications. 2. Cleaner Code by Eliminating Explicit Casts By specifying the type upfront, the compiler automatically handles casts when retrieving elements. 3. Improved Code Reusability Write classes once, and use them with any object type. Generics enable you to build flexible, reusable components without sacrificing type integrity. A perfect example? The List Interface! When you declare a List, you must typically specify the type of object it will hold within angle brackets (<>). This specified type is the type argument for the generic interface. For example: • List<String> means the list can only hold String objects. • List<Integer> means the list can only hold Integer objects. Without Generics (pre-Java 5), you could add any element to the List, but: • Adding different types of variables to the list would lead to a ClassCastException. • When retrieving values, you had to manually cast each element. This simple difference illustrates how generics transform potential runtime headaches into compile-time warnings, allowing developers to catch and fix issues much earlier in the development cycle. #Java #Generics #Programming #CleanCode #SoftwareDevelopment #JavaCollections #CodingTips

You should use 𝚂𝚝𝚛𝚒𝚗𝚐 𝚊 = “𝙷𝚎𝚕𝚕𝚘”, and not 𝚂𝚝𝚛𝚒𝚗𝚐 𝚊 = 𝚗𝚎𝚠 𝚂𝚝𝚛𝚒𝚗𝚐(“𝙷𝚎𝚕𝚕𝚘”) in Java. Here’s why. 👇 If you write Java, you deal with String objects all day long. But do you know the hidden memory optimization that saves your application from running out of space? It's the 𝐒𝐭𝐫𝐢𝐧𝐠 𝐂𝐨𝐧𝐬𝐭𝐚𝐧𝐭 𝐏𝐨𝐨𝐥. 𝐒𝐭𝐫𝐢𝐧𝐠 𝐩𝐨𝐨𝐥, 𝐨𝐫 𝐭𝐡𝐞 𝐒𝐭𝐫𝐢𝐧𝐠 𝐂𝐨𝐧𝐬𝐭𝐚𝐧𝐭 𝐏𝐨𝐨𝐥, is a special storage area in the Java 𝐇𝐞𝐚𝐩 𝐦𝐞𝐦𝐨𝐫𝐲 where string literals are stored. The core idea is to avoid creating multiple duplicate String objects in memory when they have the same content. The String Pool is the 𝐤𝐞𝐲 to efficient, scalable code and a crucial JVM feature. When you declare a String literal (𝐒𝐭𝐫𝐢𝐧𝐠 𝐚 = "𝐇𝐞𝐥𝐥𝐨"), the JVM first checks the Pool. If the string already exists, the new variable will simply point to that existing object in the pool, avoiding new memory allocation. This optimization only works because Java String objects are 𝐢𝐦𝐦𝐮𝐭𝐚𝐛𝐥𝐞. 𝐖𝐡𝐞𝐧 𝐲𝐨𝐮 𝐰𝐫𝐢𝐭𝐞: 𝚂𝚝𝚛𝚒𝚗𝚐 𝚜𝟷 = “𝙷𝚎𝚕𝚕𝚘”; 𝚂𝚝𝚛𝚒𝚗𝚐 𝚜𝟸 = “𝙷𝚎𝚕𝚕𝚘”; Both strings point to the same object in memory. So if you do: 𝚂𝚢𝚜𝚝𝚎𝚖.𝚘𝚞𝚝.𝚙𝚛𝚒𝚗𝚝𝚕𝚗(𝚜𝟷 == 𝚜𝟸); // 𝚝𝚛𝚞𝚎 𝐖𝐡𝐞𝐧 𝐲𝐨𝐮 𝐰𝐫𝐢𝐭𝐞: 𝚂𝚝𝚛𝚒𝚗𝚐 𝚜𝟹 = 𝚗𝚎𝚠 𝚂𝚝𝚛𝚒𝚗𝚐(“𝙷𝚎𝚕𝚕𝚘”); It always 𝐟𝐨𝐫𝐜𝐞𝐬 the creation of a new object in the main Heap, outside the String Pool. So if you do: 𝚂𝚢𝚜𝚝𝚎𝚖.𝚘𝚞𝚝.𝚙𝚛𝚒𝚗𝚝𝚕𝚗(𝚜𝟷 == 𝚜𝟹); // 𝚏𝚊𝚕𝚜𝚎 If you absolutely must use the new operator you can call .𝚒𝚗𝚝𝚎𝚛𝚗() on your string to explicitly move or fetch its reference from the Pool, forcing the JVM to 𝐫𝐞𝐮𝐬𝐞 𝐨𝐛𝐣𝐞𝐜𝐭𝐬. 𝚂𝚝𝚛𝚒𝚗𝚐 𝚜𝟹 = 𝚗𝚎𝚠 𝚂𝚝𝚛𝚒𝚗𝚐(“𝙷𝚎𝚕𝚕𝚘”).𝚒𝚗𝚝𝚎𝚛𝚗(); 𝚂𝚢𝚜𝚝𝚎𝚖.𝚘𝚞𝚝.𝚙𝚛𝚒𝚗𝚝𝚕𝚗(𝚜𝟷 == 𝚜𝟹); // 𝚝𝚛𝚞𝚎 What’s your favorite JVM optimization trick? Share in the comments! 👇 #Java #JVM #SoftwareEngineering #TechCareer #ProgrammingTips #MemoryManagement #PerformanceTuning #Coding

🚀 Day 7 — The Multithreading Mystery That Breaks Developer Logic 🧩 Every Java developer says: “I know how threads work.” But when two threads share the same object… even pros get confused about what actually happens 👇 class Printer implements Runnable {   int count = 0;   @Override   public void run() {     for (int i = 0; i < 3; i++) {       System.out.println(Thread.currentThread().getName() + " → " + count++);     }   }   public static void main(String[] args) {     Printer printer = new Printer();     Thread t1 = new Thread(printer, "Thread-A");     Thread t2 = new Thread(printer, "Thread-B");     t1.start();     t2.start();   } } 💭 Question: What could be the possible output? 1️⃣ Each thread prints 0 1 2 independently 2️⃣ The count value increases continuously (shared between threads) 3️⃣ Compile-time error 4️⃣ Unpredictable output 💬 Drop your guess in the comments 👇 Most devs think they know the answer — until they realize what “shared object” actually means in Java threading 😵💫 Can you explain why it happens? 🧠 #Java #Multithreading #Concurrency #CodingChallenge #JavaDeveloper #InterviewQuestion #Day7Challenges #SpringBoot

🧠 Java with DSA – Day 38: Linked Logic Today’s focus: building the backbone—singly linked lists in Java. - Created custom Node class with data and next—because every journey starts with a pointer. - Linked nodes manually to form a chain—visualizing memory as a trail of connections. - Printed intermediate nodes to trace flow—because debugging is storytelling. - Realized that linked lists aren’t just data—they’re dynamic, flexible, and foundational. DSA is about more than structures—it’s about understanding how data moves, grows, and adapts. 🚀 All code + notes on GitHub – https://lnkd.in/gGWnjGxk #LinkedListBasics #NodeByNode #CodeWithClarity #ShouryaCodes #100DaysOfCode #DSAFoundation #LinkedInDevJourney #OneQuesADay

💫 Object Class in Inheritance : In Java, every class directly or indirectly inherits from the Object class, which is the root of the class hierarchy. This means all classes automatically get the basic behavior provided by Object, even if we don’t explicitly extend it. ✅ Key Points: Object is the parent of all classes in Java. If a class doesn’t extend any class, Java implicitly makes it a child of Object. Provides essential methods like: 🔹 toString() → returns string representation of an object 🔹 equals() → compares two objects 🔹 hashCode() → returns hash value of object 🔹 clone() → creates object copy (if implemented) 🔹 finalize() → cleanup before garbage collection 🔹 getClass() → gets runtime class details 🔹 wait() → Causes the current thread to pause execution 🔹 notify() → The notified thread moves from waiting to runnable state 🔹 notifyAll() → Wakes all threads waiting on the object’s monitor. 🚀 Conclusion The Object class is the foundation of inheritance in Java. It standardizes behavior across all classes and enables powerful features like polymorphism. Thanks to our mentor Anand Kumar Buddarapu Sir for your guidance and support. #Java #ObjectClass #JavaProgramming #CoreJava