Mastering Java Arrays with Hyder Abbas Sir and Navin Reddy Sir

🚀 Day 12 – Understanding Arrays & Implementing Searching Techniques in Java Today’s focus was on mastering Arrays and implementing searching problems using methods in Core Java.this session helped me understand how data is stored, accessed, and processed efficiently using array structures — one of the most fundamental concepts in programming. Instead of writing everything inside main(), I practiced solving problems using properly defined methods to keep the logic clean and reusable. 🧩 What I Worked On: • Creating and initializing arrays • Taking array input from users • Traversing arrays using loops 🛠 Concepts Applied: ✔ Arrays (Declaration, Initialization, Traversal) ✔ Method Creation & Reusability ✔ Parameter Passing (Array as Argument) ✔ Return Statements ✔ Looping Constructs Key Learning Outcomes: • Understood how arrays manage multiple data values efficiently • Learned how to pass arrays to methods • Strengthened searching logic using structured programming • Improved code readability with modular design • Practiced writing clean, maintainable programs Arrays are a foundational step toward mastering Data Structures and Algorithms, and today strengthened that base significantly. Step by step building strong Core Java fundamentals before moving into advanced data structures and backend development #100DaysOfCode #Java #CoreJava #Arrays #DataStructures #ProblemSolving #JavaDeveloper #BackendDevelopment #CodingJourney

Deep Dive into Java Fundamentals: Collections & Wrapper Classes ☕️ Today was all about strengthening the bedrock of my Java knowledge. I spent the day exploring the theoretical foundations of the Collection Interface, the Collections Utility Class, and Wrapper Classes. Understanding the "why" behind these concepts is just as important as the "how." Here’s a quick breakdown of my key takeaways: Collection vs. Collections: Clarified the distinction between the root interface for data structures and the utility class used for polymorphic algorithms (sorting, searching, etc.). Wrapper Classes: Diving into how Java wraps primitive data types into objects, enabling them to be used within the Collections Framework through Autoboxing and Unboxing. Data Structure Architecture: Looking at how different implementations (List, Set, Queue) handle data differently under the hood. Building a solid theoretical base is essential for writing efficient, scalable code. Back to the IDE to put these theories into practice! #Java #SoftwareDevelopment #JavaFullStack #CodingJourney #BackendDevelopment #ContinuousLearning

𝗪𝗵𝗲𝗻 𝗝𝗮𝘃𝗮 𝗙𝗲𝗲𝗹𝘀 𝗙𝗿𝗲𝘀𝗵 A few weeks ago, I was writing another class just to hold some data. Getters, setters, equals(), hashCode() etc the usual way of doing. I stopped and thought if there was a simpler way or any other way of doing this??? That’s when I started exploring some of 𝗝𝗮𝘃𝗮’𝘀 𝗺𝗼𝗱𝗲𝗿𝗻 𝗳𝗲𝗮𝘁𝘂𝗿𝗲𝘀, and they completely changed how I write code: • 𝗥𝗘𝗖𝗢𝗥𝗗𝗦: Create immutable data objects in a single line. No more endless repetitive code. • 𝗦𝗘𝗔𝗟𝗘𝗗 𝗖𝗟𝗔𝗦𝗦𝗘𝗦: Control exactly which classes can extend a parent. Safer and easier to maintain. • 𝗩𝗜𝗥𝗧𝗨𝗔𝗟 𝗧𝗛𝗥𝗘𝗔𝗗𝗦: Handle thousands of tasks concurrently without eating up memory. Lightweight and practical for high concurrency. • 𝗣𝗔𝗧𝗧𝗘𝗥𝗡 𝗠𝗔𝗧𝗖𝗛𝗜𝗡𝗚: Simplifies complex conditional logic and makes code much cleaner. So Java is not just old and reliable but with its features it keeps evolving. Using these features helps reduce routine code, write safer code, and build applications that are easier to maintain while staying in the JVM enviornment. 👉 Have you tried any of these modern Java features? Which one made the biggest difference in your projects? #Java #ModernJava #JVM #BackendDevelopment #SoftwareEngineering #Programming

🚀 Week 8 – Java + DSA Journey Update This week was all about strengthening my problem-solving skills and diving deeper into Data Structures using Java. 💻 🔹 What I focused on: Arrays & Advanced Array Problems Two Pointer Technique Sliding Window Concepts Solved multiple problems on LeetCode 🔹 Key Learnings: Learned how to optimize brute force solutions into efficient ones (O(n)) Understood real use of two pointers in problems like pair sum & sorting-based questions Sliding window made problems like longest substring much more efficient 🔹 Challenges faced: Some problems looked easy but required deep thinking to optimize. Debugging logic took time, but consistency helped 💪 🔹 Progress: Improved coding speed ⏱️ Better understanding of patterns instead of just memorizing solutions 📌 Goal for next week: Start Linked List Practice medium-level problems consistently Consistency is the only key 🔑 #Java #DSA #LeetCode #CodingJourney #SoftwareEngineering #LearningInPublic

LeetCode Practice – Two Sum (Java Implementation) As part of my continuous problem-solving practice, I worked on the Two Sum problem on LeetCode. Problem Statement: Given an integer array and a target value, return the indices of the two numbers such that they add up to the target. Approach: Implemented a straightforward brute-force solution using nested loops to check all possible pairs and return the required indices. Key Takeaways: Strengthened fundamentals of array traversal Improved logical thinking and debugging skills Focused on writing clean and readable Java code Consistent practice is helping me build a stronger foundation in Data Structures and Algorithms. Looking forward to solving more problems and optimizing solutions further. #LeetCode #Java #DataStructures #Algorithms #ProblemSolving #CodingJourney #SoftwareDevelopment

#Post2 In my previous post, we explored how HashMap works internally. (If you haven't read it yet, you can find it here: https://lnkd.in/dnwPP-iv) One important point mentioned there was: HashMap is not thread safe. But what does that actually mean? Let’s understand it with an example 👇 Imagine two threads trying to update the same HashMap at the same time. Example: → map.put("Apple", 10); → map.put("Banana", 20); Since HashMap is not synchronized, both threads may try to modify the internal bucket structure at the same time. This can cause problems like: • Data inconsistency • Lost updates Why does this happen? Because operations like put() and resize() involve multiple internal steps. If two threads interleave during these steps, the internal structure can become corrupted. Example scenario: • Thread-1 is inserting an entry • Thread-2 is resizing the HashMap Both modify the bucket array concurrently → leading to unpredictable results. So how do we solve this problem? One option is to synchronize access to the HashMap. This can be done using a synchronized block or by using Collections.synchronizedMap(). However, these approaches lock the entire map, which reduces concurrency when multiple threads try to access it. Java therefore provides a better alternative: ConcurrentHashMap Instead of locking the entire map, ConcurrentHashMap uses finer-grained locking and internal concurrency mechanisms, allowing multiple threads to safely access the map. This allows: • High concurrency • Better performance compared to synchronized maps • Thread-safe read and write operations Example usage → ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); → map.put("Apple", 10); Multiple threads can safely read and write without corrupting the data structure. Key takeaway • Use HashMap when working in a single-threaded environment • Use ConcurrentHashMap when multiple threads need concurrent read/write In the next post, we’ll explore how ConcurrentHashMap works internally and how it achieves thread safety. #Java #SoftwareEngineering #BackendDevelopment #Multithreading #Programming #ConcurrentProgramming

🚀 DSA Consistency — Day 10 Continuing my consistency journey, today I solved the LeetCode problem “Sort Integers by The Number of 1 Bits.” 🔎 Key learning from today: The problem focused on sorting elements based on a custom criteria — primarily the count of set bits in each number, and secondarily their numeric value. I approached this by grouping numbers according to their set bit count using ordered data structures and then sorting within each group. 💡 This problem reinforced: ✅ Bit manipulation fundamentals ✅ Custom sorting logic ✅ Effective use of Java Collections (TreeMap + ArrayList) ✅ Translating problem constraints into clean implementation Maintaining daily problem-solving discipline is helping me sharpen both my problem-solving mindset and implementation clarity. 📌 You can check out my solution here: https://lnkd.in/d-ESnvjq #DSA #LeetCode #Consistency #ProblemSolving #Java #BitManipulation #CodingJourney

