Why Java Arrays Start at Index 0 Explained

🚀 How LinkedList Solves What Arrays Cannot. (https://lnkd.in/g_8fWXFq ) ➡️ An array demands contiguous memory — every element must sit next to the other. But what if memory is scattered? That's exactly where LinkedList steps in, connecting nodes across RAM using addresses. Here are the key takeaways from the LinkedList session at TAP Academy by Sharath R sir : 🔹 The Node: Every element lives in a node — an object with a data field and the address of the next (and previous) node. It's not magic, it's just object references. 🔹 Singly vs Doubly: Singly LL has one link — forward traversal only. Doubly LL has two links — bidirectional. Java's LinkedList class uses Doubly LL internally. 🔹 Initial Capacity = 0: Unlike ArrayList (initial capacity 10), LinkedList pre-allocates nothing. Every add() creates a fresh node dynamically — no contiguous block needed. 🔹 Polymorphism hiding in plain sight: new LinkedList(arrayList) works because ArrayList IS-A Collection. Parent reference + child object = loose coupling. The same concept from OOP, live inside Collections. 🔹 Iterator vs ListIterator: Iterator moves forward only. ListIterator moves both ways — but declaring it as Iterator type blocks access to hasPrevious(). That's Inheritance at work — parent references can't reach specialized child methods. Visit this Interactive webpage to understand the concept by visualization : https://lnkd.in/g_8fWXFq #Java #LinkedList #CoreJava #TapAcademy #DataStructures #OOP #Collections #LearningEveryDay #SoftwareDevelopment #Programming

🚀 𝗝𝗮𝘃𝗮 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗣𝗿𝗲𝗽 – Day 3 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗮𝗻 𝗢𝗯𝗷𝗲𝗰𝘁-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 (𝗢𝗢𝗣) 𝗟𝗮𝗻𝗴𝘂𝗮𝗴𝗲? An Object-Oriented Programming (OOP) language is a programming language based on the concept of objects, which represent real-world entities. 👉 These objects contain: • Data (Attributes) • Methods (Functions) that operate on that data 💡 OOP helps in writing code that is: • Modular • Reusable • Scalable 🔑 𝗙𝗼𝘂𝗿 𝗠𝗮𝗶𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗼𝗳 𝗢𝗢𝗣: ✔️ Encapsulation – Wrapping data and methods into a single unit (class) ✔️ Inheritance – Reusing properties and behavior from an existing class ✔️ Polymorphism – One interface, multiple implementations ✔️ Abstraction – Hiding internal details and showing only essential features 💻 𝗘𝘅𝗮𝗺𝗽𝗹𝗲𝘀 𝗼𝗳 𝗢𝗢𝗣 𝗟𝗮𝗻𝗴𝘂𝗮𝗴𝗲𝘀: • Java • C++ • Python 📌 In simple terms, OOP allows developers to model real-world problems using objects, making software easier to manage and maintain. 👉 In next post we will see one by one principle of OOP language in details. #Programming #OOP #Java #Coding #SoftwareDevelopment #TechInterview #P_Pranjali #Java_Day3

🚀 Day 36 – Understanding Encapsulation in Java Today’s focus was on one of the most important pillars of Object-Oriented Programming — Encapsulation. Encapsulation is all about data hiding and controlled access. Instead of exposing variables directly, we protect them and interact through methods, making our code more secure, modular, and maintainable. 📚 Concepts Covered ✔ Introduction to OOP Principles ✔ Understanding Encapsulation ✔ Data Hiding using private variables ✔ Controlled access using Getter & Setter methods 💻 What I Implemented • Created a class with private fields • Used getters and setters to access and update values • Ensured data validation before modifying object state 💡 Key Learning Encapsulation is not just about hiding data — it’s about building secure, flexible, and scalable applications. This concept is heavily used in real-world systems to maintain data integrity and clean architecture. #Java #OOP #Encapsulation #CoreJava #JavaProgramming #SoftwareDevelopment #CodingJourney #DeveloperJourney #LearningInPublic #BackendDevelopment

Day 3 of Java with DSA Journey 🚀 📌 Topic: Guess Number Higher or Lower (LeetCode 374) 💬 Quote: "Efficiency is not about doing more; it's about eliminating what doesn't matter." ✨ What I Learned: 🔹 Binary Search Beyond Arrays: Binary Search isn’t limited to arrays — it works perfectly on a number range like [1...n]. 🔹 Working with APIs: Learned how to adapt logic based on API responses: -1 → Guess is too high 1 → Guess is too low 0 → Correct answer 🔹 Power of Efficiency: Even for a huge range (up to 2³¹ - 1), Binary Search finds the answer in ~31 steps 🤯 Compared to Linear Search → practically impossible! 🔹 Complexity: ⏱ Time: O(log n) 📦 Space: O(1) 🧠 Problem Solved: ✔️ Guess Number Higher or Lower 💡 Key Insight: This problem highlights the “Narrowing the Search Space” concept. Each step eliminates half the possibilities — that’s the magic of logarithmic algorithms ⚡ ⚡ Interview Insight (3-Way Decision Logic): Unlike boundary problems, here we deal with three outcomes: 1️⃣ 0 → Found the number (return immediately) 2️⃣ -1 → Move right = mid - 1 3️⃣ 1 → Move left = mid + 1 👉 Use while (left <= right) since the target is guaranteed to exist. 🔑 Takeaway: Consistency beats intensity. Showing up daily is what builds mastery. #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #100DaysOfCode #JavaDeveloper #Algorithms

Most developers are not slowed down by bad code. They are slowed down by bad thinking. Not syntax. Not framework choice. Not whether the project uses Java, Go, or Python. The real damage usually comes earlier: - no clear boundaries - too many dependencies in one request path - retries added without thinking - APIs designed around convenience instead of failure - teams optimizing for feature speed over system clarity That’s why some codebases feel heavy even before they get big. The problem is not always technical debt. Sometimes it’s decision debt. And that is much harder to fix. Debate: What does more long-term damage to software teams? A) bad code B) bad architecture C) bad product decisions D) bad debugging habits My vote: B first, C second. What’s yours? #Java #SoftwareArchitecture #Microservices #DistributedSystems #BackendEngineering

