Java Data Structures and Object-Oriented Programming Fundamentals

🚀 Java Array Cheat Sheet — Quick Revision Guide Arrays are one of the most fundamental data structures in Java. Here’s a quick overview every Java developer should know. ✅ What is an Array? An array is a fixed-size, index-based data structure that stores elements of the same data type. Examples: int[] a = new int[10]; // Array of 10 integers char[] c = new char[15]; // Array of 15 characters String[] s = new String[20]; // Array of 20 strings ✅ Array Structure 🔹Java arrays use zero-based indexing: 🔹First element → index 0 🔹Second element → index 1 and so on. int[] arr = {21, 15, 37, 53, 17}; ✅ Types of Arrays 🔹 Single Dimensional Array – One row of elements 🔹 Multidimensional Array – Array of arrays 2D Array 3D Array 🔹 Jagged Array (rows with different lengths) ✅ Array Declaration int[] arr; int arr[]; ✅ Array Initialization int[] arr = new int[5]; arr[0] = 21; ✅ Array Traversal for(int i=0; i<arr.length; i++){ System.out.println(arr[i]); } ✅ Useful Arrays Class Methods 🔹sort() → Sort array 🔹stream() → Convert to stream 🔹fill() → Fill values 🔹copyOf() → Copy array 🔹binarySearch() → Search element asList() → Convert array to list ✅ Advantages ☑️ Easy to use ☑️ Fast data access ☑️ Supports primitive & object types ❌ Limitations ✖ Fixed size ✖ No built-in dynamic resizing 💡 Arrays are the foundation for advanced data structures like Lists, Stacks, and Queues — master them first! #Java #Programming #JavaDeveloper #Parmeshwarmetkar #Coding #DataStructures #LearnJava

Day 21 – Accessing Non-Static Members of a Class in Java Yesterday I explored static members in Java. Today’s concept was the opposite side of it: 👉 Non-Static Members (Instance Members) Unlike static members, non-static members belong to objects, not the class itself. That means we must create an object of the class to access them. 🔹 Syntax new ClassName().memberName; or ClassName obj = new ClassName(); obj.memberName; 🔹 Example class Demo4 { int x = 100; int y = 200; void test() { System.out.println("running test() method"); } } class MainClass2 { public static void main(String[] args) { System.out.println("x = " + new Demo4().x); System.out.println("y = " + new Demo4().y); new Demo4().test(); } } Output x = 100 y = 200 running test() method 🔹 Important Observation Every time we write: new Demo4() ➡️ A new object is created. Each object has its own copy of non-static variables. This is why instance variables are object-specific, unlike static variables which are shared across objects. 📌 Key takeaway • Static members → belong to the class • Non-static members → belong to objects • Accessing instance members requires object creation Understanding this concept is essential for mastering Object-Oriented Programming in Java. Step by step building stronger Core Java fundamentals. #Java #CoreJava #JavaFullStack #OOP #Programming #BackendDevelopment #LearningInPublic #SoftwareDevelopment

Day 38 - 🚀 Understanding toString() in Java In Java, the toString() method is used to return a string representation of an object. It belongs to the Object class, which means every Java class inherits it by default. 📌 Default Behavior If you don't override toString(), Java prints a combination of class name + hashcode. class Person { String name; int age; } Person p = new Person(); System.out.println(p); Output: Person@1a2b3c This output is usually not very useful for users or developers. 📌 Overriding toString() To display meaningful object information, we override the toString() method. class Person { String name; int age; @Override public String toString() { return "Person[name=" + name + ", age=" + age + "]"; } } Output: Person[name=John, age=25] 📌 Why toString() is Important ✔ Provides a human-readable representation of objects ✔ Useful for debugging and logging ✔ Makes object data easier to print and understand 💡 Pro Tip Always use the @Override annotation when implementing toString() to ensure the method is correctly overridden. ✅ Conclusion The toString() method helps convert an object into a clear and readable string format, making debugging and displaying data much easier in Java applications. #Java #OOP #JavaProgramming #ToString #ProgrammingConcepts #SoftwareDevelopment

✨ Today’s Class Update – Java Typecasting & Variables ✨ Today’s session was focused on understanding Typecasting and Variables in Java, which are core concepts for building a strong programming foundation. 🔹 Typecasting is the process of converting one data type into another. It is classified into: Implicit Typecasting (Widening) – Converting a smaller data type into a larger data type. This conversion is done automatically by the Java compiler. Explicit Typecasting (Narrowing) – Converting a larger data type into a smaller data type. This is not done automatically and must be performed manually by the programmer. 🔹 We also learned about Variables, which act as containers to store data. Variables are classified into: Instance Variables – Created inside a class and stored in the heap memory. JVM provides default values for these variables. Local Variables – Created inside a method and stored in the stack memory. 🔹 The session also covered Java Memory Management, where RAM is shared memory and divided into four segments: Code Segment Static Segment Heap Segment Stack Segment High-level Java code is first converted into bytecode by the compiler, and then the JVM converts it into machine code. 🔹 Finally, we discussed Pass by Value and Pass by Reference: Pass by Value – A copy of the variable’s value is passed to the method, so changes inside the method do not affect the original variable. Pass by Reference – The address of the variable is passed, and multiple reference variables can point to the same object. Overall, it was a very informative class that helped me understand how Java handles data, memory, and method calls more clearly 🚀 #Java #Typecasting #CoreJava #Variables #MemoryManagement #LearningJourney #TapAcademy #Programming

