Dilip Kumar Jha’s Post

After understanding how Java code gets executed, the next question is: Where does the data actually get stored? In JVM, memory is mainly divided into two parts: Heap Memory: - Used to store objects and class instances - Shared across all threads - Managed by Garbage Collection - Objects generally have a longer lifetime Stack Memory: - Stores method calls and local variables - Each thread has its own stack - Automatically managed - Data exists only during method execution Key difference: Heap → Stores Objects Stack → Handles Execution (methods & variables) Understanding this difference helps in writing better and more efficient Java applications. #Java #JVM #BackendDevelopment #Learning

Day 52 – Deep Dive into Static Concepts in Java ☕ Today I revised static concepts with a focus on understanding their internal behavior and execution flow. Topics covered: 🔹 Order of execution (static blocks, static variables, and methods) 🔹 Why static members are called class members 🔹 Difference between class members and instance (object) members 🔹 How static variables are shared across all objects 🔹 Why static members can be accessed without creating objects 🔹 Why instance variables cannot be accessed directly in static context Revisiting these concepts helped me understand how Java manages memory and execution at the class level. Strengthening my core understanding of Java internals step by step 🚀 #Day52 #JavaJourney #Static #CoreJava #OOP #Consistency

Day 46-What I Learned In a Day(JAVA) Today I explored the execution of a Java program and understood how it works inside the JVM: JVM Memory Structure: • Method Area Stores class-level data like methods, static variables, and metadata • Class (Static) Area Holds static variables and static initializers • Stack Area Manages method calls, local variables, and execution flow • Heap Area Stores objects and instance variables Execution Order of Java Program: 1️⃣ Class is loaded into Method Area 2️⃣ Static variables & static initializers are executed (Class Area) 3️⃣ Main method is pushed into Stack Area 4️⃣ Objects are created in Heap Area (if any) 5️⃣ Methods execute using Stack (LIFO order) Program Components: • Methods -Define program behavior • Variables -Store data (local, instance, static) • Static Initializers -Execute once when the class loads #Java #JVM #Programming #LearningJourney #CoreJava #TechSkills

📖 New Post: Java Memory Model Demystified: Stack vs. Heap Where do your variables live? We explain the Stack, the Heap, and the Garbage Collector in simple terms. #java #jvm #memorymanagement

Day 33/100 — Threads & Multithreading ⚡ Java can do multiple things at the same time using threads. Thread lifecycle: NEW → RUNNABLE → RUNNING → WAITING → TERMINATED 2 ways to create threads: // Method 1: extend Thread class MyThread extends Thread {   public void run() { println("Running!"); } } new MyThread().start(); // NOT run()! // Method 2: Runnable lambda (preferred!) Thread t = new Thread(() -> println("Lambda thread!")); t.start(); Most important rule: ALWAYS call start() — NOT run()! → run() = normal method call (same thread) → start() = creates new thread and calls run() 3 things to remember: → Prefer Runnable over extending Thread → start() not run() → Multiple threads = race conditions possible! 🎯 Challenge: Create 3 threads that each print their name 5 times. Observe the interleaved output! #Java #Threads #Multithreading #CoreJava #100DaysOfJava #100DaysOfCode

🧬 Java Collections – Understanding List vs Set vs Map Yesterday I focused on building a deeper understanding of core Java Collection types and their practical usage. ✔️ List – Maintains order and allows duplicates ✔️ Set – Ensures uniqueness (no duplicate elements) ✔️ Map – Stores data in key–value pairs for efficient lookup Understanding these differences is essential for selecting the right data structure based on the problem context. 💡 Hands-on Practice: • Implemented frequency counting using Map • Identified unique elements using Set These exercises helped reinforce how theoretical concepts translate into real problem-solving scenarios. ⌨️ Additionally, continued daily typing practice to improve speed and accuracy. Consistent practice and clarity in fundamentals are key to writing efficient and scalable code. #Java #Collections #DataStructures #DSA #BackendDevelopment #SoftwareEngineering #LearningInPublic

Your Java Thread Model is Broken (Here's the Fix) Watch Full Video : https://lnkd.in/e_Usi8qA Website Link : https://systemdrd.com/ Full Course Link : https://lnkd.in/eM5jJyaQ OS threads cost 1MB each and cap you at ~2,000 connections. Java's virtual threads via Project Loom handle 1,000,000+ — with simpler code. Stop writing reactive chains. #JavaDeveloper #ProjectLoom #VirtualThreads #BackendEngineering #JavaTips #CodingShorts #SoftwareEngineering #Java2026

Most Java performance issues don’t show up in code reviews They show up in object lifetimes. Two pieces of code can look identical: same logic same complexity same output But behave completely differently in production. Why? Because of how long objects live. Example patterns: creating objects inside tight loops → short-lived → frequent GC holding references longer than needed → objects move to old gen caching “just in case” → memory pressure builds silently Nothing looks wrong in the code. But at runtime: GC frequency increases pause times grow latency becomes unpredictable And the worst part? 👉 It doesn’t fail immediately. 👉 It degrades slowly. This is why some systems: pass load tests work fine initially then become unstable weeks later Takeaway: In Java, performance isn’t just about what you do. It’s about how long your data stays alive while doing it. #Java #JVM #Performance #Backend #SoftwareEngineering

Day 36/100 – Working with ArrayList in Java 📚 Today I practiced using ArrayList in Java, a dynamic array that allows flexible storage and manipulation of data. Unlike normal arrays, ArrayList can grow and shrink dynamically, making it very useful in real-world applications. Key learnings: • Adding elements using add() • Storing multiple values dynamically • Finding size using size() • Easier and more flexible than traditional arrays Understanding collections like ArrayList is important for handling data efficiently in Java. Building strong fundamentals step by step. 🚀 #100DaysOfCode #Java #ArrayList #DataStructures #CodingJourney #LearningInPublic

🚀 Day 10/30 – Real-World Java Development Today I came across the concept of polymorphism. In simple terms, it means the same thing behaving differently based on the situation. In real-world applications, this happens more often than we notice. The same action can give different results depending on the context. For example, a single operation like “process” can behave differently for different types of data or scenarios. What I found interesting is — this helps in writing flexible code instead of repeating the same logic again and again. Still trying to connect these concepts with real use cases 👍 #30DaysChallenge #Java #OOP #BackendDevelopment #LearningJourney