Java String Behavior: Why Identical Strings Differ

🚀 Day 14/30 – Java DSA Challenge 🔎 Problem 64: 1614. Maximum Nesting Depth of the Parentheses (LeetCode – Easy) Continuing Day 14 with another fundamental problem focused on Stack usage and Parentheses Processing, which is a very common interview pattern. 🧠 Problem Summary Given a valid parentheses string, the task is to determine the maximum nesting depth. 👉 Nesting depth represents how many parentheses are open simultaneously at any point. Example: (1+(2*3)+((8)/4))+1 Here, digit 8 lies inside 3 nested parentheses, so the answer is 3. 💡 Key Insight Every time we encounter: "(" → Depth increases ")" → Depth decreases So, tracking currently open parentheses helps us determine the maximum depth reached during traversal. A Stack naturally models this behavior. 🔄 Approach Used 1️⃣ Traverse the string character by character 2️⃣ Push '(' into stack when opening bracket appears 3️⃣ Pop when closing bracket appears 4️⃣ Track maximum stack size during traversal 5️⃣ Maximum stack size = Maximum nesting depth ⏱ Complexity Analysis Time Complexity: 👉 O(N) — Single traversal of string Space Complexity: 👉 O(N) — Stack storage in worst case 📌 Concepts Strengthened ✔ Stack Data Structure ✔ Parentheses Validation Logic ✔ Depth Tracking ✔ String Traversal ✔ Simulation Technique 📈 Learning Reflection Problems like this highlight how simple data structures elegantly solve structural problems. Understanding stack behavior builds strong foundations for: Expression evaluation Compiler parsing Balanced parentheses problems ✅ Day 14 Progress Update 🔥 64 Problems Solved — Still Consistent Small daily improvements → Long-term mastery 🚀 #Day14 #30DaysOfDSA #Java #LeetCode #Stack #DSAJourney #ProblemSolving #CodingConsistency #InterviewPreparation #LearningEveryday

Day 22 – Reference Variables in Java Today I explored an important concept in Object-Oriented Programming — Reference Variables. Unlike primitive variables, reference variables store the address of an object, not the actual value. 🔹 What is a Reference Variable? A reference variable is a non-primitive variable that refers to an object created from a class. It is declared using the class name. Syntax: ClassName referenceVariable; Initialization- referenceVariable = new ClassName(); Or both together: ClassName referenceVariable = new ClassName(); Here: ClassName → Name of the class referenceVariable → Object reference new → Keyword used to create an object ClassName() → Constructor 🔹 Example class Demo5 { int x = 100; int y = 200; } class MainClass3 { public static void main(String[] args) { Demo5 d1 = new Demo5(); System.out.println("x = " + d1.x); System.out.println("y = " + d1.y); System.out.println("modifying x & y"); d1.x = 300; d1.y = 400; System.out.println("x = " + d1.x); System.out.println("y = " + d1.y); } } Output: x = 100 y = 200 modifying x & y x = 300 y = 400 🔹 Important Observation When we write: Demo5 d1 = new Demo5(); Java performs three things: 1️⃣ Creates a reference variable (d1) 2️⃣ Creates a new object in memory 3️⃣ Stores the object reference in the variable #Java #CoreJava #JavaFullStack #OOP #Programming #BackendDevelopment #LearningInPublic #SoftwareDevelopment

Day 37 - 🚀 Rules of Method Overriding in Java Method Overriding is a key concept in Object-Oriented Programming (OOP) that allows a subclass to provide a specific implementation of a method already defined in its superclass. It helps achieve Runtime Polymorphism in Java. 📌 Important Rules of Method Overriding: 🔹 1. Same Method Name The method in the subclass must have the same name as in the superclass. 🔹 2. Same Method Parameters The number, type, and order of parameters must be exactly the same. 🔹 3. Return Type The return type must be the same or a covariant type (subtype) of the parent method. 🔹 4. Access Modifier Rule The subclass method cannot reduce visibility. Example: ✔ protected → public ✔ default → protected ❌ public → private 🔹 5. Final Methods Cannot Be Overridden If a method is declared final, it cannot be overridden. 🔹 6. Static Methods Cannot Be Overridden Static methods belong to the class and are method hidden, not overridden. 🔹 7. Private Methods Cannot Be Overridden Private methods are not inherited, so they cannot be overridden. 🔹 8. Exception Handling Rule The child class method cannot throw broader checked exceptions than the parent method. 🔹 9. Use @Override Annotation Using @Override helps the compiler check whether the method is correctly overridden. 💡 Conclusion: Method Overriding enables runtime polymorphism, making Java programs more flexible, maintainable, and scalable. #Java #OOP #MethodOverriding #JavaProgramming #ProgrammingConcepts #SoftwareDevelopment