#Post1 Internal working of HashMap And Hash collision 👇 When we insert a value: map.put("Apple", 10) Java performs these steps: 1️⃣ It calls hashCode() on the key. For example, Strings generate hash codes using a formula involving the prime number 31. 2️⃣ Using this hash, Java calculates the bucket index inside the internal array. Now the entry is stored inside that bucket. Example internal structure: Bucket Array [0] [1] [2] → (Apple,10) [3] [4] But what if two keys map to the same bucket? This situation is called a hash collision. Example: [2] → (Apple,10) → (Banana,20) → (Mango,30) HashMap handles collisions by storing multiple entries inside the same bucket. Before Java 8 • Entries were stored in a Linked List After Java 8 • If the bucket size grows beyond 8, the linked list is converted into a Red-Black Tree This improves search performance: O(n) → O(log n) Now let’s see what happens during get() when a bucket has multiple entries. When we call: map.get("Apple") Java performs these steps: 1️⃣ It recomputes the hashCode() of the key 2️⃣ It finds the same bucket index using (capacity - 1) & hash 3️⃣ If multiple nodes exist in that bucket, Java traverses the nodes For each node it checks: existingNode.hash == hash AND existingNode.key.equals(key) Once the correct key is found, the corresponding value is returned. Summary: Two different keys can generate the same hash, which causes a hash collision. HashMap handles collisions by storing entries as a Linked List or Red-Black Tree inside the bucket. 📌 Note HashMap is not thread safe. In the upcoming post, we will explore the thread-safe alternative to HashMap. #Java #SoftwareEngineering #BackendDevelopment #DataStructures #Programming #LearnInPublic

𝐒𝐭𝐫𝐞𝐧𝐠𝐭𝐡𝐞𝐧𝐢𝐧𝐠 𝐂𝐨𝐫𝐞 𝐉𝐚𝐯𝐚 🔹 Q1: What is the difference between Java stack and heap memory? Answer: Stack memory: Stores method calls and local variables. LIFO structure, automatically cleared after method execution. Heap memory: Stores objects and instance variables. Managed by Garbage Collector. Example: Stack = your desk (temporary work). Heap = storage room (long-term storage). 🔹 Q2: What is the difference between String Pool and normal String object? Answer: String Pool: Stores unique literals to save memory. New String objects: Stored in heap, independent of the pool. Example: String Pool = shared dictionary. New String = your personal notebook with the same words. 🔹 Q3: What are functional interfaces in Java? Answer: An interface with a single abstract method. Used in Java 8 for lambda expressions. Example: Runnable, Comparator. Real-life Example: Like a single-purpose tool, e.g., a screwdriver — one function, extremely focused. 🔹 Q4: What is the difference between HashMap, LinkedHashMap, and TreeMap? Answer: HashMap: Unordered, fast access. LinkedHashMap: Maintains insertion order. TreeMap: Sorted order (Red-Black tree). Example: HashMap = random box of items. LinkedHashMap = items in the order you added. TreeMap = items arranged alphabetically on a shelf. 🔹 Q5: What is Java serialization and why is it used? Answer: Serialization = convert object to byte stream for storage or transmission. Deserialization = restore it back to object. Example: Compressing a file to send via email and decompressing it on the recipient side. #Java #CoreJava #JavaInterviewQuestions #JavaDeveloper #BackendDeveloper #SoftwareEngineer #TechCareers #DailyLearning

