Understanding Java Agents: A Powerful JVM Feature

Java ke atomic level ke secrets! 🔥 --- Post 1: Java ka "Multi-Release JAR" ka hidden feature!🤯 ```java // Java 8 version - base code public class TimeUtils { public static String getTime() { return "Legacy time: " + new Date(); } } // Java 11 version - META-INF/versions/11/TimeUtils.java public class TimeUtils { public static String getTime() { return "Modern time: " + Instant.now(); } } ``` Secret: Ek hi JAR mein multiple Java versions ke liye alag-alag class files ho sakti hain!💀 --- Post 2: Java ka "ConstantDynamic" - invokedynamic for constants!🔥 ```java public class ConstantDynamic { // Java 11+ mein constants bhi dynamically resolve ho sakte hain public static final String DYNAMIC_CONSTANT = ConstantDescs.of("Dynamically resolved constant"); // Bytecode level par invokedynamic use karta hai // instead of constant pool entry! } ``` Internal Magic: · Traditional: Constant Pool → LDC instruction · New: ConstantDynamic → invokedynamic instruction · Dynamic constant resolution at runtime! 💡 --- Post 3: Java ka "Vector API" - SIMD operations ka raaz!🚀 ```java import jdk.incubator.vector.*; public class VectorMagic { public static void main(String[] args) { IntVector a = IntVector.fromArray(IntVector.SPECIES_256, new int[]{1,2,3,4,5,6,7,8}, 0); IntVector b = IntVector.fromArray(IntVector.SPECIES_256, new int[]{8,7,6,5,4,3,2,1}, 0); IntVector result = a.add(b); // ✅ 8 operations ek saath! // CPU level par SIMD instructions use karta hai } } ``` Performance: 10x faster for mathematical operations!💪 --- Post 4: Java ka "Heap Allocation" ka hidden alternative!🔮 ```java import java.lang.foreign.*; public class OffHeapMagic { public static void main(String[] args) { // Heap se bahar memory allocate karo! try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(100); // Direct OS memory access - no GC overhead! segment.set(ValueLayout.JAVA_INT, 0, 42); int value = segment.get(ValueLayout.JAVA_INT, 0); } } } ``` Benefits: · Zero GC pressure · Direct memory access · C-like performance 💀 --- Bhai, yeh features toh aane wali Java generations ke liye hain! 😎

Top 10 Java Internals Every Developer must Know --> 𝟭. 𝗝𝗩𝗠 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 The brain of Java. Handles class loading, memory management, and execution via the ClassLoader, Memory Areas (Heap, Stack, Metaspace), and Execution Engine (JIT + Interpreter). 𝟮. 𝗖𝗹𝗮𝘀𝘀 𝗟𝗼𝗮𝗱𝗶𝗻𝗴 & 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 Turning source code into bytecode magic. Dynamic loading via a delegation model ensures security and modularity. Each class lives in one ClassLoader universe. 𝟯. 𝗚𝗮𝗿𝗯𝗮𝗴𝗲 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 (𝗚𝗖) Memory cleanup with attitude. G1, ZGC, and Shenandoah manage heap generations, compacting memory with minimal pause times — so your app doesn’t stutter mid-run. 𝟰. 𝗝𝘂𝘀𝘁-𝗜𝗻-𝗧𝗶𝗺𝗲 (𝗝𝗜𝗧) 𝗖𝗼𝗺𝗽𝗶𝗹𝗮𝘁𝗶𝗼𝗻 When your code gets smarter at runtime. Hot methods are compiled into native code. JIT performs inlining, escape analysis, and optimization based on profiling data. 𝟱. 𝗝𝗮𝘃𝗮 𝗠𝗲𝗺𝗼𝗿𝘆 𝗠𝗼𝗱𝗲𝗹 (𝗝𝗠𝗠) Defines how threads actually see memory. Guarantees “happens-before” rules. Understands visibility, ordering, and atomicity — essential for writing safe concurrent code. 𝟲. 𝗦𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗶𝘇𝗮𝘁𝗶𝗼𝗻 & 𝗟𝗼𝗰𝗸𝘀 Inside the synchronized keyword. JVM uses biased, lightweight, and heavyweight locks. Too much contention? JVM dynamically escalates the lock strategy. 𝟳. 𝗖𝗹𝗮𝘀𝘀 𝗗𝗮𝘁𝗮 𝗦𝗵𝗮𝗿𝗶𝗻𝗴 (𝗖𝗗𝗦) & 𝗔𝗢𝗧 Faster startup, smaller footprint. CDS stores preloaded classes in a shared archive; AOT (Ahead-of-Time) compilation skips JIT for faster boot — perfect for microservices. 𝟴. 𝗡𝗮𝘁𝗶𝘃𝗲 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 (𝗝𝗡𝗜 & 𝗣𝗮𝗻𝗮𝗺𝗮) When Java shakes hands with C/C++. Bridges Java and native code for performance-critical tasks, while Project Panama makes it safer and faster than legacy JNI. 𝟵. 𝗝𝗩𝗠 𝗧𝘂𝗻𝗶𝗻𝗴 & 𝗠𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴 Keep your JVM happy and your prod stable. Tweak -Xmx, -XX:+UseG1GC, use JFR, JConsole, and VisualVM for insights. Heap dumps tell the story of your runtime. 𝟭𝟬. 𝗥𝗲𝗳𝗹𝗲𝗰𝘁𝗶𝗼𝗻 & 𝗠𝗲𝘁𝗮𝗱𝗮𝘁𝗮 Java looking at itself. Power behind frameworks like Spring and Hibernate. Uses class metadata and dynamic proxies to wire behavior at runtime. #java #javaDeepDive #coreJava #javaInternal #javaInterview #softwareEngineering #javaDeveloper #javaWins #modernJava #java25 #jdk #jre #jdkInternal #javaConcurrency #jvm

