Java String Operations: Declaration, Concatenation, Length, Case Conversion

💻 Today I Learned About Strings in Java In Java, Strings are a collection of characters enclosed within double quotes. They are objects and play a vital role in almost every Java program. There are two types of strings in Java: 🔹 Immutable Strings — Once created, they cannot be changed. Examples: name, date of birth, gender. 🔹 Mutable Strings — These can be modified. Examples: email ID, password, etc. For immutable strings, the class used is String. Strings created without using new keyword are stored in the String Constant Pool. Strings created using new keyword are stored in the Heap Memory. There are multiple ways to compare strings in Java: == → Compares references equals() → Compares values compareTo() → Compares character by character equalsIgnoreCase() → Compares values ignoring case differences Some commonly used String methods are: toLowerCase(), toUpperCase(), length(), charAt(), startsWith(), endsWith(), contains(), indexOf(), lastIndexOf(), and substring(). For mutable strings, we have two classes: StringBuffer → Synchronized, thread-safe, slower, suitable for multi-threaded environments. StringBuilder → Non-synchronized, not thread-safe, faster, suitable for single-threaded environments. ✨ Understanding strings is fundamental in Java, as they form the basis for text manipulation, data handling, and efficient memory management. #Java #String #Programming #Learning #JavaDeveloper #CodingJourney #TechLearning #SoftwareDevelopment #Immutable #Mutable #StringBuilder #StringBuffer

Method overloading in Java is when a class has multiple methods with the same name but different parameters (either in number or type). This allows you to perform similar but slightly different tasks using the same method name, improving code readability and reducing redundancy. java example : class Calculator { // Adds two integers public int add(int a, int b) { return a + b; } // Adds three integers public int add(int a, int b, int c) { return a + b + c; } // Adds two double values public double add(double a, double b) { return a + b; } } public class Test { public static void main(String[] args) { Calculator calc = new Calculator(); System.out.println(calc.add(5, 10)); // calls add(int, int) System.out.println(calc.add(5, 10, 15)); // calls add(int, int, int) System.out.println(calc.add(5.5, 3.2)); // calls add(double, double) } } Here, the add method name is overloaded with different parameter lists. The compiler decides which method to call based on arguments given. Summary: Method overloading means same method name, different parameters.Improves code clarity; no need for different method names for similar actions.Compiler selects correct method based on argument types/count. #Java #MethodOverloading #ProgrammingConcepts #CodingTips #JavaBasics #JavaDevelopment #100DaysOfCode #Day6ofcoding

🚀 Mastering Strings in Java – The Backbone of Text Handling! 🧵 In Java, Strings are more than just text — they’re objects that make text manipulation powerful and efficient. Let’s break it down 👇 🔹 1. What is a String? A String in Java is an object that represents a sequence of characters. Example: String name = "Java"; Yes, even though it looks simple — it’s backed by the String class in java.lang package! 🔹 2. Immutable by Nature 🧊 Once created, a String cannot be changed. If you modify it, Java creates a new object in memory. String s = "Hello"; s = s + " World"; // Creates a new String object ✅ Immutability ensures security, caching, and thread-safety. 🔹 3. String Pool 🏊♂️ Java optimizes memory by storing String literals in a special area called the String Constant Pool. If two Strings have the same literal value, they point to the same memory! 🔹 4. Common String Methods 🛠️ s.length(); // Returns length s.charAt(0); // Returns first character s.toUpperCase(); // Converts to uppercase s.equals("Java"); // Compares values s.substring(0, 3);// Extracts substring 🔹 5. Mutable Alternatives 🧱 For performance-heavy string manipulations, use: StringBuilder (non-thread-safe, faster) StringBuffer (thread-safe) 💡 Pro Tip: Use StringBuilder inside loops for better performance instead of concatenating Strings repeatedly. #Java #Programming #Coding #100DaysOfCode #JavaDeveloper #StringsInJava #SoftwareDevelopment #TechLearning

🧩 Day 12: String Methods in Java (In Depth) Today I explored some powerful built-in methods that make string handling efficient and flexible. These are the real tools behind text manipulation in Java! 💡 What I Learned Today substring(start, end) → Extracts part of a string replace(oldChar, newChar) → Replaces characters equalsIgnoreCase() → Compares strings ignoring case trim() → Removes extra spaces indexOf() → Finds position of a character or substring contains() → Checks if substring exists split() → Splits string into parts based on a delimiter 🧩 Example Code public class StringMethods {   public static void main(String[] args) {     String text = " Java Programming ";     System.out.println("Original: '" + text + "'");     System.out.println("Trimmed: '" + text.trim() + "'");     System.out.println("Substring: " + text.substring(2, 6));     System.out.println("Replace: " + text.replace("a", "@"));     System.out.println("Contains 'Java': " + text.contains("Java"));     System.out.println("Index of 'P': " + text.indexOf("P"));   } }

✨ Day 11: Strings in Java Today’s focus was on Strings — the heart of text processing in Java. They’re everywhere: names, messages, inputs, and more! 💡 What I Learned Today String is a class in Java, not a primitive type. Strings are immutable – once created, they can’t be changed. Common ways to create strings: Using string literal: "Hello" Using new keyword: new String("Hello") Common methods: length() → returns string length charAt(i) → returns character at index toUpperCase(), toLowerCase() concat() or + → combines strings equals() → compares content 🧩 Example Code public class StringExample {   public static void main(String[] args) {     String name = "Java";     String message = "Welcome to " + name;     System.out.println(message);     System.out.println("Length: " + message.length());     System.out.println("Uppercase: " + message.toUpperCase());     System.out.println("Character at 5: " + message.charAt(5));   } } 🗣️ Caption for LinkedIn 💬 Day 11 – Strings in Java Strings bring life to Java programs — from handling names to dynamic messages. Today I learned how to create, modify, and compare strings efficiently. Fun fact: Strings are immutable but incredibly powerful when used right! #CoreJava #JavaDeveloper #Programming #LearnJava #CodingJourney

💡 Mastering Java Strings - Once and For All 🚀 Strings in Java are simple to use… until you start comparing or modifying them. Let’s break it down clearly 👇 🔹 1️⃣ String Literals vs new String() String a = "abc"; // String literal → stored in String Pool String b = new String("abc"); // New object → stored in Heap 🔹 2️⃣ Reference Change String a = "abc"; a = "def"; System.out.println(a); ✅ Output: def Here, the reference of a changes from "abc" to "def". The original "abc" still exists in the String Pool, but a no longer points to it. Because Strings are immutable in Java, their values can’t be modified once created. 🔹 3️⃣ concat() Behavior String a = "abc"; a.concat("ghi"); System.out.println(a); ✅ Output: abc concat() creates a new String object "abcghi" but doesn’t change the original one. To update it, you must reassign: a = a.concat("ghi"); // Now a = "abcghi" 🔹 4️⃣ == vs .equals() String a = "abc"; String b = new String("abc"); System.out.println(a == b); // false → compares memory reference System.out.println(a.equals(b)); // true → compares actual content 🧠 If you do: String b = "abc"; Then both point to the same literal in the String Pool, so a == b → ✅ true. 🧩 Summary Concept Checks/Behavior Example Output Immutability - Value can’t change Reference change - Needs reassignment == - Compares reference false .equals() - Compares value true 💬 In short: Strings are immutable. == compares memory reference. .equals() compares actual content. Methods like concat() return a new object, not modify the old one. Once you get this, Strings in Java become super easy 💪 #Java #Programming #CodingTips #JavaDeveloper #Backend #Learning

Java Practice — Palindrome Check Using Streams Today I revisited a small but powerful problem: checking if a string is a palindrome — this time using Java Streams for a more functional approach. Here’s the snippet I practiced: import java.util.stream.IntStream; public class PalindromeWithStreams {   public static void main(String[] args) {     String s = "madam";          boolean isPalindrome = IntStream.range(0, s.length() / 2)         .allMatch(i -> s.charAt(i) == s.charAt(s.length() - i - 1));     System.out.println(isPalindrome ? "Palindrome" : "Not palindrome");   } } > Key takeaway: 1: IntStream.range(0, s.length() / 2) generates indices for only half the string. 2: .allMatch() ensures every pair of characters (from front and back) are equal. 3: Clean, concise, and expressive — a great example of functional programming in modern Java. #Java #Streams #CodingPractice #ProblemSolving #CleanCode #DevelopersJourney

🚀 Java Date Formatting: Controlling Output with SimpleDateFormat ✍️ After covering the basic Date class, today I focused on formatting dates. The raw output of a Date object isn't always user-friendly, so the java.text.SimpleDateFormat class is essential for presenting dates in customized, readable ways. Key Formatting Patterns The SimpleDateFormat class uses specific pattern letters to define the output structure: Numeric Dates & Time: "dd/MM/yyyy HH:mm" (e.g., 14/11/2025 11:21): Uses numeric values for all components. Year-First Order: "yyyy/MM/dd" (e.g., 2025/11/14): Useful for file naming or strict international standards. Abbreviated Month/Day: "dd MMM yyyy" (e.g., 14 Nov 2025): Uses the short text representation for the month. Full Text Month: "dd MMMM yyyy" (e.g., 14 November 2025): Uses the full text name for the month. Day of the Week: "EEEE dd MMMM yyyy" (e.g., Friday 14 November 2025): Includes the full name of the day of the week. 🛠️ The Process The process is straightforward: Create a Date object (the data). Create a SimpleDateFormat object with the desired pattern (the presentation rule). Call the .format(Date obj) method to apply the rule and generate the formatted String. This control over presentation is vital for building clean user interfaces and standardizing data exchange! Thank you sir Anand Kumar Buddarapu,Saketh Kallepu,Uppugundla Sairam,Codegnan #Java #Programming #DateFormatting #SimpleDateFormat #JavaUtilities #TechEducation