Convert String to 32-bit Signed Integer in Java

Leetcode Practice - 16. 3Sum Closest The problem is solved using JAVA Given an integer array nums of length n and an integer target, find three integers at distinct indices in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution.   Example 1: Input: nums = [-1,2,1,-4], target = 1 Output: 2 Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2). Example 2: Input: nums = [0,0,0], target = 1 Output: 0 Explanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).   Constraints: 3 <= nums.length <= 500 -1000 <= nums[i] <= 1000 -104 <= target <= 104 #LeetCode #Java #CodingPractice #ProblemSolving #DSA #Array #DeveloperJourney #TechLearning

Leetcode Practice - 15. 3Sum The problem is solved using JAVA. Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0. Notice that the solution set must not contain duplicate triplets.   Example 1: Input: nums = [-1,0,1,2,-1,-4] Output: [[-1,-1,2],[-1,0,1]] Explanation: nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0. nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0. nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0. The distinct triplets are [-1,0,1] and [-1,-1,2]. Notice that the order of the output and the order of the triplets does not matter. Example 2: Input: nums = [0,1,1] Output: [] Explanation: The only possible triplet does not sum up to 0. Example 3: Input: nums = [0,0,0] Output: [[0,0,0]] Explanation: The only possible triplet sums up to 0.   Constraints: 3 <= nums.length <= 3000 -105 <= nums[i] <= 105 #LeetCode #Java #CodingPractice #ProblemSolving #DSA #Array #DeveloperJourney #TechLearning

💻 String vs StringBuffer vs StringBuilder in Java – Know the Difference! In Java, handling text data is very common. Let’s understand the three important classes: 🔹 1. String ✔ Immutable (cannot be changed once created) ✔ Any modification creates a new object ✔ Safe and widely used Example: "String s = "Hello";" "s = s + " World"; // creates new object" --- 🔹 2. StringBuffer ✔ Mutable (can be changed) ✔ Thread-safe (synchronized) ✔ Slightly slower due to synchronization Example: "StringBuffer sb = new StringBuffer("Hello");" "sb.append(" World");" --- 🔹 3. StringBuilder ✔ Mutable (can be changed) ✔ Not thread-safe ✔ Faster than StringBuffer Example: "StringBuilder sb = new StringBuilder("Hello");" "sb.append(" World");" --- 💡 Key Difference: String = Immutable StringBuffer = Mutable + Thread-safe StringBuilder = Mutable + Faster 🚀 Use String for simple tasks, StringBuffer for multi-threading, and StringBuilder for better performance in single-threaded applications. #FortuneCloudTechnology #Java #Programming #String #JavaBasics #Coding #Developers #Learning

Day 11/100 – Java Practice Challenge 🚀 Continuing my #100DaysOfCode journey with another important Java concept. 🔹 Topic Covered: Compile-time vs Runtime Polymorphism 💻 Practice Code: 🔸 Compile-time Polymorphism (Method Overloading) class Calculator { int add(int a, int b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } } 🔸 Runtime Polymorphism (Method Overriding) class Animal { void sound() { System.out.println("Animal sound"); } } class Cat extends Animal { @Override void sound() { System.out.println("Cat meows"); } } public class Main { public static void main(String[] args) { // Compile-time Calculator c = new Calculator(); System.out.println(c.add(10, 20)); System.out.println(c.add(10, 20, 30)); // Runtime Animal a = new Cat(); a.sound(); } } 📌 Key Learnings: ✔️ Compile-time → method decided at compile time ✔️ Runtime → method decided at runtime ✔️ Overloading vs Overriding difference 🎯 Focus: Understanding how Java resolves method calls 🔥 Interview Insight: Difference between compile-time and runtime polymorphism is one of the most frequently asked Java interview questions. #Java #100DaysOfCode #MethodOverloading #MethodOverriding #Polymorphism #JavaDeveloper #Programming #LearningInPublic