🚀 Learning Java the Right Way Today, I practiced a popular DSA problem 👉 Container With Most Water 📌 Problem: Given an array of heights, find two lines that together can store the maximum amount of water. Example: Array → {1, 8, 6, 2, 5, 4, 8, 3, 7} Output → 49 ✅ 🔹 Key Learning: Instead of using brute force (O(n²)), I used the Two Pointer approach to solve it in O(n) time. 📌 Approach: Start with two pointers (left & right) Calculate area = min(height) × width Move the pointer with smaller height Repeat to find maximum area This problem helped me understand: ✔ Two Pointer technique ✔ Optimization over brute-force ✔ Logical decision making ✔ Real interview-level problem solving Learning when and how to optimize is what truly improves coding skills 💪 📌 Think smart • Optimize logic • Solve efficiently 🚀 #java #javafullstack #javadeveloper #corejava #codingjourney #coding

🚀 DAY 99/150 — BINARY SEARCH ON ANSWER! 🔥📊 Day 99 of my 150 Days DSA Challenge in Java and today I solved a very important problem that uses Binary Search in a 2D matrix 💻🧠 📌 Problem Solved: Kth Smallest Element in a Sorted Matrix 📌 LeetCode: #378 📌 Difficulty: Medium–Hard 🔹 Problem Insight The task is to find the kth smallest element in an n x n matrix where: • Each row is sorted • Each column is sorted 👉 Instead of flattening and sorting (O(n² log n)), we can do better using Binary Search on Answer. 🔹 Approach Used I used Binary Search on Value Range: • Set: low = smallest element high = largest element • Apply binary search: Find mid Count how many elements are ≤ mid 👉 If count < k → move right (low = mid + 1) 👉 Else → move left (high = mid) ✔️ Continue until low == high → answer found 🔹 Counting Logic (Optimized) • Start from bottom-left corner • If element ≤ mid: All elements above are also ≤ mid Move right • Else: Move up ✔️ This gives O(n) counting per iteration ⏱ Complexity Time Complexity: O(n log (max - min)) Space Complexity: O(1) 🧠 What I Learned • Binary Search is not just for arrays — it can be applied on answer space • Matrix properties can be used for efficient counting • Avoid brute force by leveraging sorted structure 💡 Key Takeaway This problem taught me: How to apply Binary Search on Answer pattern How to optimize 2D problems using structure Thinking beyond direct sorting approaches 🌱 Learning Insight Now I’m improving at: 👉 Recognizing when to use Binary Search beyond arrays 👉 Solving problems with optimized thinking 🚀 ✅ Day 99 completed 🚀 51 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/g-yhc7kH 💡 Don’t search the data — search the answer. #DSAChallenge #Java #LeetCode #BinarySearch #Matrix #Optimization #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗝𝗮𝘃𝗮’𝘀 𝘃𝗮𝗿 Recently, I explored how Java introduced Local Variable Type Inference (var) in Java 10 and how it transformed the way developers write cleaner and more expressive code. Java has traditionally been known for its verbosity. With the introduction of var through Project Amber, the language took a major step toward modern programming practices—balancing conciseness with strong static typing. 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: • var allows the compiler to infer types from initializers, reducing boilerplate without losing type safety. • It is not a keyword, but a reserved type name, ensuring backward compatibility. • Works only for local variables, not for fields, method parameters, or return types. • The inferred type is always static and compile-time resolved—no runtime overhead. • Powerful in handling non-denotable types, including anonymous classes and intersection types. Must be used carefully: • Avoid when the type is unclear from the initializer • Prefer when the initializer clearly reveals the type (e.g., constructors or factory methods) • Enhances readability only when the initializer clearly conveys the type. 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆: var is not just about writing less code—it’s about writing clearer, more maintainable code when used correctly. The real skill lies in knowing when to use it and when not to. A special thanks to Syed Zabi Ulla sir at PW Institute of Innovation for their clear explanations and continuous guidance throughout this topic. #Java #Programming #SoftwareDevelopment #CleanCode #Java10 #Developers #LearningJourney