Second article about tree translation in Java is out! In this post I explored how JavaPoet works and how it can help with automatic AST translation. https://lnkd.in/dDSFv3xh

I learned a surprising Java concept. Two Java keywords exist… But we can’t actually use them. They are: • goto • const Both are reserved keywords in Java. But if you try to use them, the compiler throws an error. So why do they exist? Let’s start with goto. In older languages like C and C++, goto allowed jumping to another part of the code. Sounds powerful, right? But it often created messy and confusing programs — commonly called “spaghetti code.” When Java was designed, the creators decided to avoid this problem completely. Instead of goto, Java encourages structured control flow using: break continue return This makes programs easier to read and maintain. Now the second keyword: const. In languages like C/C++, const is used to declare variables whose value cannot change. Java handles this differently using the final keyword. Example: final int x = 10; Once declared final, the value cannot be modified. And here’s the interesting part Java kept goto and const as reserved words so developers cannot accidentally use them as identifiers. Sometimes the smartest design decision in a programming language is what it chooses NOT to include. Learning programming isn’t just about syntax. It’s about understanding why the language was designed this way. A special thanks to my mentor Syed Zabi Ulla for explaining programming concepts with such clarity and always encouraging deeper understanding rather than just memorizing syntax. #Java #Programming #Coding #LearnToCode #DeveloperJourney

The Magic of @SneakyThrows in Java: How Does It Break the Rules? Lombok’s @SneakyThrows often raises questions in code reviews. It allows us to throw a checked exception (like IOException) without adding a throws clause - something Java normally forbids. The Problem: Java forces you to catch checked exceptions or declare them. This is especially frustrating with lambdas, where adding a throws declaration isn't an option. How does this work? Lombok uses bytecode manipulation. It replaces your checked exception with a generic throw that bypasses the compiler's checks. At runtime, the exception is thrown normally, but the compiler never sees the violation. It’s a clean solution for edge cases - just use it intentionally. While @SneakyThrows makes the code look cleaner, it breaks the method signature contract. Consumers of your method won't know they need to handle that exception, which can lead to unexpected application crashes. It also violates the Principle of Least Astonishment - other developers reading the code won't expect a checked exception to appear out of nowhere, making debugging and maintenance more difficult. But despite these risks, it's hard to deny how pleasant @SneakyThrows feels to use. The code becomes so clean and readable - no more wrapping everything in try-catch blocks just to satisfy the compiler. When you're working with streams or quick scripts, that single annotation removes the noise and lets the business logic shine. Do you use @SneakyThrows in your projects? Let’s discuss below! 👇 #Java #Programming #Lombok #SoftwareDevelopment #CodingTips

Most of us, when we started Competitive Programming in Java, understood that using the Scanner class for taking inputs and System.out.print() for outputs can make our programs slower, so we quickly switched to BufferedReader and BufferedWriter by following a standard template, which improved the execution time. I decided to understand both to see how they differ and what makes the latter one faster. Honestly, the logic was simple. BufferedReader and BufferedWriter use a buffer to store a large chunk of an input stream in a single I/O operation, then break it up internally according to the needs, using a StringTokenizer or any other means.   Scanner does internal parsing and reads input token by token. It performs extra processing like regex matching, which makes it convenient but slower. It also takes care of token validation internally. BufferedReader works differently. It reads a large chunk of data into memory at once (a buffer) and then processes it. Instead of interacting with the input stream repeatedly, it reduces the system calls made. It just reads the stream and does not do any special parsing. Moreover, Scanner is also not thread safe.   This doesn’t mean Buffered Reader is better than Scanner in any way, though; it depends on specific use cases and what we want.   I decided to learn Java I/O properly and tried to understand how input/output streams and reader/writer classes work. It was fun. 😊 It fascinates me how engineers have tailored systems with clever techniques for several use cases. Happy Coding :)   #Java #Coding #CompetitiveProgramming #SoftwareEngineering

