Java Pass-by-Value: Understanding Array Modifiers

🚀 LeetCode Problem Solved: 454. 4Sum II Today I solved 4Sum II (Medium) on LeetCode using an optimized approach with HashMap in Java. 🔹 Problem Summary: Given four integer arrays nums1, nums2, nums3, and nums4, count the number of tuples (i, j, k, l) such that: nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0 🔹 Approach Used: Instead of using brute force (O(n⁴)), I optimized it to O(n²) using a HashMap: 1️⃣ Store all possible sums of nums1[i] + nums2[j] in a HashMap with frequency. 2️⃣ For each pair from nums3[k] + nums4[l], check if -(sum) exists in the map. 3️⃣ Add the frequency to the count. 💡 This reduces time complexity from O(n⁴) → O(n²), which is a huge improvement for large inputs. 🔹 Key Concepts Practiced: ✔ HashMap ✔ Frequency counting ✔ Time complexity optimization ✔ Thinking in terms of pair sums Consistent DSA practice is helping me improve my problem-solving patterns and optimization mindset. 💪 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #SoftwareEngineering #100DaysOfCode

Loops work. But they don’t always express intent clearly. That’s where 𝗦𝘁𝗿𝗲𝗮𝗺𝘀 𝗔𝗣𝗜 changed Java. Instead of telling the system how to iterate, you describe what you want. Example: List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); names.stream() .filter(name -> name.startsWith("A")) .map(String::toUpperCase) .forEach(System.out::println); This reads like a pipeline: • Take a collection • Filter it • Transform it • Consume it No explicit loop. No temporary variables. No manual indexing. Streams encourage: • Functional-style thinking • Declarative code • Cleaner data transformation They also introduce: • Lambda expressions • Method references • Lazy evaluation Today was about: • Understanding 𝘀𝘁𝗿𝗲𝗮𝗺() • Difference between intermediate and terminal operations • Writing expressive and readable data pipelines Modern Java isn’t about writing more code. It’s about writing clearer code. #Java #Streams #FunctionalProgramming #CleanCode #SoftwareEngineering #LearningInPublic

Once you understand classes and encapsulation, the next question becomes: How do we reuse behavior properly? That’s where 𝗶𝗻𝗵𝗲𝗿𝗶𝘁𝗮𝗻𝗰𝗲 comes in. Instead of rewriting common logic, Java allows one class to extend another. Example: 𝚌𝚕𝚊𝚜𝚜 𝚅𝚎𝚑𝚒𝚌𝚕𝚎 {    𝚟𝚘𝚒𝚍 𝚜𝚝𝚊𝚛𝚝() {      𝚂𝚢𝚜𝚝𝚎𝚖.𝚘𝚞𝚝.𝚙𝚛𝚒𝚗𝚝𝚕𝚗("𝚅𝚎𝚑𝚒𝚌𝚕𝚎 𝚜𝚝𝚊𝚛𝚝𝚒𝚗𝚐");    }  }   𝚌𝚕𝚊𝚜𝚜 𝙲𝚊𝚛 𝚎𝚡𝚝𝚎𝚗𝚍𝚜 𝚅𝚎𝚑𝚒𝚌𝚕𝚎 {    𝚟𝚘𝚒𝚍 𝚑𝚘𝚗𝚔() {      𝚂𝚢𝚜𝚝𝚎𝚖.𝚘𝚞𝚝.𝚙𝚛𝚒𝚗𝚝𝚕𝚗("𝙱𝚎𝚎𝚙");    }  } Now 𝐂𝐚𝐫 automatically gets the 𝐬𝐭𝐚𝐫𝐭() behavior. This is powerful. But inheritance is not about copying code. It’s about expressing relationships. A 𝗖𝗮𝗿 𝗶𝘀 𝗮 𝗩𝗲𝗵𝗶𝗰𝗹𝗲. That phrase matters. Inheritance should represent: • Logical hierarchy • Shared behavior • Clear relationships When misused, it creates tight coupling and fragile systems. Today was about: • Understanding 𝗲𝘅𝘁𝗲𝗻𝗱𝘀 • The “is-a” relationship • When inheritance makes sense (and when it doesn’t) Reuse is important. But correct modeling is more important. #Java #OOP #Inheritance #SoftwareDesign #CleanCode #LearningInPublic

I recently revisited Chapter 3: "Methods Common to All Objects" in Effective Java by Joshua Bloch. This chapter focuses on the core methods defined in Object that every Java class inherits, and how to override them correctly. Here are the key takeaways I found most valuable: 1. equals() • Override equals() when a class has a notion of logical equality, not just object identity. • Follow the contract: reflexive, symmetric, transitive, consistent, and x.equals(null) must return false. • Compare only significant fields and ensure type compatibility. 2. hashCode() • Always override hashCode() when overriding equals(). • Equal objects must have the same hash code. • A good hash function combines the hash codes of significant fields. This is critical when using hash-based collections like HashMap or HashSet. 3. toString() • Provide a meaningful toString() implementation. • Include useful information about the object's state. • A well-designed toString() greatly simplifies debugging and logging. 4. clone() and Comparable • clone() is tricky and often better avoided in favor of copy constructors or factory methods. • Implement Comparable when a class has a natural ordering, and ensure consistency with equals(). 💡 My takeaway: Correctly implementing equals(), hashCode(), and toString() is fundamental for writing reliable Java classes. These methods influence how objects behave in collections, comparisons, debugging, and logging. Getting them right improves correctness and maintainability across the entire codebase. #Java #EffectiveJava #JoshuaBloch #CleanCode #SoftwareEngineering #JavaTips #Coding #JavaDevelopment

