Thiago Pereira’s Post

𝗝𝗮𝘃𝗮 𝗧𝗶𝗽: 𝗕𝘂𝘀𝘁𝗶𝗻𝗴 𝗮 𝗖𝗼𝗺𝗺𝗼𝗻 𝗠𝗲𝗺𝗼𝗿𝘆 𝗠𝘆𝘁𝗵 Let's talk about a common assumption in Java: if a short primitive is smaller than an int, then a Short object must be smaller than an Integer object, right? Not exactly. This is a great example of how Java's object model works. While short (2 bytes) is half the size of int (4 bytes), their wrapper classes tell a different story. Every object in Java comes with overhead—a header for metadata. This overhead is often larger than the data itself! On a standard 64-bit system, this header plus memory padding means that Byte, Short, and Integer objects all typically occupy the same 16 bytes of memory. So, what's the lesson? ✅ Use Integer by default: For collections like List<Integer>, it's the standard and doesn't waste memory compared to Short or Byte. ✅ Use Short or Byte for clear communication: They are great for showing that a field has a limited, known range. ✅ For real memory savings, use primitive arrays: A short[] is far more memory-efficient than an ArrayList<Short>. It's a small detail, but understanding it helps us write better, more intentional code. #Java #ProgrammingTips #SoftwareEngineering #CodeQuality #Developer

Day 91 of #100DaysOfCode Solved Base 7 in Java 🔢 Approach The challenge was to convert a given integer (num) to its base 7 string representation. Conversion Method The core of the solution lies in the standard algorithm for base conversion: repeated division and remainder collection. Handle Zero and Negatives: If the input num is 0, the result is immediately "0". I determined if the number is negative and stored this in a boolean flag, then proceeded with the absolute value of the number (num = Math.abs(num)) for the conversion logic. Conversion Loop: I used a while loop that continues as long as num > 0. In each iteration: The remainder when num is divided by 7 (num % 7) gives the next digit in base 7. This digit is appended to a StringBuilder. num is then updated by integer division by 7 (num /= 7). Final Result: Since the remainders are collected in reverse order, I called sb.reverse(). If the original number was negative, I prepended a hyphen (-) to the reversed string. Finally, I returned the result as a string. This simple and efficient implementation had a very fast runtime, beating 77.39% of submissions. #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #BaseConversion #ProblemSolving

💫 Difference Between String Literal and String Object In Java, Strings can be created in two ways — as a Literal or as an Object. Though both store text, they differ in memory allocation and creation process. Let’s understand how👇 ✨ 1️⃣ String Literal Created without using the new keyword. Stored in the String Constant Pool (SCP). Reuses memory if the same value already exists. ⚙️ 2️⃣ String Object Created explicitly using the new keyword. Stored in the heap memory (outside the SCP). Always creates a new object, even if the value is the same. 💡 In Short "Cindrella" → Literal → Stored in SCP, memory-efficient. new String("Cindrella") → Object → Stored in Heap, separate instance. #Java #StringConcepts #ObjectvsLiteral #CodingBasics #LearningJourney

💡Did you know that Generics simplify your code in Java, even if you don't use them directly? If you’ve ever worked with Java Collections, you’ve already used one of the language’s most powerful features: Generics. But why are they so important? 1. Type Safety Generics allow you to specify the type of objects a collection or class can work with. This drastically reduces ClassCastException and other runtime surprises, leading to more stable applications. 2. Cleaner Code by Eliminating Explicit Casts By specifying the type upfront, the compiler automatically handles casts when retrieving elements. 3. Improved Code Reusability Write classes once, and use them with any object type. Generics enable you to build flexible, reusable components without sacrificing type integrity. A perfect example? The List Interface! When you declare a List, you must typically specify the type of object it will hold within angle brackets (<>). This specified type is the type argument for the generic interface. For example: • List<String> means the list can only hold String objects. • List<Integer> means the list can only hold Integer objects. Without Generics (pre-Java 5), you could add any element to the List, but: • Adding different types of variables to the list would lead to a ClassCastException. • When retrieving values, you had to manually cast each element. This simple difference illustrates how generics transform potential runtime headaches into compile-time warnings, allowing developers to catch and fix issues much earlier in the development cycle. #Java #Generics #Programming #CleanCode #SoftwareDevelopment #JavaCollections #CodingTips

