Java String & Character Methods for Coding

🚀 Day 25/50 – LeetCode Challenge Today’s problem: To Lower Case (#709) 🔤 Problem Statement: Given a string s, convert all uppercase letters into lowercase and return the result. 💡 Example: Input: "Hello" Output: "hello" 🧠 Approach: This problem is straightforward and perfect for beginners. Java provides a built-in method toLowerCase() which makes the solution clean and efficient. Alternatively, we can manually convert characters by checking if they fall between 'A' and 'Z' and then adding 32 to shift them to lowercase. 👨💻 Java Solution: class Solution { public String toLowerCase(String s) { return s.toLowerCase(); } } ⚡ Complexity: Time: O(n) Space: O(n) 📌 Key Takeaway: Even simple problems help reinforce fundamentals. Understanding character encoding (ASCII) can be very useful in string manipulation problems. Consistency > Complexity 💯 #Day25 #LeetCode #Java #DSA #CodingChallenge #50DaysOfCode #LearningJourney

Day 23-What I Learned In a Day(JAVA) Today I explored more concepts in Java, especially related to methods and return types. I learned about the different logics that can be written inside a method, such as calculations, conditional statements, loops, and returning values to the calling method. Methods help organize code and make programs more reusable and structured. Along with that, I also explored common mistakes that cause compile-time errors in methods. For example: *Declaring a return type but not returning a value. *Returning a different data type than the declared return type. *Writing incorrect method syntax. *Calling a method with wrong parameters or missing arguments. *Using a method before declaring it properly. By practicing different programs, I was able to identify these errors and understand how to fix them. Exploring both correct logic and compile-time errors helped me gain a deeper understanding of how methods work in Java. This practice improved my problem-solving skills and debugging ability while writing Java programs. Practiced 👇 #Java #CoreJava #JavaMethods #CodingPractice #ProgrammingJourney #LearnJava #DeveloperSkills #TechLearning

💡 The Java Habit That Instantly Made My Code Cleaner One habit improved my Java code more than any framework or library. Naming things properly. Sounds simple, but it’s surprisingly hard. Compare this: int d;  vs int daysSinceLastLogin; Or this: processData(); vs calculateMonthlyRevenue(); Good naming does 3 powerful things: ✔ Makes code self-documenting ✔ Reduces the need for excessive comments ✔ Helps other developers understand your logic instantly I realized that most messy code isn't complex — it's just poorly named. Now I follow one rule: 👉 If someone can understand the code without asking me questions, the naming is good. Clean code is not just about algorithms or patterns. Sometimes it's just about choosing better words. 💬 What’s the worst variable or method name you’ve ever seen in a codebase? #Java #CleanCode #SoftwareEngineering #JavaDeveloper #CodingBestPractices #BuildInPublic

Streams look powerful. But the real shift happens with 𝗟𝗮𝗺𝗯𝗱𝗮 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀. Before Java 8, behavior was verbose. If you wanted to pass logic, you had to: • Create a class • Implement an interface • Override a method Now, you can write: x -> x * 2 That single line represents behavior. A lambda is: • An anonymous function • A block of code treated as data • A way to pass behavior as a parameter Example: List<Integer> numbers = Arrays.asList(1, 2, 3); numbers.forEach(n -> System.out.println(n)); Instead of defining a separate class, you directly provide the action. Lambdas improve: • Readability • Conciseness • Functional-style programming They work because of 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲𝘀 — interfaces with exactly one abstract method. Today was about: • Understanding lambda syntax • How lambdas implement functional interfaces • Writing cleaner and more expressive behavior Less boilerplate. More intent. That’s modern Java. #Java #Lambda #FunctionalProgramming #Streams #CleanCode #LearningInPublic

🚀 15 Days of Java 8 – #Day5: Transforming with `map()` What is the `map()` operation in streams, and how is it different from `filter()`? ✅ Answer: The `map()` operation is an intermediate operation that transforms each element of a stream into another object by applying a function to it. While `filter()` selects elements, `map()` changes them. - `filter(n -> n > 5)`: Takes an `Integer` and returns a `boolean`. The stream remains a stream of `Integer`s. - `map(s -> s.length())`: Takes a `String` and returns an `int`. The stream of `String`s is transformed into a stream of `Integer`s. //--- Code Snippet: Get a list of names' lengths --- List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); List<Integer> nameLengths = names.stream()   .map(name -> name.length())   .collect(Collectors.toList()); // Result: [5, 3, 7] //---------------------------------------------------- 💡 Takeaway: Use `filter()` when you want to reduce the number of elements in a stream. Use `map()` when you want to transform each element into something else. 📢 Filtering and mapping are the two most fundamental stream operations! 🚀 Day 6: Chaining operations into a pipeline! 💬 How would you use `map` to convert a list of strings to all uppercase? 👇 #Java #Java8 #StreamAPI #Map #FunctionalProgramming #DataTransformation #15DaysOfJava8

🚀 Java Collections — Stop Memorizing, Start Understanding This diagram looks simple… until you’re asked why things work the way they do. 👇 🔹 Iterable → Collection → List / Set / Queue Everything flows from here. If you don’t get this structure, you’re guessing. 🔹 List - Maintains order - Allows duplicates - ArrayList → fast read, slow insert - LinkedList → fast insert, slow access 🔹 Set - No duplicates allowed - HashSet → fastest, no order - LinkedHashSet → maintains insertion order - TreeSet → sorted, but slower 🔹 Queue / Deque - Built for processing (FIFO / LIFO) - Used in real-world systems like task scheduling 🔹 Map (Separate hierarchy) - Key-value structure - HashMap → O(1) (average) - LinkedHashMap → ordered - TreeMap → sorted (O(log n)) #Java #CollectionsFramework #Coding #DSA #BackendDevelopment

Many developers overlook a small but important difference in Java: == vs .equals() String s1 = new String("Java"); String s2 = new String("Java"); System.out.println(s1 == s2); // false System.out.println(s1.equals(s2)); // true ✔ == compares memory references (whether both variables point to the same object). ✔ .equals() compares the actual content of the objects. Even though s1 and s2 contain the same value, they are stored as different objects in memory, so == returns false. 💡 This distinction becomes critical when working with collections like HashMap, HashSet, or custom objects. Strong Java fundamentals often come down to understanding small details like these. #Java #Programming #JavaDeveloper #Coding #SoftwareEngineering LinkedIn Guide to Networking LinkedIn Learning Community LinkedIn Learning

Day 27 of #100DaysOfLeetCode 💻✅ Solved #83. Remove Duplicates from Sorted List on LeetCode using Java. Approach: • Utilized the fact that the linked list is already sorted • Traversed the list using a single pointer • Compared current node value with next node value • If duplicate found, skipped the next node by updating links • Continued traversal until reaching the end of the list Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 45.30 MB (Beats 85.70% submissions) Key Learning: ✓ Understood how sorting simplifies duplicate removal logic ✓ Strengthened pointer manipulation skills in linked lists ✓ Learned efficient in-place modification without extra space Learning one problem every single day 🚀 #Java #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #100DaysOfCode

Day 25 -What I Learned In a Day(JAVA) Today I learned about conditional and control statements in Java, which allow programs to make decisions, repeat tasks, or alter the flow of execution. Three Types of Control Statements in Java: *Decision Statements (Decision Making) Used to execute code based on conditions. Examples: if / if-else / nested if-else – Executes code if condition is true or false. switch – Executes code based on the value of a variable. *Looping Statements: Used to repeat a block of code multiple times. Examples: for, while, do-while. *Jump Statements: Used to alter the normal flow of execution in loops or methods. Examples: break, continue, return. Today I Practiced 20 questions based on the decision making statement if,else. Practiced 👇 #Java #IfElse #ConditionalStatement #NestedIfElse #DecisionMaking #LogicalOperators #ComparisonOperators #JavaPractice #ProgrammingBasics #FlowControl #TodayILearned #CodingPractice

✅ DSA Day 8 / 100 Solved Reverse an Array on HackerRank using Java. Problem: Given an array, return the array in reverse order. Logic : - Use the built-in method Collections.reverse() -This method reverses the elements of the list directly -Then return the reversed list This problem helped me understand how arrays/lists can be manipulated easily using Java utility methods. #DSA #100DaysOfCode #Java #HackerRank #LearningInPublic #BeginnerDSA