🛑 A Quick Java Memory Guide Understanding the Java Memory Model is non-negotiable for writing performant, bug-free code. If you don’t know where your data lives, you don’t really know Java. Here is the breakdown of Stack vs Heap: 🧠 The Stack (LIFO - Last In, First Out) · What lives here: Primitive values (int, double) and references to objects (pointers). · Scope: Each thread has its own private stack. Variables exist only as long as their method is running. · Access Speed: Very fast. · Management: Automatically freed when methods finish. 🗄️ The Heap (The Common Storage) · What lives here: The actual objects themselves (all instances of classes). · Scope: Shared across the entire application. · Access Speed: Slower than the stack due to global access. · Management: Managed by the Garbage Collector (GC). 💡 The Golden Rule: The reference is on the Stack, but the object it points to is on the Heap. Map<String, String> myMap = new HashMap<>(); (Stack: myMap) --> (Heap: HashMap object) 👇 Q1: If I declare int id = 5; inside a method, where is this value stored? A1: Stack. It's a local primitive variable, so it lives directly in the stack frame. Q2: I created an array: int[] data = new int[100];. The array holds primitives. Is the data stored on the Stack or Heap? A2: Heap. The array itself is an object in Java. The reference data lives on the Stack, but the 100 integers are stored contiguously on the Heap. Q3: What happens to memory if I pass this object reference to another method? A3: A copy of the reference is passed (passed by value). Both methods now have a pointer (on their respective stacks) to the same single object on the Heap. ♻️ Repost if you found this helpful! Follow me for more Java wisdom. #Java #Programming #SoftwareEngineering #MemoryManagement #Coding

🚀 Java 8 Streams – Word Frequency in a Sentence Here’s a classic interview-style problem 👇 🧩 Input: String str = "I am learning Streams API in JAVA JAVA"; 🎯 Goal: Count the frequency of each word using the power of Java Streams API. At first, we might think of using a Map and a loop. But with Java 8 Streams, we can make it expressive and concise. 💡 Solution: String str = "I am learning Streams API in JAVA JAVA"; Map<String, Long> wordCount = Arrays.stream(str.split(" ")) .collect(Collectors.groupingBy( word -> word, Collectors.counting())); wordCount.forEach((key, value) -> System.out.println(key + " : " + value)); 🔎 What’s happening here? • split(" ") → Breaks sentence into words • stream() → Creates a stream • groupingBy() → Groups identical words • counting() → Counts occurrences Simple. Clean. Powerful ✨ Want to make it better? You could: 1️⃣ Convert everything to lowercase to make it case-insensitive Problems like this show how beautifully Streams handle data transformation with minimal code. #Java #Java8 #Streams #BackendDevelopment #CodingInterview #SoftwareEngineering #LearningJourney #LearnWithMe

🚀Why String is Immutable in Java? — Explained Simply🧠💡!! 👩🎓In Java, a String is immutable, which means once a String object is created, its value cannot be changed. If we try to modify it, Java creates a new String object instead of changing the existing one. 📌But why did Java designers make Strings immutable? 🤔 ✅ 1️⃣ Security Strings are widely used in sensitive areas like database URLs, file paths, and network connections. Immutability prevents accidental or malicious changes. ✅ 2️⃣ String Pool Optimization Java stores Strings in a special memory area called the String Pool. Because Strings are immutable, multiple references can safely share the same object — saving memory. ✅ 3️⃣ Thread Safety Immutable objects are naturally thread-safe. Multiple threads can use the same String without synchronization issues. ✅ 4️⃣ Performance & Caching Hashcodes of Strings are cached. Since values never change, Java can reuse hashcodes efficiently, improving performance in collections like HashMap. 🧠 Example: String name = "Java"; name = name.concat(" Dev"); Here, the original "Java" remains unchanged, and a new object "Java Dev" is created. 🚀 Understanding small concepts like this builds strong Core Java fundamentals and helps you write better, safer, and optimized code. #Java #CoreJava #Programming #JavaDeveloper #CodingConcepts #SoftwareEngineering #LearningEveryday #Parmeshwarmetkar

🚀 Experimenting with Multithreading in Java – Real Performance Impact Recently, I built a multi-threaded web crawler in Java to understand the real-world impact of concurrency. The crawler scrapes product data (title + price) from a paginated website and stores it in a CSV file. 🧪 The Experiment: I ran the same crawler with different thread pool sizes. Case 1: Single Thread Execution time: ~678 seconds Tasks executed sequentially. Each HTTP request completed before the next one started. Case 2: 20 Threads (FixedThreadPool(20)) Execution time dropped dramatically. Multiple product pages were fetched in parallel, significantly reducing total runtime. 💡 Key Insight: The crawler is I/O-bound, not CPU-bound. Most of the time is spent waiting on network calls and server responses. While one thread waits for a response, other threads can continue working. That’s where multithreading creates massive performance gains. 📌 What I Learned: Thread pools drastically improve throughput for I/O-heavy systems. Too many threads can hurt performance due to context switching, memory overhead, and potential server throttling. Optimal thread count depends on CPU cores and the ratio of wait time to compute time. There’s even a formula: Optimal Threads ≈ CPU Cores × (1 + Wait Time / Compute Time) 🏗 Technical Takeaways Used ExecutorService with FixedThreadPool Implemented synchronized CSV storage for thread safety Used awaitTermination() to measure actual execution time Learned the importance of safe resource sharing in concurrent systems This experiment reinforced one key lesson: Multithreading isn’t just about parallelism — it’s about understanding where your system actually waits. #Java #Multithreading #BackendDevelopment #PerformanceEngineering #Concurrency