Java Variables: Instance vs Local

Core Java Fundamentals :Key Traits of Metaspace Permanent Generation in Java PermGen (Permanent Generation) was a memory area in the Java Virtual Machine (JVM) used before Java 8 to store class metadata, interned strings, and static variables. It was part of the JVM heap space and had a fixed size, making it difficult to manage memory efficiently. Fixed and Hard-to-Tune Size in PermGen PermGen had a fixed maximum size, which was often too small for applications with many classes. Correct Tuning was Tricky Even though it was configurable using -XX:MaxPermSize, tuning it correctly was difficult. PermGen was not dynamically expanding Unlike Metaspace, on the other hand, dynamically expands using native memory, eliminating manual tuning issues. OutOfMemoryError If class metadata exceeded 256MB, the application would crash with OutOfMemoryError: PermGen space. Key Features of Metaspace Stores Class Metadata It holds information about classes, methods, and their runtime representations (like method bytecode and field details). Unlike PermGen, it does not store Java objects (which reside in the heap). Uses Native Memory Unlike PermGen, which had a fixed maximum size, Metaspace dynamically expands using native memory(outside the heap), reducing Out of memory errors. Automatic Growth & GC Handling The JVM automatically manages Metaspace size based on the application’s needs. Class metadata is garbage collected when classes are no longer needed (such as when an application uses dynamic class loading). Configurable Maximum Size -XX:MaxMetaspaceSize=256m // Limits Metaspace to 256MB -XX:MetaspaceSize=128m // Initial size before expanding ☕ If this helped you — support my work: 👉 Buy Me a Coffee -https://lnkd.in/ebXVUJn2 #JVMInternals #JavaPerformance #MemoryManagement #SpringBoot #Microservices #SystemDesign

🚀 Learning Core Java – Mutable Strings in Java Today I explored Mutable Strings in Java and how they differ from immutable String objects. Unlike the String class (which is immutable), mutable strings allow us to modify the same object without creating new objects in memory. Java provides two classes for mutable strings: 🔹 StringBuffer 🔹 StringBuilder ⸻ 🔹 Default Capacity Both StringBuffer and StringBuilder have a default capacity of 16 characters. When the content exceeds the current capacity, Java automatically increases the size using this formula: 👉 New Capacity = (Current Capacity × 2) + 2 This allows dynamic resizing without manual memory handling. ⸻ 🔹 Important Methods ✔ append() Adds new content to the end of the existing string without creating a new object. ✔ delete() Allows modification by removing specific characters from the existing string. ✔ trimToSize() Reduces the capacity to match the current content length, optimizing memory usage. ⸻ 🔹 Key Difference The main difference between the two: ✔ StringBuffer → Thread-safe (synchronized) ✔ StringBuilder → Not thread-safe (faster in single-threaded environments) In most modern applications, StringBuilder is preferred unless thread safety is required. ⸻ 🔎 Key Takeaway: Use mutable strings when frequent modifications are needed to improve performance and reduce unnecessary object creation. Excited to keep strengthening my Java fundamentals! 🚀 #CoreJava #JavaProgramming #MutableStrings #StringBuilder #StringBuffer #JavaDeveloper #ProgrammingFundamentals #LearningJourney

Java Fundamentals Series – Day 5 Garbage Collection in Java : In Java, developers do not need to manually free memory. JVM automatically manages memory using Garbage Collection (GC). The Garbage Collector is an Mechanism were default implemented inside JVM which is Invoke automatically In java there has a method gC() which is present inside the System Class this gC() method is a static method so there is no need for object to invoke this method so we can able to access this particular method by the class name *** System.gC() ***. By help of this method we just provide the request to JVM to call the ** Garbage Collector ** but we cannot assure that it may or may not be call the GC . It is totally depends on JVM here we just provide request. What is Garbage Collection? Garbage Collection is the process of automatically removing unused objects from Heap memory. Why GC is Important? 1 Prevents memory leaks 2 Frees unused memory 3 Improves application performance How GC Works? 1 JVM identifies objects that are no longer referenced 2 These objects become eligible for garbage collection 3 GC reclaims the memory occupied by them 4 It removes the memory for anonymous. object Method : void finalize(): Incase we needed to do some set of work before GC get Called in that particular time we can use this finalize () this method is defined as protected for example - closing the file this like operation.we can able to provide inside this finalize() method #Java #GarbageCollection #JVM #BackendDeveloper #Placements

Understanding Map in Java — One of the Most Important Concepts in the Collections Framework The Map interface in Java is a powerful data structure used to store data in key–value pairs, where every key is unique and maps to a specific value. Let’s simplify it: Key Characteristics: - Stores data as Key → Value pairs - Keys must be unique (duplicate keys overwrite values) - Duplicate values are allowed - No indexing — access data using keys Common Map Implementations: - HashMap → Fastest performance (O(1)), no order guarantee - LinkedHashMap → Maintains insertion order - TreeMap → Sorted keys (O(log n)) - ConcurrentHashMap → Thread-safe for multi-threaded applications Most Used Methods: - put() – Add or update data - get() – Retrieve value - remove() – Delete entry - containsKey() – Check key existence - entrySet() – Iterate key-value pairs Interview Tip: - If ordering matters → use LinkedHashMap - If sorting is needed → use TreeMap - If performance matters → use HashMap Java Collections become much easier once you truly understand how Map works. What Map implementation do you use most in your projects #Java #JavaDeveloper #SpringBoot #BackendDevelopment #JavaCollections #Programming #SoftwareDevelopment #Coding #TechLearning

☕ Java Generics – Upper Bounded Wildcards Explained In Java Generics, the question mark (?) represents a wildcard, meaning an unknown type. Sometimes, we need to restrict the type of objects that can be passed to a method — especially when working with numbers or specific class hierarchies. That’s where Upper Bounded Wildcards come into play. 🔹 What is an Upper Bounded Wildcard? To restrict a wildcard to a specific type or its subclasses, we use: <? extends ClassName> This means: 👉 Accept ClassName or any of its subclasses. For example, if a method should only work with numeric types, we restrict it to Number and its subclasses like Integer, Double, etc. As explained in the document (Page 1), the syntax uses ? followed by the extends keyword to define the upper bound. 🔹 Practical Example From the example shown (Page 2), a method calculates the sum of elements in a list: public static double sum(List<? extends Number> numberlist) { double sum = 0.0; for (Number n : numberlist) sum += n.doubleValue(); return sum; } 📌 Why ? extends Number? ✔ Ensures only numeric types are allowed ✔ Accepts List<Integer> ✔ Accepts List<Double> ✔ Maintains type safety 🔹 Usage in Main Method List<Integer> integerList = Arrays.asList(1, 2, 3); System.out.println("sum = " + sum(integerList)); List<Double> doubleList = Arrays.asList(1.2, 2.3, 3.5); System.out.println("sum = " + sum(doubleList)); 🔹 Output (Page 3) sum = 6.0 sum = 7.0 This demonstrates how the same method works seamlessly with different numeric types. 💡 Upper bounded wildcards improve flexibility while maintaining compile-time type safety. They are essential for writing reusable and robust generic methods in Java. #Java #Generics #UpperBoundedWildcards #JavaProgramming #OOP #FullStackJava #Developers #AshokIT

🔹 What Does static Mean in Java? In Java, the static keyword means the member belongs to the class, not to the objects of the class. 👉 Static members are loaded into memory only once when the class is loaded. 👉 They are shared among all objects of that class. 🔹 Static Members of a Class A class can contain: ✔ Static Variables ✔ Static Methods ✔ Static Blocks These belong to the class memory (Method Area). Whereas: ❌ Instance variables ❌ Instance methods Belong to the object (heap memory). 🔹 Why Static is Important? 1️⃣ Memory Efficiency Since static members are created only once, they save memory when multiple objects are created. 2️⃣ No Object Required Static methods can be called directly using the class name: 🔹 Rules of Static (Very Important) ✅ Static methods CAN access: Static variables Static methods ❌ Static methods CANNOT directly access: Instance variables Instance methods ❌ Static methods CANNOT use: this keyword super keyword Why? Because static methods belong to the class, and this refers to an object. 🔹 Static Block A static block: Executes only once Runs when the class is loaded Executes before the main method 🔹 Flow of Execution in Java (Important for Interviews) Static variables Static block Main method Object creation Instance block Constructor Instance method I sincerely appreciate the structured learning approach at Tap Academy, which helps in building strong technical fundamentals. A special thanks to Sharth Sir for explaining the concept with exceptional clarity and depth. Your guidance has helped me strengthen my foundation in Core Java and understand concepts beyond just theory. #Java #CoreJava #Programming #OOP #SoftwareDevelopment #LearningJourney #TapAcadem

🚀 Java Series – Day 3 📌 Operators in Java 🔹 What is it? Operators are special symbols in Java used to perform operations on variables and values. Java mainly provides different types of operators such as: • Arithmetic Operators – + - * / % • Relational Operators – == != > < >= <= • Logical Operators – && || ! • Assignment Operators – = += -= *= /= • Increment / Decrement Operators – ++ -- 🔹 Why do we use it? Operators help programs perform calculations and make decisions. For example: In an e-commerce application, operators can be used to calculate the total price, check discount conditions, or verify whether a user is eligible for an offer. 🔹 Example: public class Main { public static void main(String[] args) { int a = 10; int b = 5; // Arithmetic operator System.out.println(a + b); // Relational operator System.out.println(a > b); // Logical operator System.out.println(a > 5 && b < 10); } } 💡 Key Takeaway: Operators are the building blocks of logic in Java programs and are essential for calculations and decision-making. What do you think about this? 👇 #Java #CoreJava #JavaDeveloper #Programming #BackendDevelopment

📌 Checked vs Unchecked Exceptions in Java ✨In Java, exceptions are events that disrupt the normal flow of a program. They are mainly classified into Checked Exceptions and Unchecked Exceptions. 🔹 Checked Exceptions ✨These are checked at compile time. ✨The compiler forces us to handle them using try-catch or throws keyword. ✨Common examples: IOException, FileNotFoundException, SQLException, ClassNotFoundException. ✨They help in writing reliable and error-free code by handling predictable issues. 🔹 Unchecked Exceptions ✨These are checked at runtime and are not mandatory to handle at compile time. ✨They usually occur due to programming mistakes. ✨Common examples: NullPointerException, ✨ArrayIndexOutOfBoundsException, ClassCastException, ArithmeticException. ✨If not handled, they can crash the program during execution. 💡 Understanding these exceptions helps developers write robust, secure, and maintainable Java applications. Thank you Anand Kumar Buddarapu Sir for your guidance and motivation. Learning from you was really helpful! 🙏 Heartfelt thanks to Uppugundla Sairam Sir and Saketh Kallepu Sir ,Grateful for the opportunity to learn and grow under your guidance. 🙏 #Java #ExceptionHandling #CoreJava #Programming #Learning

ArrayList ✈️ In Java, an ArrayList is a member of the Java Collections Framework and resides in the java.util package. While a standard Java array (e.g., int[]) is fixed in length, an ArrayList is a resizable-array implementation of the List interface. How It Works: The "Growing" Mechanism When you add an element to an ArrayList, Java checks if there is enough room in the underlying memory. If the internal array is full, the ArrayList performs the following: It allocates a new, larger array ✅Key Features in Java Type Safety: It uses Generics, allowing you to specify what type of data it holds (e.g., ArrayList<String>). Wrapper Classes: It cannot store primitive types (like int, double, char) directly. Instead, Java uses "Autoboxing" to convert them into objects (like Integer, Double, Character). Nulls and Duplicates: It allows you to store duplicate elements and null values. Unsynchronized: By default, it is not thread-safe. If multiple threads access it simultaneously, you must handle synchronization manually. It copies all existing elements to the new array. It updates its internal reference to this new array. ✅ArrayList vs. LinkedList A common interview question is when to use ArrayList over LinkedList. ArrayList: Best for frequent access and storing data where you mostly add/remove from the end. LinkedList: Best if you are constantly inserting or deleting items from the beginning or middle of the list. Would you like me to explain the specific differences between ArrayList and Vector, or perhaps show you how to sort an ArrayList using Collections.sort(). Huge thanks for the mentorship on Java ArrayList Anand Kumar Buddarapu Saketh Kallepu Uppugundla Sairam #ArrayList #Java #DataStructures #Programming #Coding #SoftwareEngineering #Backend #JavaDeveloper #Algorithms #TechTips #ComputerScience

📘 Day 8 | Core Java – Revision (Q&A) 🌱 Revising today’s Core Java topics by asking questions and validating my understanding 1. What is an array in Java? ➡️ An array is a collection of elements of the same data type stored in a continuous memory location. 2.What is method overloading? ➡️ Method overloading means defining multiple methods with the same name but different parameters in the same class. It is resolved at compile time. 3.What is method overriding? ➡️ Method overriding occurs when a subclass provides a specific implementation of a method already defined in its parent class. It supports runtime polymorphism. 4. What is the use of the super keyword? ➡️ The super keyword is used to refer to the parent class object, access parent class variables, methods, and constructors. 5.What is method hiding in Java? ➡️ Method hiding happens when a static method in a subclass has the same signature as a static method in the parent class. 6.What is typecasting in Java? ➡️ Typecasting is the process of converting one data type into another. 7.What is an abstract class? ➡️ An abstract class is a class declared using the abstract keyword and may contain abstract and non-abstract methods. 8.What is a concrete class? ➡️ A concrete class is a class that provides implementation for all methods and can be instantiated. 9.What is an interface? ➡️ An interface is a blueprint of a class that contains abstract methods and is used to achieve abstraction and multiple inheritance. 10.What is polymorphism in Java? ➡️ Polymorphism means one method performing different behaviors based on the object type. 11.What are the types of polymorphism? ➡️ Compile-time polymorphism (method overloading) and runtime polymorphism (method overriding). #CoreJava #JavaLearning #LearningJourney #Programming #MCAGraduate