Day 43-Understanding Runtime Polymorphism in Java If compile-time polymorphism is about decisions made early, runtime polymorphism is where things get interesting — decisions are made while the program is running. What is Runtime Polymorphism? Runtime polymorphism is the ability of a program to decide which method to execute at runtime based on the object. It is achieved using method overriding. 🔹 Simple Idea: Same method name, same parameters… but different behavior depending on the object. 🔹 Example: class Card { void swipe() { System.out.println("Please wait..."); } } class CreditCard extends Card { void swipe() { System.out.println("Payment via Credit Card"); } } class DebitCard extends Card { void swipe() { System.out.println("Payment via Debit Card"); } } public class Main { public static void main(String[] args) { Card c; c = new CreditCard(); c.swipe(); // Credit Card method c = new DebitCard(); c.swipe(); // Debit Card method } } 🔹 What’s happening here? - The reference type is Card - But the object changes (CreditCard / DebitCard) - JVM decides which method to call at runtime 🔹 Key Points: ✔ Happens at runtime (execution time) ✔ Achieved using method overriding ✔ Also called Dynamic Binding / Late Binding ✔ JVM decides method execution based on actual object This is what makes Java powerful and flexible in real-world applications. #Java #OOP #Polymorphism #CodingJourney #ProgrammingBasics

. 🚀 Day 2 — First & Last Index of Repeating Characters ✅ Problem Find the first and last occurrence index of each repeating character in a string. import java.util.*; import java.util.stream.*; class FirstLastIndexFinder { public static void main(String[] args) { String input = "Programming"; Map<Character, List<Integer>> map = IntStream.range(0, input.length()) .boxed() .collect(Collectors.groupingBy( i -> input.charAt(i), LinkedHashMap::new, Collectors.toList() )); map.entrySet().stream() .filter(entry -> entry.getValue().size() > 1) .forEach(entry -> { List<Integer> indexes = entry.getValue(); System.out.println( "Key: " + entry.getKey() + ", First Index: " + indexes.get(0) + ", Last Index: " + indexes.get(indexes.size() - 1) ); }); } } 💡 Explanation 👉 Step-by-step: Use IntStream.range() to iterate over indexes Group indexes by character using groupingBy() Use LinkedHashMap to maintain insertion order Filter characters that appear more than once Get: First index → indexes.get(0) Last index → indexes.get(size - 1) ✅ Output Key: r, First Index: 1, Last Index: 9 Key: g, First Index: 3, Last Index: 10 Key: m, First Index: 6, Last Index: 7 Happy Learning!!!

Most Java mistakes I see in code reviews come from the same 20 misunderstandings. After reviewing thousands of pull requests, these patterns keep showing up, especially from developers in their first 2 years. Here is what trips people up the most: → Using == instead of .equals() for String comparison → Mutating Date objects when LocalDate exists → Throwing checked exceptions for programming errors → Using raw types instead of generics → Concatenating Strings in loops instead of StringBuilder → Writing nested null checks instead of using Optional → Defaulting to arrays when ArrayList gives you flexibility → Wrapping everything in synchronized when ConcurrentHashMap exists → Catching Exception instead of the specific type you expect → Making utility methods static when they should be instance methods → Using new String("hello") instead of string literals → Using Integer when int would suffice → Repeating type args instead of using the diamond operator → Manual close() in finally instead of try-with-resources → Using static final int constants instead of enums → Writing verbose for-if-add loops instead of streams → Using Arrays.asList when List.of gives true immutability → Spelling out full types when var keeps code clean → Writing boilerplate classes when records do the job → Concatenating strings with \n instead of using text blocks None of these are hard to fix once you see the pattern. The real problem is that nobody points them out early enough. Save this for your next code review. #Java #SoftwareDevelopment #Programming #CleanCode #CodingTips

💡 Java Tip: One Method to Remember for Type Conversion We used to rely on: Integer.parseInt(), Long.parseLong(), Double.parseDouble() → for converting String to primitives String.valueOf() → for converting values to String It works—but it can get confusing when switching between primitives, wrapper classes, and even char ↔ String conversions. 🔑 Simple takeaway: You can simplify most conversions by remembering just one method: 👉 WrapperClass.valueOf() ✅ Converts String → Wrapper (Integer, Long, Double, etc.) ✅ Works well with primitives (via autoboxing/unboxing) ✅ Keeps your code more consistent and readable Example: Integer i = Integer.valueOf("10"); Double d = Double.valueOf("10.5"); String s = String.valueOf(100); 🧠 Personal learning: Instead of memorizing multiple parsing methods, focusing on valueOf() makes type conversion easier to reason about and reduces cognitive load while coding. #Java #CleanCode #ProgrammingTips #BackendDevelopment #SoftwareEngineering #Learning

Q. Can an Interface Extend a Class in Java? This is a common confusion among developers and even I revisited this concept deeply today. - The answer is NO, an interface cannot extend a class. - It can only extend another interface. But there is something interesting: - Even though an interface doesn’t extend Object, all public methods of the Object class are implicitly available inside every interface. Methods like: • toString() • hashCode() • equals() These are treated as abstractly redeclared in every interface. ⚡ Why does Java do this? - To support upcasting and polymorphism, ensuring that any object referenced via an interface can still access these fundamental methods. ❗ Important Rule: While you can declare these methods in an interface, you cannot provide default implementations for them. interface Alpha { default String toString() { // ❌ Compile time error return "Hello"; } } Reason? Because these methods already have implementations in the Object class. Since every class implicitly extends Object, allowing default implementations of these methods in interfaces would create ambiguity during method resolution. Therefore, Java does not allow interfaces to provide default implementations for Object methods. 📌 Interfaces don’t extend Object, but its public methods are implicitly available. However, default implementations for them are not allowed. #Java #OOP #InterviewPreparation #Programming #Developers #Learning #SoftwareEngineering

Think var in Java is just about saving keystrokes? Think again. When Java introduced var, it wasn’t just syntactic sugar — it was a shift toward cleaner, more readable code.  So what is var? var allows the compiler to automatically infer the type of a local variable based on the assigned value. Instead of writing: String message = "Hello, Java!"; You can write: var message = "Hello, Java!"; The type is still strongly typed — it’s just inferred by the compiler.  Why developers love var:  Cleaner Code – Reduces redundancy and boilerplate  Better Readability – Focus on what the variable represents, not its type  Modern Java Practice – Aligns with newer coding standards  But here’s the catch: Cannot be used without initialization Only for local variables (not fields, method params, etc.) Overuse can reduce readability if the type isn’t obvious Not “dynamic typing” — Java is still statically typed  Pro Insight: Use var when the type is obvious from the right-hand side — avoid it when it makes the code ambiguous.  Final Thought: Great developers don’t just write code — they write code that communicates clearly. var is a tool — use it wisely, and your code becomes not just shorter, but smarter. Special thanks to Syed Zabi Ulla and PW Institute of Innovation for continuous guidance and learning support. #Java #Programming