Ever wondered how your computer understands the letter "A"? 🤔 It doesn't. Not directly. Your computer only speaks one language — 0s and 1s. So when we type 'A', behind the scenes it's being converted to a binary code. This is the foundation of Character Type Data in Java. Here's the logic: → 4 symbols need 2-bit codes (2² = 4) → 8 symbols need 3-bit codes (2³ = 8) → 16 symbols need 4-bit codes (2⁴ = 16) Americans standardized this into 128 symbols → ASCII (American Standard Code for Information Interchange) — a 7-bit system. But Java said: "The world speaks more than English." So Java follows UNICODE — supporting 65,536 symbols from languages across the globe. That's why a char in Java takes 2 bytes (16-bit). --- Now here's where it gets practical — Type Casting in Java. Sometimes you need to convert one data type to another. There are two ways: 🔄 Implicit Casting (automatic) — smaller → larger type. No data loss. byte → short → int → long → float → double Java handles this silently. No worries. ⚠️ Explicit Casting (manual) — larger → smaller type. You're in control, but precision is lost. Example: double a = 45.5; byte b = (byte) a; // b stores 45, 0.5 is gone forever That 0.5? Lost. That's the trade-off. --- And lastly — Boolean in Java. Just true or false. Simple. But its size? Decided by the JVM, which is platform-dependent. --- Summary: Understanding how data is stored and converted is not just theory, it directly affects how your programs behave, perform, and sometimes fail silently. #Java #Programming #LearnToCode #ComputerScience #JavaDeveloper #CodingTips #Tech #Unicode #ASCII #TypeCasting #Upskill

𝐎𝐮𝐭 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐎𝐥𝐝, 𝐈𝐧 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐍𝐞𝐰 Java has evolved, and with it, a simpler, more modern approach to writing immutable data types records. In previous versions of Java, creating simple value objects required a significant amount of boilerplate code. 𝐓𝐡𝐞 𝐎𝐥𝐝 𝐖𝐚𝐲 public class Point {   private final int x, y;   public Point(int x, int y) {     this.x = x;     this.y = y;   }   public int getX() { return x; }   public int getY() { return y; }       @Override   public boolean equals(Object obj) { ... }   @Override   public int hashCode() { ... }   @Override   public String toString() { ... } } 𝐓𝐡𝐞 𝐍𝐞𝐰 𝐖𝐚𝐲 Now, with records, all that boilerplate is handled for you. A record automatically generates A constructor equals(), hashCode(), and toString() methods public record Point(int x, int y) {} When you have simple value objects with immutable data. When you don’t need additional logic like setters, mutable fields, or complex methods. #Java #JavaRecords #Programming #Coding #ImmutableData #BoilerplateCode #CleanCode #Java14 #ModernJava #SoftwareDevelopment #CodeSimplification #ObjectOrientedProgramming #JavaBestPractices #JavaTips #JavaDeveloper #TechTrends #DeveloperLife #JavaSyntax #JavaProgramming #RecordClass #TechInnovation #CodingTips #JavaCommunity

🚀 LeetCode Day 18 – Complement of Base 10 Integer Today I solved LeetCode Problem 1009: Complement of Base 10 Integer using Java. 🧠 Problem: Given a non-negative integer n, return the complement of its binary representation. The complement means flipping all bits in the binary form of the number. 📌 Example: Input: n = 5 Binary of 5 → 101 Complement → 010 Output → 2 💡 Approach: • Create a bitmask with all bits set to 1 up to the highest bit of n. • Use the XOR (^) operator with the mask to flip the bits. 💻 Java Code: class Solution { public int bitwiseComplement(int n) { if (n == 0) return 1; int mask = 0, temp = n; while (temp > 0) { mask = (mask << 1) | 1; temp >>= 1; } return n ^ mask; } } ⏱️ Time Complexity: O(log n) 📦 Space Complexity: O(1) 📚 Practicing Data Structures & Algorithms daily to improve problem-solving skills. #LeetCode #Java #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Day 33 of #100DaysOfLeetCode 💻✅ Solved #145. Binary Tree Postorder Traversal on LeetCode using Java. Approach: • Used recursion to perform postorder traversal • Followed Left → Right → Root order strictly • Traversed left subtree first • Then traversed right subtree • Added node value after visiting both subtrees Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 43.12 MB (Beats 71.37% submissions) Key Learning: ✓ Clearly understood difference between preorder, inorder, and postorder ✓ Strengthened recursive tree traversal concepts ✓ Improved confidence in handling binary tree problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

Day 32 of #100DaysOfLeetCode 💻✅ Solved #144. Binary Tree Preorder Traversal on LeetCode using Java. Approach: • Used recursion to perform preorder traversal • Followed Root → Left → Right order strictly • Added node value before traversing subtrees • Traversed left subtree first, then right subtree • Stored values in a list during traversal Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 42.83 MB (Beats 96.77% submissions) Key Learning: ✓ Strengthened understanding of preorder traversal pattern ✓ Clearly differentiated preorder from inorder traversal ✓ Improved recursive tree traversal implementation skills Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

Day 31 of #100DaysOfLeetCode 💻✅ Solved #94. Binary Tree Inorder Traversal on LeetCode using Java. Approach: • Used recursion to perform inorder traversal • Followed Left → Root → Right order strictly • Traversed left subtree first before processing current node • Stored node values in a list during traversal • Returned the final list after complete traversal Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 42.76 MB (Beats 98.30% submissions) Key Learning: ✓ Strengthened understanding of tree traversal patterns ✓ Improved clarity on recursion stack behavior ✓ Reinforced difference between preorder, inorder, and postorder traversal Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode