Java Stack Mistake: Using remove() vs pop() in Balanced Brackets Problem

🚀 From Writing Code to Understanding Memory — My Java Learning (Post #3) 🧠💻 In my previous posts, I shared what I learned about Access Modifiers and Non-Access Modifiers. This time, I wanted to go a bit deeper into something I’ve been using without really thinking about it: 👉 Where do variables and objects actually live in Java? Here’s my current understanding 👇 🧠 Java doesn’t directly use memory — it runs inside the JVM, which manages how data is stored in RAM. The three main areas I focused on: 🔹 Stack Memory (Execution Area) ⚡ Used for method calls and local variables. public class Main { public static void main(String[] args) { int x = 10; int y = 20; } } Here, x and y are stored in the Stack. ✔️ Fast ✔️ Temporary ✔️ Automatically cleared after execution 🔹 Heap Memory (Object Storage) 📦 Used for storing objects and instance variables. class Student { int age; } public class Main { public static void main(String[] args) { Student s1 = new Student(); s1.age = 25; } } What clicked for me here: 👉 s1 is just a reference (stored in Stack) 👉 The actual object is stored in Heap 🔹 Static Variables (Class-Level Memory) 🏫 This part confused me at first 👀 class Student { static String schoolName = "ABC School"; } ✔️ Not stored in Stack ✔️ Not inside objects in Heap 👉 Stored in a special area (Method Area) 👉 Only ONE copy exists and is shared across all objects 💡 Real-world example that helped me: Think of a university system 🎓 • Students → Objects (Heap) • Student ID → Reference (Stack) • University Name → Static variable (shared across all students) 📌 Key takeaways: ✔️ Stack = execution (temporary data) ✔️ Heap = object storage ✔️ Static = class-level shared data ✔️ JVM manages memory (physically stored in RAM) This topic really changed how I look at Java code. Earlier, I was just writing programs — now I’m starting to understand what happens behind the scenes 🔍 I’m currently focusing on strengthening my Core Java fundamentals, and I’d really appreciate any feedback, corrections, or guidance from experienced developers here 🙌 🚀 Next, I’m planning to explore Garbage Collection and how JVM manages memory efficiently. #JavaDeveloper #BackendEngineering #JavaInternals #SoftwareDevelopment #TechLearning #CodeNewbie

Day 39 of Learning Java: Downcasting & instanceof Explained Clearly 1. What is Downcasting? Downcasting is the process of converting a parent class reference → child class reference. It is the opposite of Upcasting. 👉 Key Points: Requires explicit casting Used to access child-specific methods Only works if the object is actually of the child class Example: class A {} class B extends A {} A ref = new B(); // Upcasting B obj = (B) ref; // Downcasting 💡 Here, ref actually holds a B object, so downcasting is safe. 2. When Downcasting Fails If the object is NOT of the target subclass → it throws: ClassCastException 📌 Example: A ref = new A(); B obj = (B) ref; // Runtime Error 👉 This is why we need a safety check! 3. instanceof Keyword (Safety Check ) The instanceof keyword is used to check whether an object belongs to a particular class before casting. 📌 Syntax: if (ref instanceof B) { B obj = (B) ref; } 💡 Prevents runtime errors and ensures safe downcasting. 4. Real-World Example class SoftwareEngineer { void meeting() { System.out.println("Attending meeting"); } } class Developer extends SoftwareEngineer { void coding() { System.out.println("Writing code"); } } class Tester extends SoftwareEngineer { void testing() { System.out.println("Testing application"); } } 📌 Manager Logic using instanceof: void review(SoftwareEngineer se) { if (se instanceof Developer) { Developer dev = (Developer) se; dev.coding(); } else if (se instanceof Tester) { Tester t = (Tester) se; t.testing(); } } 💡 This is a real use of polymorphism + safe downcasting 5. Key Rules to Remember ✔ Downcasting requires upcasting first ✔ Always use instanceof before downcasting ✔ Helps access child-specific behavior ✔ Wrong casting leads to runtime exceptions 💡 My Key Takeaways: Upcasting gives flexibility, Downcasting gives specificity instanceof is essential for writing safe and robust code This concept is widely used in real-world applications, frameworks, and APIs #Java #OOP #LearningInPublic #100DaysOfCode #Programming #Developers #JavaDeveloper #CodingJourney

🚀 Day 3 of my Java journey — OOP concepts! (Part 1) Today I explored Object Oriented Programming — the heart of Java! 🫀 ⚙️ Method Overloading ✅Same Class, Same method name, different parameters ✅ Example: add(int a, int b) ,add(int a, int b,int c) and add(double a, double b) ✅ Decided at compile time ✅Socho ek calculator hai — add button ek hi hai lekin tum 2 number bhi jod sakte ho, 3 number bhi! Same naam, alag parameter! 🔁 Method Overriding ✅ Child class redefines parent class method ✅ Same name, same parameters — different behaviour ✅ Decided at runtime — this is polymorphism! ✅Method Overriding — Child apna kaam khud karta hai ✅(Socho Papa kehte hain "khana khao" — matlab roti khao. Lekin beta kehta hai "khana khao" — matlab pizza khao! Same baat, alag matlab! ) ✅child apne papa ka kaam badal deta hai 🔑 this keyword ✅ Refers to the current object inside a class ✅ Used to avoid confusion between class variables and method parameters ✅this — "Main khud hoon(Intense variable,method and constructor )" 👨👩👦 super keyword ✅ Used to call parent class methods or constructor ✅ super() calls parent constructor ✅ super.methodName() calls parent method ✅ super — "Mere papa hain(parent Class)" 🧬 Inheritance ✅ Child class inherits properties and methods from parent class ✅ Single inheritance — one parent, one child ✅ Multiple inheritance via interfaces (Java does not allow multiple class inheritance directly) 💉 Dependency Injection(DI) ✅ Instead of creating objects inside a class, we pass them from outside ✅ Makes code flexible, testable and clean ✅ Used heavily in Spring Boot (next goal!) Socho tumhara ek Car hai. Car ko Engine chahiye. ✅Bina DI: Car khud engine banati hai andar — agar engine badlani ho toh poori car todna padega! ✅DI ke saath: Engine bahar se car mein daali jaati hai — engine badlo, car wahi rehti hai! ✅Galat tarika — tightly coupled ✅cheez bahar se do, andar mat banao OOP is not finished yet — Day 4 will cover more! 🔥 Day 1 ✅ | Day 2 ✅ | Day 3 ✅ | Day 4 coming... If you are on a similar Java journey, connect with me! 🙏 #Java #JavaDeveloper #OOP #ObjectOrientedProgramming #Inheritance #Polymorphism #DependencyInjection #100DaysOfCode #BackendDevelopment #TechCareer

How Java Achieves Platform Independence One of the biggest strengths of Java is its ability to run anywhere without modification. Understanding platform independence is essential for every programming student and developer. 1. Bytecode Compilation   - Java code is compiled into bytecode, not machine code   - This makes the output platform-neutral  2. JVM Abstraction   - The Java Virtual Machine acts as an intermediary   - It allows the same bytecode to run on different systems  3. Standard Java APIs   - Provides consistent libraries across platforms   - Ensures uniform behavior regardless of OS  4. Architecture-Neutral Format   - Bytecode is independent of hardware architecture   - Eliminates compatibility issues  5. WORA Principle (Write Once, Run Anywhere)   - Write code once and execute it anywhere   - No need for platform-specific changes  6. Cross-Platform Execution Flow   - Source code compiled via JAVAC → Bytecode   - Bytecode executed by JVM on Windows, Linux, Mac, etc.  Mastering these concepts helps you write scalable, portable, and efficient Java applications. Need help with Java assignments or programming projects? Message us or visit our website. I searched 300 free courses, so you don't have to. Here are the 35 best free courses. 1. Data Science: Machine Learning Link: https://lnkd.in/gUNVYgGB 2. Introduction to computer science Link: https://lnkd.in/gR66-htH 3. Introduction to programming with scratch Link: https://lnkd.in/gBDUf_Wx 3. Computer science for business professionals Link: https://lnkd.in/g8gQ6N-H 4. How to conduct and write a literature review Link: https://lnkd.in/gsh63GET 5. Software Construction Link: https://lnkd.in/ghtwpNFJ 6. Machine Learning with Python: from linear models to deep learning Link: https://lnkd.in/g_T7tAdm 7. Startup Success: How to launch a technology company in 6 steps Link: https://lnkd.in/gN3-_Utz 8. Data analysis: statistical modeling and computation in applications Link: https://lnkd.in/gCeihcZN 9. The art and science of searching in systematic reviews Link: https://lnkd.in/giFW5q4y 10. Introduction to conducting systematic review Link: https://lnkd.in/g6EEgCkW 11. Introduction to computer science and programming using python Link: https://lnkd.in/gwhMpWck Any other course you'd like to add? Follow Programming [Assignment-Project-Coursework-Exam-Report] Helper For Students | Agencies | Companies for more #JavaProgramming #ProgrammingHelp #ComputerScience #Coding #SoftwareDevelopment #AssignmentHelp #TechEducation #j15

🚀 Ever wondered what really happens when your Java code runs? 🤔 Let’s peel back the layers and uncover the deterministic, and highly optimized execution flow of Java code—because understanding this isn’t just academic, it’s transformational for writing efficient systems. 🔍 1. Compilation: From Human Logic to Bytecode When you write Java code, the javac compiler doesn’t convert it directly into machine code. Instead, it produces platform-independent bytecode. 👉 This is where Java’s "Write Once, Run Anywhere" promise begins—clean, structured, and universally interpretable instructions. ⚙️ 2. Class Loading: Dynamic & Lazy The ClassLoader subsystem kicks in at runtime, loading classes on demand—not all at once. This involves three precise phases: Loading → Bytecode enters memory Linking → Verification, preparation, resolution Initialization → Static variables & blocks executed 💡 This lazy loading mechanism is what makes Java incredibly memory-efficient and modular. 🧠 3. Bytecode Verification: Security First Before execution, the JVM performs rigorous bytecode verification. It ensures: No illegal memory access Proper type usage Stack integrity 👉 This step is Java’s silent guardian, preventing malicious or unstable code execution. 🔄 4. Execution Engine: Interpretation vs JIT Compilation Here’s where things get fascinating. The JVM uses: Interpreter → Executes bytecode line-by-line (fast startup) JIT Compiler (Just-In-Time) → Converts hot code paths into native machine code 🔥 The result? A hybrid execution model that balances startup speed with runtime performance. 🧩 5. Runtime Data Areas: Structured Memory Management Java doesn’t just run code—it orchestrates memory intelligently: Heap → Objects & dynamic allocation Stack → Method calls & local variables Method Area → Class metadata PC Register & Native Stack → Execution tracking 💡 This segmentation ensures predictable performance and scalability. ♻️ 6. Garbage Collection: Autonomous Memory Reclamation Java eliminates manual memory management with sophisticated garbage collectors. From Mark-and-Sweep to G1 and ZGC, the JVM continuously: Identifies unused objects Reclaims memory Optimizes allocation 👉 This results in robust, leak-resistant applications with minimal developer intervention. 💥 Why This Matters Understanding this flow isn’t just theoretical—it empowers you to: ✔ Write high-performance code ✔ Diagnose memory and latency issues ✔ Leverage JVM optimizations effectively 🔥 Java isn’t just a language—it’s a meticulously engineered execution ecosystem. So next time you run a .java file, ask yourself: 👉 Am I just coding… or truly understanding the machine beneath? #Java #JVM #Programming #SoftwareEngineering #Performance #Developers #TechInsights

🚀 Java Learning Progress – Key Features from Java 8 → Java 21 As part of strengthening my Java fundamentals, I revised the major improvements introduced in different Java versions. Here is a simple summary from Java(LTS) 8 to Java 21 that helped me understand the evolution of the language. ☕ Java 8 (2014) – Functional Programming in Java Major shift in Java programming style. Key Features • Lambda Expressions • Stream API • Functional Interfaces • Default & Static methods in Interfaces • New Date & Time API Example – Lambda Expression List<Integer> list = Arrays.asList(1,2,3,4); list.forEach(n -> System.out.println(n)); Why it matters ✔ Less boilerplate code ✔ Functional programming style ✔ Powerful data processing with Streams ☕ Java 11 (2018) – Modern HTTP Client & Utilities Java 11 is an LTS (Long Term Support) version. Key Features • New HTTP Client API • String utility methods (isBlank, lines, strip) • Files.readString() • Run Java without compilation Example – HTTP Client HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://example.com")) .build(); Why it matters ✔ Easier REST API calls ✔ Cleaner String handling ☕ Java 17 (2021) – Modern Object-Oriented Features Another LTS version widely used in enterprise applications. Key Features • Sealed Classes • Pattern Matching for instanceof • Enhanced Switch Expressions • Strong encapsulation of JDK internals Example – Pattern Matching if (obj instanceof String s) { System.out.println(s.toUpperCase()); } Why it matters ✔ Cleaner and safer code ✔ Reduced type casting ☕ Java 21 (2023) – High Performance Concurrency Latest LTS version. Key Features • Virtual Threads (Project Loom) • Record Patterns • Pattern Matching for switch • Sequenced Collections Example – Virtual Thread Thread.startVirtualThread(() -> { System.out.println("Hello from Virtual Thread"); }); Why it matters ✔ Handle millions of concurrent requests ✔ Great for microservices and cloud systems 📌 My Key Takeaway Java has evolved from object-oriented programming → functional programming → modern concurrency. Understanding these features helps in writing clean, scalable, and high-performance applications. #Java #JavaDeveloper #LearningInPublic #SoftwareEngineering #Java8 #Java11 #Java17 #Java21

Mastering Asynchronous Programming in Java with CompletableFuture Most backend systems slow down not because of bad logic, but because everything runs sequentially. Every API call, database query, or external request adds delay. So here’s a better approach: Why wait, when tasks can run independently? 👉What is CompletableFuture? CompletableFuture (Java 8) lets you: - Run tasks asynchronously - Chain operations cleanly - Handle failures without breaking flow The Key Idea java CompletableFuture.supplyAsync(() -> "Hello") .thenApply(s -> s + " World"); - thenApply() → transforms result - thenCompose() → chains async calls Running Tasks in Parallel java CompletableFuture.allOf(f1, f2, f3).join(); Multiple tasks. No blocking. Better performance. Handling Failures java future.handle((res, err) -> res != null ? res : "Fallback"); No crashes. Just controlled behavior. Final Thought Synchronous code waits. Asynchronous code scales. If you're building APIs or working with Spring Boot, understanding CompletableFuture is not optional anymore—it’s essential. #Java #SpringBoot #BackendDevelopment #AsyncProgramming #Multithreading

my Java Journey... Today I went deeper than just theory. I actually wrote a program that talks to the user. And it felt like real coding for the first time. What I built today A program that: - Asks for your name - Asks for your city - Then greets you personally Simple? Yes. But to build this I had to understand 3 important concepts. Concept 1 — Scanner Class Java does not take user input automatically. You have to tell it to listen. That is what Scanner does. javaimport java.util.Scanner; Scanner sc = new Scanner(System.in); Think of Scanner like a microphone. You turn it on — now Java can hear the user. Concept 2 — nextLine() To actually read what the user types — javaString name = sc.nextLine(); nextLine() waits for the user to type something and press Enter. Then stores it in the variable. Concept 3 — String Concatenation ➕ Combining text and variables together in one line. javaSystem.out.println("Hello " + name + " from " + city); That + sign joins everything together. Output: Hello Raj from Mumbai The full program javapackage abstraction; import java.util.Scanner; public class demo3 {   public static void main(String[] args) {     System.out.println("main starts");     Scanner sc = new Scanner(System.in);     System.out.println("enter your name");     String name = sc.nextLine();     System.out.println(name);     System.out.println("enter your city");     String city = sc.nextLine();     System.out.println(city);     System.out.println("Hello " + name + " from " + city);     sc.close();     System.out.println("main ends");   } } Wait — sc.close(). Why? Always close your Scanner after use. It frees up memory. Like turning off the microphone when you are done talking. This is called good coding practice. And recruiters notice this. What this taught me beyond the code A program is not just logic. It is a conversation between the user and the machine. Your job as a developer or automation tester — Is to make that conversation smooth, clean and error free. 3 things recruiters look for even in beginner code: - Clean structure — proper indentation, readable code - Good practices — closing Scanner, meaningful variable names - Understanding flow — knowing WHY each line exists, not just copying it I am not just writing code. I am building habits that will make me hireable. #qa #corejava #job #manualtesting #hiringqa #automationtesting

Hello Connections, Post 17 — Java Fundamentals A-Z ☕ Java Streams have completely transformed coding approach. 🚀 However, many developers still have misconceptions about what a Stream truly is. Let's clear the air! 💡 🚫 What a Stream is NOT: ❌ A data structure ❌ A place to store data ❌ Anything like an ArrayList ✅ What a Stream actually IS: 🌊 A pipeline that processes data 📖 Reads from a source ⚙️ Transforms it step by step 🏁 Produces a result Example in Action: 💻 List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); long count = names.stream() // 1. SOURCE 📥 .filter(n -> n.length() > 3) // 2. INTERMEDIATE ⚙️ .count(); // 3. TERMINAL 🏁 System.out.println(count); // Output: 3 ⚠️ The Golden Rule: Streams are LAZY! 😴 Stream<String> stream = names.stream() .filter(n -> { System.out.println("Checking: " + n); return n.length() > 3; }); // 🤫 Nothing happens yet! stream.count(); // 🔥 NOW it runs! This laziness is a superpower—it avoids unnecessary processing, even in pipelines with millions of records! ⚡ 🧠 Quick Quiz — Test Your Knowledge! Problem 1 — What is the output? 🔢 List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); long result = nums.stream().filter(n -> n > 2).count(); System.out.println(result); 👉 Answer: 3 (Numbers 3, 4, and 5 pass the filter!) Problem 2 — How many times does filter run? ⏱️ List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); Optional<String> result = names.stream() .filter(n -> n.startsWith("C")) .findFirst(); 👉 Answer: 3 times (Alice ❌, Bob ❌, Charlie ✅... then it stops!) Problem 3 — Will this print anything? 🙊 List<Integer> nums = Arrays.asList(1, 2, 3); Stream<Integer> stream = nums.stream() .filter(n -> n > 1) .map(n -> n * 2); 👉 Answer: Nothing! Remember: No terminal operation = No execution! 🚫 Post 17 Summary: 📝 🔴 Unlearned → "Stream is just another collection." 🟢 Relearned → "Stream is a lazy processing pipeline." 🤯 Biggest surprise → filter() does NOTHING without a terminal operation! Follow along for more👇 #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2 #CodingTips #SoftwareEngineering

🚀 Core Java Learning Journey Explored Types of Constructors in Java (In Depth) ☕ 🔹 Constructors are special methods used to initialize objects when they are created. They help in setting up the initial state of an object. 📌 1️⃣ Default Constructor (Implicit) - Provided automatically by Java if no constructor is defined - Does not take any parameters - Initializes instance variables with default values: - "int → 0" - "boolean → false" - "char → '\u0000'" - "reference types → null" - Mainly used for basic object creation without custom initialization 💡 Example: class Student { int id; String name; } 👉 Here, Java internally provides a default constructor --- 📌 2️⃣ No-Argument Constructor (Explicit) - Defined by the programmer without parameters - Used to assign custom default values instead of Java defaults - Improves control over object initialization 💡 Example: class Student { int id; String name; Student() { id = 100; name = "Default"; } } --- 📌 3️⃣ Parameterized Constructor - Accepts parameters to initialize variables - Allows different objects to have different values - Helps in making code more flexible and reusable 💡 Example: class Student { int id; String name; Student(int id, String name) { this.id = id; this.name = name; } } --- 🎯 Key Takeaway: - Default constructor → Automatic initialization - No-argument constructor → Custom default values - Parameterized constructor → Dynamic initialization Learning and growing at Dhee Coding Lab 💻 #Java #CoreJava #Constructors #OOP #Programming #LearningJourney #FullStackDevelopment