Pranay Gottipati’s Post

✨ 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

Day 14 of #JavaWithDSAChallenge , Factorials of Large Numbers Today’s problem was about calculating the factorial of very large numbers that can’t be stored in standard data types like int or long. To solve this, I implemented a custom multiplication logic using an ArrayList simulating how we do multiplication manually, digit by digit. Code Snippet: import java.util.*; class Solution { public ArrayList<Integer> factorial(int n) { ArrayList<Integer> res = new ArrayList<>(); res.add(1); for (int x = 2; x <= n; x++) { multiply(res, x); } Collections.reverse(res); return res; } private static void multiply(ArrayList<Integer> res, int x) { int carry = 0; for (int i = 0; i < res.size(); i++) { int product = res.get(i) * x + carry; res.set(i, product % 10); carry = product / 10; } while (carry != 0) { res.add(carry % 10); carry /= 10; } } } Key Takeaways: Handling large numbers requires manual simulation of multiplication. ArrayList makes it easy to store and manage individual digits dynamically. Managing carry efficiently is crucial for accurate results. Reinforced my understanding of loops, lists, and modular arithmetic in Java. Sometimes, solving big problems means thinking digit by digit! #Day14 #JavaWithDSAChallenge #GeeksforGeeks #JavaProgramming #DSA #CodingChallenge #ProblemSolving #100DaysOfCode #CodeNewbie #CodingJourney #LearnToCode #ProgrammersLife

Today I learned that from Java 23+ all annotation processors have been explicitly disabled by default. Before Java 23 the full classpath was scanned for any processors and those were automatically picked up. An attacker could exploit this by slipping a malicious processor into one of the many dependencies in your project. Otherwise known as a supply chain attack. That is why Bob stopped working according to some of my colleagues who switched from Java 21 to 25. Turned out it wasn't Bob after all. As such I updated Bobs documentation on how to explicitly set the annotation processor so you can happily generate your builders! https://lnkd.in/eQjD7hcq #java

🌟 Day 15 – Cracking the Core Concept: Arrays in Java ☕💻 Today, I stepped into one of the most essential concepts in Java — Arrays. They might look simple at first glance, but understanding how they actually store and manage data opened a new perspective for me. 💡 Key Takeaways: 🔹 Arrays allow us to store multiple values of the same type under a single variable name. 🔹 Each element is indexed — starting from 0 — making it easy to access and modify data efficiently. 🔹 Memory for arrays is allocated in a continuous block, which helps in faster data access. 🔹 Learned how to declare, initialize, and traverse arrays using loops. 🔹 Explored common pitfalls like index out of bounds and fixed-size limitations. 💭 Reflection: Before today, I just thought of arrays as “lists of numbers,” but now I realize how crucial they are for building larger data structures like matrices, stacks, and queues later on. #JavaLearningJourney #LearnInPublic #JavaProgramming #Arrays #ProblemSolving #CodeEveryday #100DaysOfCode #DeveloperJourney #BackendDevelopment #NamasteJava #KeepLearning

(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

🚀 A Small but Powerful Java Tip — Logging Done Right! Recently, I came across a subtle performance pitfall that often sneaks into production code — string concatenation in log statements. Let’s look at this simple example: log.debug("User data: " + user.getName() + " age: " + user.getAge()); At first glance, it seems fine. But here’s the catch 👉 even if debug logging is disabled in production, the string concatenation will still happen before log.debug() is called! That means: Unnecessary object creation Extra memory usage in the String pool Avoidable CPU overhead ✅ The better approach: use parameterized logging — log.debug("User data: {} age: {}", user.getName(), user.getAge()); With this, the concatenation is skipped entirely if debug logging is off. The logging framework (like Log4j or SLF4J) only processes the message if that log level is actually enabled. 🧠 Takeaway: Even small code choices like this can make your production code a bit leaner and more efficient. Use parameterized logging — save memory, save CPU, and write cleaner logs. #Java #Logging #CleanCode #Performance #BestPractices

🌳 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

How HashMap Works in Java Behind the Scenes Ever wondered what really happens when you write: map.put("Aman", 101); Let’s break it down visually. 1) Hashing: The key’s hashCode() is calculated. Example: "Aman".hashCode() gives an integer. This number decides where the entry will go inside the HashMap. 2) Index Calculation: That hash value is converted to a bucket index using: index = hash & (n - 1); This ensures it fits within the internal array size (n). 3) Bucket Storage (Collision Handling): Each bucket is like a locker. If the locker is empty, your entry is stored directly. If another entry already exists at that index, a linked list is created to chain them. Since Java 8, if too many entries go into the same bucket, it converts into a balanced tree for faster lookup. 4) Lookup / Update: When you do map.get("Aman"), Java repeats the same hash process to find the correct bucket and retrieve the value usually in O(1) time. In short: HashMap = Hashing + Buckets + Trees → Fast & Efficient key-value storage #Java #HashMap #DataStructures #BackendDevelopment #SpringBoot #CodingInsights #Programming

🔹 StringBuilder vs StringBuffer ✨ Both StringBuilder and StringBuffer are used to create mutable strings, meaning their content can be modified after creation. 👉 However, they differ in thread-safety and performance. 🧱 StringBuilder ▪️ Introduced in Java 5. ▪️ Mutable — can modify content without creating a new object. ▪️ Not thread-safe (no synchronization). ▪️ Offers better performance in single-threaded environments. ▪️ Ideal for non-concurrent operations where speed matters. 🔒 StringBuffer ▪️ Introduced in Java 1.0. ▪️ Mutable — can also modify content without creating new objects. ▪️ Thread-safe (methods are synchronized). ▪️ Slightly slower due to synchronization overhead. ▪️ Best suited for multi-threaded environments where multiple threads modify the same string. 💡 In short: Use StringBuilder for single-threaded programs (faster), and StringBuffer for multi-threaded programs (safer). #Java #StringBuilder #StringBuffer #CodingBasics #StringHandling