🚀 Day 88 of My 100 Days LeetCode Challenge | Java Today’s problem focused on designing an efficient data structure that supports multiple operations in constant time. The challenge was to implement a RandomizedSet that can insert, remove, and get a random element, all in O(1) time complexity. The key insight was combining two data structures: A HashMap to track element indices An ArrayList to store elements for quick random access To maintain constant time removal, the trick was to swap the element to remove with the last element in the list, update the index in the map, and then remove the last element. This clever swap technique avoids expensive shifting operations. ✅ Problem Solved: Insert Delete GetRandom O(1) ✔️ All test cases passed (21/21) ⏱️ Runtime: 33 ms 🧠 Approach: HashMap + ArrayList (Data Structure Design) 🧩 Key Learnings: ● Combining multiple data structures can unlock powerful optimizations. ● HashMaps are perfect for constant-time lookups. ● Lists provide efficient random access. ● Swapping elements helps maintain O(1) deletion. ● Designing efficient systems often requires thinking beyond a single structure. This problem felt like building a mini system design inside a coding challenge, balancing efficiency and simplicity. 🔥 Day 88 complete — improving my understanding of data structure design and optimization. #LeetCode #100DaysOfCode #Java #DataStructures #HashMap #ProblemSolving #DSA #CodingJourney #Consistency

🚀Day - 24 | Day - 8: Deep Dive into Linked Lists! Today, my DSA journey took me beyond the basics of Arrays and into the flexible world of Linked Lists. While Arrays are great, I quickly realized they have their limits—specifically when it comes to memory and efficiency. 📉 The "Array" Problem Arrays require contiguous memory, which can be a pain to allocate for large datasets. Plus, inserting or deleting elements is expensive because you have to shift everything else around. 💡 The Solution: Linked Lists A Linked List is a collection of Nodes. Each node is like a small container with two parts: Data: The actual value you want to store. Next (Address): A pointer/reference to the next node in the sequence. The list starts with a Head and ends when a node points to Null. No more shifting elements! Just update the pointers, and you're good to go. 🛠️ What I Built Today I moved from theory to implementation using Java. Here’s a snapshot of what I practiced: Structure: Defined the Node using Classes and Objects. Traversal: Mastered the while loop to navigate the list (since we don't have indexes like Arrays). Core Operations: Adding elements (at the beginning, end, and specific indexes). Removing elements (first and last). Printing the entire list. 🧠 Key Takeaway If you need fast insertions and deletions without worrying about pre-allocating memory blocks, Linked Lists are best. A big thanks to Poovizhi Mam for the clear explanation and hands-on coding practice✨ #DSA #CodingJourney #Java #DataStructures #LinkedList #LearningInPublic #SoftwareEngineering

🚀 Day 5 – LeetCode Practice Today, I solved the Merge k Sorted Lists problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given an array of k sorted linked lists, the task was to merge them into one sorted list. • I used a min-heap (priority queue) to efficiently select the smallest node among all lists at each step. • Inserted the head of each list into the min-heap, then repeatedly extracted the smallest value and added it to the merged result. • Advanced the pointer in the selected list and added its next node to the heap. • This approach ensured the merged list was built in a sorted order. ⏱ Complexity: • Time Complexity: O(N log k) (where N is total number of nodes across all lists) • Space Complexity: O(k) (due to the heap) 📚 Key Takeaway: This problem reinforced how priority queues and efficient data structures help simplify merging multiple sorted streams. Using a min-heap significantly improves performance compared to pairwise merging. Consistent problem-solving practice continues to strengthen my understanding of advanced data structures and algorithm design. 💪 #LeetCode #Java #DSA #PriorityQueue #LinkedList #ProblemSolving #Algorithms #100DaysOfCode #SoftwareDeveloper