Java ke atomic level ke secrets! 🔥 --- Post 1: Java ka "Class Loading" ka hidden hierarchy!🤯 ```java public class ClassLoaderSecrets { public static void main(String[] args) { ClassLoader loader = String.class.getClassLoader(); System.out.println(loader); // null ✅ // Kyun? Bootstrap ClassLoader C++ mein implemented hai // Java mein uska koi object nahi hota! } } ``` ClassLoader Hierarchy: 1. Bootstrap (C++ implementation) - null dikhata hai 2. Platform (Java 9+) - jdk.internal.loader.ClassLoaders$PlatformClassLoader 3. Application - sun.misc.Launcher$AppClassLoader Secret: Bootstrap ClassLoader Java mein visible nahi hota! 💀 --- Post 2: Java ka "Lambda Metafactory" internal magic!🔥 ```java public class LambdaSecrets { public static void main(String[] args) { Runnable r = () -> System.out.println("Lambda"); // Internally ye invokeDynamic instruction banata hai // LambdaMetafactory lambda class runtime pe generate karta hai! } } ``` Bytecode Level: ``` invokedynamic #2, 0 // LambdaMetafactory.metafactory() call ``` Internal Process: 1. invokedynamic instruction 2. LambdaMetafactory call 3. Runtime pe synthetic class generation 4. Method handle return 💡 --- Post 3: Java ka "String Deduplication" G1GC feature!🚀 ```java public class StringDedup { public static void main(String[] args) { // G1GC automatically duplicate strings ko same memory point kar deta hai char[] data = {'J', 'a', 'v', 'a'}; String s1 = new String(data); String s2 = new String(data); // G1GC intern() ki tarah same char[] point kar sakta hai! } } ``` JVM Option: ``` -XX:+UseG1GC -XX:+UseStringDeduplication ``` Secret: G1GC duplicate strings ko automatically optimize karta hai! 💪 --- Post 4: Java ka "Stack Walking" internal API!🔮 ```java public class StackWalkSecrets { public static void main(String[] args) { StackWalker walker = StackWalker.getInstance(); walker.forEach(frame -> { System.out.println(frame.getClassName() + "." + frame.getMethodName()); }); } } ``` Internal Stack Frame Structure: · Method name · Class name · Line number · Bytecode index Performance: StackWalker traditionalStackTrace se 10x faster hai! 💀