🚀 Day 11.2 of Java DSA Journey — Trilogy Complete 🧠⚡ 📌 Problem: Power of Four (LeetCode 342) I didn’t just solve this problem… 👉 I connected everything from the last days: Power of 2 → Bitwise Power of 3 → Math Power of 4 → Both combined 💡 Breakthrough Idea To be a power of four, a number must: ✔️ Be positive ✔️ Be a power of two → (n & (n - 1)) == 0 ✔️ Follow a math rule → (n - 1) % 3 == 0 👉 That’s a multi-layered check in O(1) 🧠 Key Learnings 🔹 Not all powers of 2 are powers of 4 (Example: 8, 32 ❌) 🔹 Mathematical Signature Matters For every 4^x, (n - 1) is divisible by 3 🔹 Combining Concepts = Real Growth Bitwise + Math → Cleaner, faster solution ⚡ Complexity ⏱ Time: O(1) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Layer Your Conditions Break complex checks into smaller logical filters 💡 Tip 2: Don’t Stop at Bitwise Sometimes bit tricks need math support 💡 Tip 3: Know Alternative Tricks 👉 0x55555555 mask can validate correct bit position 💡 Tip 4: Pattern Recognition is Everything This entire trilogy is about identifying patterns in numbers 💡 Tip 5: Think Like an Engineer Combine approaches instead of forcing one technique 🔥 Real Insight This wasn’t just a problem… It was about learning: 👉 When to use bitwise 👉 When to use math 👉 When to combine both That’s real problem-solving. Consistency builds mastery 📈 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #InterviewPrep #Day11 #BitManipulation #InterviewPrep #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

🚀 Day 18 / 100 Days of Java 💻 Today was all about going deeper into one of the most fundamental topics in programming — Arrays. Even though arrays seem simple at first, they are the backbone of many advanced data structures and algorithms. Here’s what I worked on today 👇 🔹 Understanding Arrays Learned how arrays are represented in memory and why they allow fast access using indexing. This helped me clearly understand how data is stored and retrieved efficiently. 🔹 Finding Maximum & Minimum Elements Practiced iterating through an array to identify the largest and smallest values — a simple yet powerful concept used in many real-world problems. 🔹 Finding the Third Largest Element This pushed me to think beyond basics and handle edge cases like duplicates and ordering without relying completely on sorting. 🔹 Searching an Element in Array Explored linear search and understood where it works best. Also got a glimpse of how search efficiency matters when data grows. 🔹 Finding Missing Number Solved problems using both brute force and optimized approaches. This improved my understanding of patterns and mathematical logic. 🔹 Finding Repeating Elements Learned different techniques to detect duplicates — from basic loops to more optimized methods using extra space. 💡 Key Learnings from Today: ✔ Arrays are not just beginner topics — they are the foundation of problem solving ✔ Writing clean logic is more important than jumping to complex solutions ✔ Edge cases (duplicates, boundaries, etc.) matter a lot ✔ There’s always a better (optimized) way to solve a problem 🔥 Reflection: Every day I realize that consistency beats intensity. Even small concepts, when practiced deeply, build strong problem-solving skills over time. 📈 Slowly but surely becoming better than yesterday. Let’s keep building, learning, and growing 💪 #Java #DSA #100DaysOfCode #CodingJourney #LearningInPublic #DeveloperLife #Programmer #CodingLife #SoftwareEngineering #ComputerScience #TechJourney #ProblemSolving #Algorithms #DataStructures #JavaDeveloper #CodeDaily #Consistency #GrowthMindset #SelfImprovement #StudentLife #EngineeringStudent #FutureEngineer #CodeNewbie #KeepLearning #BuildInPublic #Motivation #Discipline #DailyProgress #NeverGiveUp