Java Interface vs Abstract Class: Key Differences

🚀 Day 8 of My 90 Days Java Full Stack Challenge Today, I practiced two interesting String problems that helped me strengthen my understanding of string manipulation and logical thinking in Java. 🧩 1️⃣ Reverse Words in a Sentence Input: "Java is fun" Output: "fun is Java" 🔎 Approach: Traverse from the end Extract words Rebuild the sentence in reverse order Handle edge cases like multiple spaces 💡 Learned how to manage string traversal without relying completely on inbuilt methods. 🧩 2️⃣ Check Rotation of String Example: "abcd" & "cdab" 🔎 Key Insight: If s2 is a rotation of s1, then s2 must be a substring of (s1 + s1). ✔ Length check first ✔ Then verify using substring logic This problem improved my understanding of pattern recognition in strings. 🧠 Key Takeaways: Two-pointer & traversal techniques Importance of handling edge cases Writing optimized logic instead of brute force Understanding how string concatenation helps solve rotation problems 📅 Next step: Continue exploring more intermediate-level string problems. Consistency > Motivation 💪 #90DaysJavaFullStack #Java #StringManipulation #ProblemSolving #LearningInPublic #DeveloperJourney

Java Collections — Iterator vs forEach 👉small but important 🤖 While working with ArrayList and LinkedList, we usually loop using forEach. So why does Iterator still exist? forEach: - Simple and readable - Best when we only want to read data Iterator: - Allows safe removal while iterating - Avoids ConcurrentModificationException - More control over traversal Example: Iterator<String> it = list.iterator(); while (it.hasNext()) { if (it.next().equals("Java")) { it.remove(); } } forEach looks cleaner, but Iterator is safer when modifying collections. Small concept, but very useful in real code. #Java #Collections #JavaLearning

How return Keyword Returns a Value in Java? We write it every day. We never question it. When a method is called in Java, JVM creates a Stack Frame for that method. This stack frame contains: Method parameters Local variables Return address Reference to previous stack frame Temporary space for return value  Step-by-step Flow int result = add(2, 3); Step 1️⃣ Caller method stack frame already exists. Step 2️⃣ add(2,3) is called → JVM creates a new stack frame (callee). Step 3️⃣ Inside callee stack frame: Parameters: a = 2, b = 3 Local variables Return address (where to go back) Step 4️⃣ When return a + b; executes: The value 5 is placed in the callee’s return value slot Step 5️⃣ JVM copies that value to the caller’s variable result Step 6️⃣ Callee stack frame is destroyed Execution continues in caller method Gurugubelli Vijaya Kumar #Java #JVM #CallStack #StackFrame #ReturnKeyword #CoreJava #JavaInternals #JavaDeveloper #LearningJava #ProgrammingConcepts

🚀ARRAYS IN JAVA As I dive deeper into Java, I’m realizing that even the fundamentals have some hidden gems. Most of us start with the standard Array, but have you played around with Jagged Arrays? So , Hi LinkedIn 👋 Here’s the breakdown of first time experience: We usually visualize a 2D array like a spreadsheet—every row has the exact same number of columns. It’s clean, it’s structured, but it’s rigid. 💡 The Fascinating Fact: Java’s "Array of Arrays" Here is the eye-opener: In Java, a multi-dimensional array isn't a single block of memory. It is actually an array that holds other arrays. Because of this architecture, Java allows for Jagged Arrays—where every row can have a completely different length. 🤯 🛠️ how it matters?? 🤔 Memory Efficiency Real-World Logic Dynamic Thinking and more... It’s these small nuances that make Java so flexible and powerful. To my fellow developers: did you use jagged arrays in your early projects? #Java #CodingNewbie #SoftwareEngineering #DataStructures #BackendDevelopment #TechLearning 💻 See it in action 👇

One Java feature I wish I knew earlier: Records For years, I wrote the same boilerplate again and again: constructors, getters, equals(), hashCode(), toString()… Then I discovered Java Records. public record User(String name, int age) {} That’s it. Immutable, readable, and perfect for DTOs and value objects. What I love about records: • Less boilerplate • Built-in immutability • Clear intent: this is data, not behavior • Cleaner APIs and easier reviews Records won’t replace every class — but when they fit, they fit perfectly. 👉 If you work with Java 16+, start using them. Your future self will thank you. What Java feature do you wish you had learned earlier? #Java #JavaRecords #CleanCode #BackendDevelopment #SoftwareEngineering

I used to overuse Optional in Java. Then I learned when not to use it. Optional is great for: • Return types • Avoiding null checks • Making intent clear But using it everywhere can actually make code worse. ❌ Don’t do this: class User { Optional<String> email; } Why? • Makes serialization messy • Complicates getters/setters • Adds noise where it’s not needed ✅ Better approach: Optional<String> findEmailByUserId(Long userId); Rule of thumb I follow now: 👉 Use Optional at the boundaries, not inside your models. Java gives us powerful tools, but knowing where to use them matters more than just knowing how. Clean code is less about showing knowledge and more about reducing confusion. What’s one Java feature you stopped overusing after some experience? #Java #CleanCode #BackendDevelopment #SoftwareEngineering #LearningInPublic #OptionalInJava #Optimization

Today I revisited an important Core Java concept :- Variable Shadowing. Shadowing happens when a constructor parameter has the same name as a class member variable. Example of the problem: private String name; public Employee(String name) { name = name; // Shadow problem } Here, both sides refer to the constructor parameter. The instance variable never gets assigned. Result: The object prints default values like null or 0.0. Correct way using this: public Employee(String name) { this.name = name; // Proper assignment } this refers to the current object’s instance variable. Key takeaway: Without this, constructor parameters can hide instance variables. With this, we clearly differentiate between object state and local scope. A small keyword, but critical for proper object initialization. Strong OOP fundamentals prevent subtle bugs in real systems. #Java #CoreJava #OOP #Encapsulation #SoftwareEngineering #BackendDevelopment

🚀Java practice - Day 87 Completed! 👍 Problem: Sum of Squares of Special Elements Language: Java Today’s problem was about identifying special elements in a 1-indexed array. An element is considered special if its index divides the length of the array (n % i == 0). The task was to calculate the sum of the squares of such elements.✨ #Day87 #Java #LeetCode #Arrays #ProblemSolving #DailyCoding #Consistency #100DaysOfCode

📌 LeetCode #27 – Remove Element 💻 Language: Java 🔹 Approach (Two Pointer Technique): Use one pointer to track the position for valid elements Traverse the array If the current element is not equal to val, place it at the pointer index Increment the pointer Final pointer value gives the new length of the array ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(1) In-place modification, no extra memory 💡 Consistency over perfection 💯 #DSA #Java #LeetCode #ProblemSolving #LearningInPublic 

Java☕ — Collections changed everything 📦 Before collections, my code looked like this: #Java_Code int[] arr = new int[100]; Fixed size. No flexibility. Painful logic. Then I met the Java Collections Framework. #Java_Code List<Integer> list = new ArrayList<>(); Suddenly I could: ✅Grow data dynamically ✅Use built-in methods ✅Write cleaner logic The biggest lesson for me wasn’t syntax, it was choosing the right collection. 📌ArrayList → fast access 📌LinkedList → frequent insert/delete 📌HashSet → unique elements 📌HashMap → key-value data Java isn’t powerful because of loops. It’s powerful because of its collections. #Java #CollectionsFramework #ArrayList #HashMap #LearningInPublic