🚀 Modern Java in One Shot — All Features in One Program🤔 Modern Java brings powerful improvements -> RECORDS, SEALED CLASSES, PATTERN MATCHING, SWITCH, TEXT BLOCKS, ASYNC HTTPCLIENT & VIRTUAL THREADS. Here’s a compact demo program with all features 👇 --------------------------------------------------------------------------- import java.net.http.*;import java.net.URI;import java.time.LocalDate; import java.util.*;import java.util.concurrent.*; // RECORDS record User(int id, String name, LocalDate lastActive) { } // SEALED CLASSES sealed interface Notification permits Email, Sms { } record Email(String to, String msg) implements Notification { } public class ModernJavaService {   public static void main(String[] args) throws Exception {      // Loads a user & checks if they’re recently active     var user = new User(1, "Alice", LocalDate. now());     var isActive = user.lastActive().isAfter(LocalDate. now().minusDays(2));     SOP("User Active: " + isActive);      // Prepares an email notification,     Notification n=new Email( user. name().toLowerCase()+"@ex. com", "Thanks!"); // PATTERN MATCHING     if (n instanceof Email e)    SOP("Preparing Email for: " + e. to()); // Selects channel via SWITCH     var channel = switch (n) { case Email e -> "EMAIL";   };     SOP("Notification Channel: " + channel); // Builds JSON payload using a TEXT BLOCK     String payload = """         {    "message": "Thank you for staying active"      }         """;     SOP("Payload: " + payload);     Optional.of(user. name()).ifPresent(name -> SOP("Sending to user: " + name));     // Fetches remote config via ASYNC HTTPCLIENT     var client = HttpClient.newHttpClient();     var req = HttpRequest.newBuilder().uri(URI.create("https://httpbin. org/get")).build();     var configFuture = client.sendAsync(req, HttpResponse.BodyHandlers.ofString())         .thenApply(HttpResponse::body) .thenApply(b -> { SOP("Fetched Remote Config OK");  return b; }); // Sends the notification using a VIRTUAL THREAD     Thread.startVirtualThread(() -> {       try { Thread.sleep(300); SOP("Notification delivered to: " + user. name());       } catch (Exception e) {  e.printStackTrace();   }    });     configFuture.join();    SOP("All operations completed.");   }} --------------------------------------------------------------------------- OUTPUT: User Active: true Preparing Email for: alice@ex. com Notification Channel: EMAIL Payload: {  "message": "Thank you for staying active"} Sending to user: Alice Fetched Remote Config OK Notification delivered to: Alice All operations completed. --------------------------------------------------------------------------- 💬 Which do you think? #ModernJava #JavaDeveloper #CleanCode #VirtualThreads

🎯 Modern Java Null Handling: DTO vs Domain Objects - The Right Way! NullPointerException is still the #1 runtime error in Java applications. Let me share a battle-tested approach 👇 📌 The Problem We All Face: Your API receives JSON with nullable fields: { "userId": "123", "email": "user@example.com", "phoneNumber": null, "address": null } Traditional approach? Null checks everywhere! 😫 if (user.getPhone() != null) { if (!user.getPhone().isEmpty()) { sendSMS(user.getPhone()); } } 🎯 The Modern Solution: Layer 1️⃣ - DTO Layer (API Boundary) Keep it nullable for flexibility: public record UserRequest( String userId, String email, String phoneNumber, // nullable AddressDTO address // nullable ) Layer 2️⃣ - Domain Layer (Business Logic) Use Optional for clarity: public class User { private final String userId; private final String email; private final Optional<String> phoneNumber; private final Optional<Address> address; public void sendNotification(NotificationService service) { phoneNumber.ifPresent(phone -> service.sendSMS(phone, "Welcome!") ); address.ifPresentOrElse( addr -> service.sendMail(email, "Delivery: " + addr), () -> service.sendMail(email, "Add delivery address") ); } } Layer 3️⃣ - Safe Conversion public User toDomain() { return new User( userId, email, Optional.ofNullable(phoneNumber) .filter(p -> !p.isBlank()), Optional.ofNullable(address) .map(AddressDTO::toDomain) ); } 🚀 Real-World Benefits: ✅ No Null Checks: Code remains clean and readable ✅ Type Safety: Compiler tells you what's optional ✅ Self-Documenting: Optional clearly means "may not exist" ✅ Stream-Friendly: flatMap(Optional::stream) filters empties elegantly ✅ Testability: Mock-free unit tests, no null edge cases 💡 Golden Rules I Follow: 1️⃣ DTOs can be nullable (API contracts need flexibility) 2️⃣ Domain objects use Optional (business logic clarity) 3️⃣ Never return null from domain methods 4️⃣ Use Optional.ofNullable() at conversion boundaries 5️⃣ Combine with Stream API for powerful filtering ⚡ Power Combo Example: List<String> validPhones = users.stream() .map(User::getPhoneNumber) .flatMap(Optional::stream) // Magic! Filters empties .filter(phone -> phone.startsWith("+91")) .toList(); 🎓 Key Takeaway: The pattern isn't just about Optional - it's about separating concerns: DTOs handle external world (nulls exist) Domain handles business rules (Optional expresses intent) Conversion layer bridges them safely This follows DDD principles while keeping APIs backward-compatible! #Java #CleanCode #SoftwareArchitecture #DomainDrivenDesign #NullSafety #BestPractices #SpringBoot #BackendDevelopment #EnterpriseJava #CodeQuality #Optional #DTO #DDD #JavaDevelopers #SoftwareEngineering #TechTips #Programming #FullStackDevelopment