🚀Day 93/100 #100DaysOfLeetCode 🧩Problem: Remove Duplicates from Sorted List II✅ 💻Language: Java 🧠Approach: This problem requires removing all duplicate nodes from a sorted linked list, leaving only unique elements. Steps: 1️⃣Use a dummy node to handle edge cases easily (like when the first few nodes are duplicates). 2️⃣Use two pointers — one (prev) to track the previous node and another (head) to traverse the list. 3️⃣Whenever duplicate values are found (head.val == head.next.val), move head forward until all duplicates are skipped. 4️⃣Link prev.next to the next distinct node. 5️⃣Move prev forward only when no duplicates are found. This ensures that only unique nodes remain in the resulting linked list. 🔑Key Takeaways: 🔹Handling linked list edge cases effectively using a dummy node simplifies logic. 🔹Two-pointer techniques are powerful for in-place list manipulation. 🔹Proper pointer management avoids unnecessary complexity and extra memory usage. ⚡Performance: ⏱️Runtime: 0 ms (Beats 100%) 💾Memory: 43.51 MB (Beats 24.99%) #100DaysOfLeetCode #Java #LinkedList #LeetCode #CodingJourney #DSA #CodingChallenge #ProblemSolving

🌳 Trees in Java — From Layman to Pro (2025 Edition) Ever wondered how hierarchical structures like file systems, JSON, or company org charts are represented in code? That’s where Trees come in — nature’s most elegant data structure 🌱 In my latest article, I break down Trees from scratch — starting with simple Java examples to architect-level insights: What makes a Tree different from linear structures Building and traversing a Binary Search Tree (BST) Understanding metrics like height, depth, diameter, balance factor, and leaf count How Trees relate to real-world systems (Kubernetes, APIs, ML models, databases) And yes, a complete working Java program you can run today 🚀 If you’ve ever felt Trees were confusing — this one will make them crystal clear. Simple visuals, intuitive explanations, and modern Java code (2025-ready). 👉 Read here: https://lnkd.in/dhsQQj2p #Java #DataStructures #SystemDesign #Coding #Learning #SoftwareEngineering #Algorithms #TechEducation

Blog: What if Java Collections had Eager Methods for Filter, Map, FlatMap? "I encourage folks to check out the code in the experiment and maybe try some experiments of their own with Covariant Return Types, Default and Static methods for Interfaces, and Sealed Classes." https://lnkd.in/embc2rTs

(Union of Two Sorted Arrays — Java ) Hey everyone 👋 Today I implemented a program to find the Union of Two Sorted Arrays — while maintaining ascending order and avoiding duplicates. It looks simple at first, but the real challenge is handling duplicates efficiently and merging arrays in one traversal ⚙️ Here’s how I approached it 👇 💡 Concept: When two arrays are sorted, we can use two-pointer technique to compare elements and build the union in sorted order — without using any extra sorting later. ⚙️ Approach: 1️⃣ Initialize two pointers i and j for both arrays. 2️⃣ Compare arr1[i] and arr2[j]. • If one is smaller, add it to the union (if not duplicate). • If both are equal, add once and move both pointers. 3️⃣ Continue until both arrays are traversed. 4️⃣ Handle remaining elements in either array (checking for duplicates). 🧩 Key Takeaway: → Using two-pointer technique avoids extra sorting and reduces redundant comparisons. → Time Complexity: O(N + M) → Space Complexity: O(N + M) (for result storage) This problem helped me understand how small pointer-based optimizations can make merging logic both clean and efficient 🚀 Code is available on my GitHub repo: https://lnkd.in/eT335xuc #Java #DSA #Arrays #ProblemSolving #CodingJourney #TwoPointerTechnique #LearningByDoing #FullStackDeveloper #MCA

Day 90 of #100DaysOfCode Solved Squares of a Sorted Array in Java 🔠 Approach The task was to take an array of integers sorted in non-decreasing order, square each number, and then return the result array also sorted in non-decreasing order. Brute-Force Method The solution implemented here is a straightforward two-step brute-force approach: Squaring: I iterated through the input array nums and replaced each element with its square (i.e., nums[i] * nums[i]). This handles both positive and negative numbers correctly. Sorting: After squaring all elements, I used Java's built-in Arrays.sort(nums) method to sort the entire array. While correct, this approach has a time complexity dominated by the sorting step, which is O(NlogN), where N is the number of elements. The runtime of 10 ms shows that a more efficient, two-pointer approach (which can solve this in O(N) time) is generally preferred for optimal performance. #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #Array #Sorting #ProblemSolving

✨ Difference Between String and StringBuffer In Java, both String and StringBuffer are used to handle text data. However, they differ in mutability, performance, and thread-safety — which makes choosing the right one important for your application. 💡 🧩 1️⃣ String Immutable → Once created, it cannot be changed. Every modification (like concatenation) creates a new object. Slower when performing many modifications. Not thread-safe (since it doesn’t change, this isn’t a problem). ⚙️ 2️⃣ StringBuffer Mutable → Can be modified after creation. Performs operations (append, insert, delete) on the same object. Faster for repeated modifications. Thread-safe → All methods are synchronized. ✅ Pro Tip: If your program involves frequent string changes in a single thread, use StringBuilder. If you need thread safety, use StringBuffer. #Java #StringVsStringBuffer #CodingBasics #LearningJourney