Why "Thinking in Objects" is the Ultimate Superpower in Java 🚀 If you are just starting your journey into Object-Oriented Programming (OOP), the terminology can feel like a foreign language. "Classes," "Objects," "Methods," "Instances"—it’s a lot to take in. But if you look at this illustration, you’ll see that coding isn’t just about syntax; it’s about architecture. 1. The Class: Your Architectural Blueprint 📜 The left side of the image shows the Class House. In Java, a class is not a thing; it is a template. It defines: Attributes (Fields): Like int windows and String color—these are the characteristics every house will have. Behaviors (Methods): Like void build()—this is what the house (or the system) can do. 2. The Process: Instantiation 🏗️ Notice the arrow in the middle? That’s the "Magic Moment" called Instantiation. When you use the new keyword in Java, you are telling the computer: "Take this blueprint and actually build it in memory!". 3. The Objects: The Real-World Result 🏡 On the right, we see three distinct Objects: Object 1: A Red House. Object 2: A Yellow House. Object 3: A Blue House. Here is the key takeaway: Even though they all came from the exact same blueprint, they are unique. They each have their own "state" (different colors), but they share the same "identity" (they are all Houses). Why does this matter? By using this model, Java allows us to write code that is: ✅ Reusable: Write the blueprint once, create a thousand houses. ✅ Organized: Keep data and behavior in one neat package. ✅ Scalable: It’s much easier to manage a neighborhood when you have a standard plan to follow. What was the "Aha!" moment that helped you finally understand OOP? Drop a comment below! 👇 #Java #SoftwareEngineering #CodingLife #OOP #TechEducation #WebDevelopment

Some Java features only reveal their real power once you see them applied across different concrete types. Polymorphism is one of those features, and it quietly drives half of the APIs you use every day. When you watch the JVM decide which implementation to run, especially in mixed hierarchies, the mechanics become a lot more interesting than the textbook explanation. This article walks through those edge cases where inheritance, overriding, and casting intersect. https://bit.ly/4rJLj4e

🚀 Day 6/30 – Java DSA Challenge 🔎 Problem 45: 88. Merge Sorted Array (LeetCode – Easy) Today’s problem focuses on a classic Two Pointer technique 🔥 🧠 Problem Summary We are given: nums1 of size m + n First m elements are valid Last n elements are 0 (extra space) nums2 of size n 🎯 Merge nums2 into nums1 in sorted order Without returning a new array (modify in-place). 💡 Key Insight If we start merging from the front, elements in nums1 will get overwritten. So instead: ✅ Start from the back of both arrays. We compare the largest elements and place them at the end. 🔄 Approach 1️⃣ Pointer i → last valid element of nums1 2️⃣ Pointer j → last element of nums2 3️⃣ Pointer k → last position of nums1 Compare nums1[i] and nums2[j] Place the larger one at nums1[k] Move pointers accordingly Continue until all elements from nums2 are placed. ⏱ Time Complexity O(m + n) 📦 Space Complexity O(1) – In-place merge 📌 Pattern Used ✔ Two Pointer Technique ✔ Backward Traversal ✔ In-place Array Manipulation 🎯 Key Learning When extra space is available at the end of an array: 👉 Always think merge from the back 👉 Prevent unnecessary shifting 👉 Achieve O(1) space complexity 🔥 45 Problems Completed Day 6 = Sliding Window + Two Pointer patterns mastered 💪 Consistency builds confidence 🚀 #Day6 #30DaysOfCode #Java #DSA #LeetCode #TwoPointers #ProblemSolving #InterviewPrep #Consistency