🔰 𝐃𝐚𝐲 𝟗𝟏/𝟏𝟎𝟎 – 𝟏𝟎𝟎 𝐃𝐚𝐲𝐬 𝐨𝐟 𝐉𝐚𝐯𝐚 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 📌 𝐓𝐨𝐩𝐢𝐜: 𝐒𝐞𝐫𝐯𝐢𝐜𝐞 𝐏𝐫𝐨𝐯𝐢𝐝𝐞𝐫 𝐈𝐧𝐭𝐞𝐫𝐟𝐚𝐜𝐞 (𝐒𝐏𝐈) 𝐢𝐧 𝐉𝐚𝐯𝐚 – 𝐏𝐥𝐮𝐠 𝐚𝐧𝐝 𝐏𝐥𝐚𝐲 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 👨💻 Yesterday, we explored ServiceLoader — Java’s dynamic service discovery tool. Today, let’s understand the foundation behind it: the Service Provider Interface (SPI) — the backbone of extensibility in Java. 🔹 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐒𝐏𝐈 𝐢𝐧 𝐉𝐚𝐯𝐚? SPI (Service Provider Interface) is a design pattern that allows frameworks or libraries to be extended by external implementations without modifying the core code. 🧩 Think of it as: 👉 “You define the contract — others plug in their implementations.” 🔹 𝐇𝐨𝐰 𝐒𝐏𝐈 𝐖𝐨𝐫𝐤𝐬 The SPI model has three main parts: 1️⃣ Service Interface – Defines a standard contract or behavior. 2️⃣ Service Provider (Implementation) – One or more classes implementing that interface. 3️⃣ Service Configuration File – Registers implementations under META-INF/services/. Java then uses ServiceLoader to discover and load these implementations at runtime. 🔹 𝐄𝐱𝐚𝐦𝐩𝐥𝐞 (𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐮𝐚𝐥) 1️⃣ Define the SPI (Service Interface): public interface PaymentService { void processPayment(double amount); } 2️⃣ Provide Implementations: public class CreditCardPayment implements PaymentService { public void processPayment(double amount) { System.out.println("Paid " + amount + " using Credit Card"); } } 3️⃣ Register the Implementation: 📁 META-INF/services/com.example.PaymentService Content: com.example.CreditCardPayment 4️⃣ Load Dynamically: ServiceLoader<PaymentService> loader = ServiceLoader.load(PaymentService.class); for (PaymentService service : loader) { service.processPayment(500.0); } 🔹 𝐀𝐝𝐯𝐚𝐧𝐭𝐚𝐠𝐞𝐬 𝐨𝐟 𝐒𝐏𝐈 ✅ Extensibility – Add new features without modifying the base framework. ✅ Loose Coupling – Framework and implementations remain independent. ✅ Dynamic Loading – Implementations can be swapped or added at runtime. ✅ Scalability – Ideal for large, pluggable systems. 🔹 𝐑𝐞𝐚𝐥-𝐖𝐨𝐫𝐥𝐝 𝐄𝐱𝐚𝐦𝐩𝐥𝐞𝐬 💡 JDBC Drivers – The java.sql.Driver interface is discovered using SPI. 💡 Java Logging Frameworks – Allow developers to plug in different log handlers. 💡 Cryptography APIs (JCA/JCE) – Use SPI to enable multiple security providers. 💭 𝐅𝐢𝐧𝐚𝐥 𝐓𝐡𝐨𝐮𝐠𝐡𝐭 SPI + ServiceLoader = Java’s plug-and-play mechanism. It powers extensible frameworks, allowing developers to innovate without breaking core functionality. #Java #CoreJava #SPI #ServiceProviderInterface #ServiceLoader #JavaModules #DependencyInjection #JavaProgramming #100DaysOfJava #100DaysOfCode #JavaDeveloper #ModularProgramming #CodingChallenge #SoftwareDevelopment #JavaLearning

