Mastering Java ArrayList with Autoboxing and Unboxing

Day 79 of #100DaysOfLeetCode 💻✅ Solved #3. Longest Substring Without Repeating Characters problem in Java. Approach: • Used Sliding Window with HashSet • Expanded window using right pointer • Shrunk window when duplicate found • Tracked maximum substring length Performance: ✓ Runtime: 6 ms (Beats 69.53% submissions) 🚀 ✓ Memory: 46.46 MB (Beats 41.45% submissions) Key Learning: ✓ Strengthened Sliding Window technique ✓ Learned efficient duplicate handling using HashSet ✓ Improved substring optimization skills Learning one problem every single day 🚀 #Java #LeetCode #DSA #SlidingWindow #Strings #ProblemSolving #CodingJourney #100DaysOfCode

🚀 #50DaysOfCode – Day 2 ✅ Problem Solved: Maximum Product Subarray 💻 Language Used: Java Today’s challenge was all about handling tricky cases with negative numbers and tracking both minimum and maximum products dynamically. 🔍 Key Learning: When dealing with products, a negative number can flip the result — so maintaining both current min and max values is crucial. ⚡ Performance: • Runtime: 2 ms • Beat: 69.81% • Memory: 47.17 MB Consistency is the goal. Small progress every day adds up! 💪 #DSA #LeetCode #Java #CodingChallenge #ProblemSolving #Consistency #PaavaiPEC #PEC #Learning

🔥 Day 61 of #100DaysOfCode Solved – Contains Duplicate II 🔍 What I did: Used a sliding window approach with a HashSet to track elements within a range of size k, checking for duplicates efficiently. 💡 Key Learning: Understood the concept of sliding window technique Learned how to use HashSet for quick duplicate checks Practiced controlling window size by removing outdated elements 🎯 Takeaway: Combining sliding window with hashing helps solve problems efficiently without extra complexity. #Day61 #LeetCode #Java #ProblemSolving #CodingJourney #100DaysOfCode #DSA

Day: 96/365 📌 LeetCode POTD: Minimum Distance to Type a Word Using Two Fingers Hard Key takeaways/Learnings from this problem: 1. This problem is a great example of DP with state as both fingers’ positions, which feels tricky at first but clicks once you model it right. 2. Key learning: instead of deciding both fingers every time, fix one and optimize the movement of the other to reduce complexity. 3. Precomputing distances between characters makes transitions much faster and keeps the code clean. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

#Day32 of learning Java from Aditya Tandon CoderArmy Today I went deeper into List Implementations ➤ ArrayList → dynamic array, fast access ➤ LinkedList → better insert/delete, uses nodes ➤ Vector → thread-safe but slower (legacy) ➤ Stack → LIFO (built on Vector) Also learned: ✔ ArrayList grows dynamically (~1.5x) ✔ LinkedList uses extra memory (nodes + pointers) ✔ Vector has overhead due to synchronization 📂 Notes + Code: https://lnkd.in/gUHSdaFN

Day 87 of #100DaysOfLeetCode 💻✅ Solved #334. Increasing Triplet Subsequence problem in Java. Approach: • Used Greedy approach with two variables • Tracked smallest and second smallest values • Updated values while traversing array • Returned true when a valid triplet was found Performance: ✓ Runtime: 2 ms (Beats 99.30% submissions) 🚀 ✓ Memory: 122.40 MB (Beats 80.69% submissions) Key Learning: ✓ Learned efficient Greedy strategy for subsequences ✓ Improved tracking of minimum values dynamically ✓ Strengthened understanding of pattern detection in arrays Learning one problem every single day 🚀 #Java #LeetCode #DSA #Greedy #Arrays #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Day 58 at Tap Academy – Core Java Journey Today’s session was all about understanding powerful data structures and concepts that improve performance and efficiency in Java. 📚 What I learned today: 🔹 HashSet and its features 🔹 Hashing, Hash Functions & Hash Table properties 🔹 Load Factor and Bucket Locations 🔹 When to use HashSet effectively 🔹 LinkedHashSet and its advantages 🔹 Introduction to Map interface 🔹 HashMap and LinkedHashMap concepts These concepts helped me understand how data is stored, retrieved, and managed efficiently using hashing techniques. It’s exciting to see how these structures play a crucial role in real-world applications! 💡 Every day is a step closer to becoming a better developer. #Java #CoreJava #LearningJourney #TapAcademy #Programming #DataStructures #100DaysOfCode #DeveloperLife

🚀 Day 60 at Tap Academy – Core Java Journey Today’s session was all about enhancing code flexibility and efficiency! 🔹 Learned about Generics (<>) – writing reusable and type-safe code 🔹 Explored Collections utility methods: frequency() – to count occurrences replaceAll() – to update elements shuffle() – to randomize data sort() – to organize collections efficiently Grateful for the continuous learning and hands-on experience every day! 💡 Excited to apply these concepts in real-world projects. #Java #CoreJava #Generics #Collections #LearningJourney #TapAcademy #Programming #100DaysOfCode

🚀 ArrayList Deep Dive — Beyond the Basics. (https://lnkd.in/gUuBbkwb) ArrayList, as part of Java’s Collections Framework, represents a resizable array that bridges the gap between fixed-size arrays and dynamic data structures. It allows elements to grow and shrink automatically, providing fast index-based access while handling memory management internally. Here are the key takeaways from the ArrayList session at TAP Academy by Sharath R. Sir: → Why collections can’t store primitives, and how AutoBoxing handles it → Why for-each loops are preferred in real-world scenarios → Iterator vs ListIterator — forward vs bidirectional traversal → Why add() in the middle is O(n), but get() is O(1) → The key difference between retainAll() and removeAll() One interesting takeaway: there’s no direct way to check an ArrayList’s capacity—you rely on internal behavior and documentation. Reinforces how important it is to understand internals, not just APIs. To know everything in detail I Built a small interactive study guide with quizzes and code snippets to reinforce the concepts. visit site: https://lnkd.in/gUuBbkwb #Java #DSA #Collections #LearningInPublic #SoftwareEngineering #TAPTAP Academy #ArrayList

🚀 Day 53 of #100DaysOfLeetCode Solved: Next Greater Element (Leetcode 496) Today’s problem was a great reminder of how powerful Monotonic Stack can be for optimization. 🔹 Approach: Used a stack to maintain decreasing elements Mapped each element to its next greater using a HashMap Reduced time complexity from O(n²) → O(n) 🔹 Key Learning: Small mistakes in conditions (like missing a !) can completely break logic. Attention to detail matters just as much as understanding the concept. 🔹 Complexity: Time: O(n + m) Space: O(n) Consistency > Perfection. Showing up daily and improving step by step. #LeetCode #DSA #Java #CodingJourney #ProblemSolving