What are OOPs concepts in Java? Encapsulation, Inheritance, Polymorphism, and Abstraction. Difference between an interface and an abstract class? Interface has only abstract methods (till Java 7), abstract class can have both abstract and concrete methods. What is the difference between == and .equals()? == compares references; .equals() compares content. What are access modifiers in Java? public, private, protected, and default. What is the difference between String, StringBuilder, and StringBuffer? String is immutable; StringBuilder and StringBuffer are mutable (StringBuffer is thread-safe). Difference between List, Set, and Map in Java? List allows duplicates, Set doesn’t, Map stores key-value pairs. What is HashMap and how does it work internally? Uses hashing; stores key-value pairs in buckets based on hashcode. How to handle duplicate values in arrays? Use Set, or loop and compare values manually. What is the difference between ArrayList and LinkedList? ArrayList is faster for search; LinkedList is faster for insertion/deletion. How to sort a list of numbers or strings in Java? Collections.sort(list); or use list.stream().sorted(). What is the difference between checked and unchecked exceptions? Checked must be handled (like IOException); unchecked are runtime (like NullPointerException). Explain try-catch-finally with example. Can we have multiple catch blocks? Yes, to handle different exception types. Can finally block be skipped? Only if System.exit(0) is called before it. How do you read data from Excel in Selenium? Using Apache POI or JXL library. How do you handle synchronization in Selenium? Using Implicit, Explicit, or Fluent Wait. How do you handle JSON in RestAssured? Using JsonPath or org.json library. How do you handle dynamic elements in Selenium? Use XPath with contains(), starts-with(), or CSS selectors. What is the difference between Page Object Model (POM) and Page Factory? POM is a design pattern; Page Factory is an implementation of POM using @FindBy. How to read data from properties file in Java? Using Properties class and FileInputStream. Explain static keyword in Java. Used for class-level variables and methods; shared among all objects. What is final, finally, and finalize()? final (keyword) = constant; finally = block; finalize() = method before GC. What is constructor overloading? Multiple constructors with different parameter lists. Can we overload or override static methods? Overload Yes, Override No. What is difference between throw and throws? throw is used to throw an exception; throws declares it. Write a Java program to find duplicates in an array. Write a Java program to reverse a string. Write a Java program to count occurrences of each element. Write a Java program to check if a number is prime. Write a Java program to separate positive and negative numbers in an array. #Automation #Interview #Java

Understanding jmap — One of Java’s Most Powerful Diagnostic Tools When your Java application starts consuming too much memory or behaving unpredictably, the real question is: What’s inside the heap? That’s where the jmap (Java Memory Map) tool comes in. jmap is a command-line utility bundled with the JDK that lets you inspect and analyze memory usage of a running JVM. It’s invaluable when debugging memory leaks, high heap consumption, or GC-related performance issues. Basic Syntax: jmap [options] <pid> (where <pid> is the process ID of your Java application) Common Usages: 1. Check the heap summary jmap -heap <pid> Shows heap configuration, memory pools, garbage collectors, and usage statistics. Useful to verify how the heap is divided between Eden, Survivor, and Old Generation spaces. 2. List loaded classes jmap -clstats <pid> Displays class loader statistics — helps identify classloader leaks or unexpected redeployments in application servers. 3. Dump the heap to a file jmap -dump:format=b,file=heapdump.hprof <pid> Creates a heap dump file that you can analyze using tools like Eclipse MAT (Memory Analyzer Tool) or VisualVM. Perfect for investigating memory leaks and object retention. 4. Print histogram of objects jmap -histo <pid> | head -20 Shows a ranked list of objects in memory — classes with the most instances and total size. Great for spotting suspicious growth patterns (e.g., millions of HashMap$Node objects). Example Scenario: Imagine your microservice keeps slowing down after hours of uptime. You run: jmap -histo <pid> | head and notice thousands of byte[] and HttpSession objects still in memory. That’s your clue — likely a memory leak in session management. Pro Tip: You can also combine jmap with jhat, jvisualvm, or mat to visually navigate heap dumps and find leaks faster. In short: jmap is your JVM’s X-ray — it shows you what’s really happening inside memory. Next time you face an OutOfMemoryError, don’t panic — grab the process ID, run jmap, and start uncovering the truth. #Java #JVM #Performance #MemoryLeak #DevTools #Troubleshooting #JavaDevelopers

🗓️ Day-21: Collection Framework in Java The Collection Framework was introduced in Java 1.2 version 🧩 It is part of the java.util package 📦 and provides a set of classes and interfaces to store and manipulate groups of objects efficiently. The framework unifies different types of collections like List, Set, and Map, making them easier to use and maintain 🧠 🔹 Important Interfaces 🌀 Iterable – Root interface of the collection framework. ➤ Allows iteration using Iterator or enhanced for-each loop. 📚 Collection – Parent interface of most collection classes. ➤ Defines basic operations like add(), remove(), size(), clear(). 📋 List – Ordered collection that allows duplicate elements. ➤ Examples: ArrayList, LinkedList, Vector, Stack. 🚫 Set – Unordered collection that does not allow duplicates. ➤ Examples: HashSet, LinkedHashSet, TreeSet. 📬 Queue – Used to hold elements before processing (FIFO order). ➤ Examples: PriorityQueue, ArrayDeque. ↔️ Deque – Double-ended queue; elements can be added or removed from both ends. ➤ Example: ArrayDeque. 🔢 SortedSet – Maintains elements in sorted order. ➤ Example: TreeSet. 🗝️ Map – Stores key–value pairs. Keys are unique, values may duplicate. ➤ Examples: HashMap, LinkedHashMap, TreeMap. 📊 SortedMap – A Map that keeps its keys in sorted order. ➤ Example: TreeMap. 🕰️ Legacy Classes (Before Java 1.2) Legacy classes are the old collection classes that existed before the framework was introduced. They were later modified to fit into the new architecture. 📦 Vector – Dynamic array (synchronized). 📚 Stack – Subclass of Vector; follows LIFO (Last In First Out). 🔐 Hashtable – Similar to HashMap but synchronized. 🔁 Enumeration – Old iterator used to traverse legacy collections. 🧠 Note: Legacy classes are still supported for backward compatibility. ⚙️ Key Points ✅ The collection framework provides a common architecture for storing and manipulating data. 🧩 It is part of the java.util package. 🧮 Interfaces define different collection types, and classes provide implementations. 🧾 Generics were added in Java 1.5 to make collections type-safe. ⚠️ Legacy classes are synchronized, while most modern collection classes are not. 10000 Coders #Java #Collections #100DaysOfCoding #Day21 #CodingJourney

🔥 Day 30 / 120 - Java Full Stack Journey 📌 Today's focus: Heap Memory & String Constant Pool in Java 💻 ✨ It's the 🎯 entry point of every Java program - the place where execution begins and logic takes life! 🚀 Definition of Heap Memory: Heap memory is the runtime memory area in Java where all objects and their instance variables are stored. It is created when the Java Virtual Machine (JVM) starts and is shared among all threads of the application. When you use the new keyword to create an object, that object is allocated in heap memory. 🔹 Key Points: It stores objects, arrays, and class instances. It is managed by the Garbage Collector (GC), which automatically frees memory of unused objects. It is shared by all threads in the program. Size of the heap can be set using JVM options: -Xms (initial heap size) -Xmx (maximum heap size) Example Code: public class Example {   public static void main(String[] args) {     Example obj = new Example(); // 'obj' is stored in heap memory   } } Definition of String Constant Pool: The String Constant Pool (SCP) is a special memory area inside the heap that stores unique string literals. It helps save memory by reusing immutable string objects instead of creating duplicates. When you create a string literal (using double quotes ""), Java first checks the String Constant Pool: If the string already exists, Java reuses the existing object. If it doesn’t exist, a new object is created and stored in the pool. 🔹 Key Points: The SCP is part of the heap memory. Only string literals and strings created using intern() are stored there. It helps in memory optimization. Strings are immutable, so sharing them is safe. Example Code: public class StringPoolExample {   public static void main(String[] args) {     String s1 = "Java";     // Stored in String Constant Pool     String s2 = "Java";     // Reuses the same object from SCP     String s3 = new String("Java"); // Created in heap memory, outside SCP     String s4 = s3.intern();   // Moves/links to SCP reference     System.out.println(s1 == s2); // true → both point to same SCP object     System.out.println(s1 == s3); // false → s3 is in heap, not SCP     System.out.println(s1 == s4); // true → s4 refers to SCP string   } } 💐 Deep Gratitude: 🎓 Anand Kumar Buddarapu Sir— my dedicated Mentor, for guiding with clarity & wisdom. 👔 Saketh Kallepu Sir — the visionary CEO whose leadership inspires progress. 🔥 Uppugundla Sairam — the energetic Founder who fuels us with motivation