Understanding Java Strings and Memory Optimization

☕ Java Generics – Upper Bounded Wildcards Explained In Java Generics, the question mark (?) represents a wildcard, meaning an unknown type. Sometimes, we need to restrict the type of objects that can be passed to a method — especially when working with numbers or specific class hierarchies. That’s where Upper Bounded Wildcards come into play. 🔹 What is an Upper Bounded Wildcard? To restrict a wildcard to a specific type or its subclasses, we use: <? extends ClassName> This means: 👉 Accept ClassName or any of its subclasses. For example, if a method should only work with numeric types, we restrict it to Number and its subclasses like Integer, Double, etc. As explained in the document (Page 1), the syntax uses ? followed by the extends keyword to define the upper bound. 🔹 Practical Example From the example shown (Page 2), a method calculates the sum of elements in a list: public static double sum(List<? extends Number> numberlist) { double sum = 0.0; for (Number n : numberlist) sum += n.doubleValue(); return sum; } 📌 Why ? extends Number? ✔ Ensures only numeric types are allowed ✔ Accepts List<Integer> ✔ Accepts List<Double> ✔ Maintains type safety 🔹 Usage in Main Method List<Integer> integerList = Arrays.asList(1, 2, 3); System.out.println("sum = " + sum(integerList)); List<Double> doubleList = Arrays.asList(1.2, 2.3, 3.5); System.out.println("sum = " + sum(doubleList)); 🔹 Output (Page 3) sum = 6.0 sum = 7.0 This demonstrates how the same method works seamlessly with different numeric types. 💡 Upper bounded wildcards improve flexibility while maintaining compile-time type safety. They are essential for writing reusable and robust generic methods in Java. #Java #Generics #UpperBoundedWildcards #JavaProgramming #OOP #FullStackJava #Developers #AshokIT

🚀 Learning Core Java – Mutable Strings in Java Today I explored Mutable Strings in Java and how they differ from immutable String objects. Unlike the String class (which is immutable), mutable strings allow us to modify the same object without creating new objects in memory. Java provides two classes for mutable strings: 🔹 StringBuffer 🔹 StringBuilder ⸻ 🔹 Default Capacity Both StringBuffer and StringBuilder have a default capacity of 16 characters. When the content exceeds the current capacity, Java automatically increases the size using this formula: 👉 New Capacity = (Current Capacity × 2) + 2 This allows dynamic resizing without manual memory handling. ⸻ 🔹 Important Methods ✔ append() Adds new content to the end of the existing string without creating a new object. ✔ delete() Allows modification by removing specific characters from the existing string. ✔ trimToSize() Reduces the capacity to match the current content length, optimizing memory usage. ⸻ 🔹 Key Difference The main difference between the two: ✔ StringBuffer → Thread-safe (synchronized) ✔ StringBuilder → Not thread-safe (faster in single-threaded environments) In most modern applications, StringBuilder is preferred unless thread safety is required. ⸻ 🔎 Key Takeaway: Use mutable strings when frequent modifications are needed to improve performance and reduce unnecessary object creation. Excited to keep strengthening my Java fundamentals! 🚀 #CoreJava #JavaProgramming #MutableStrings #StringBuilder #StringBuffer #JavaDeveloper #ProgrammingFundamentals #LearningJourney

Day 15 – Learning Java Full Stack. Today, let’s strengthen two important fundamentals in Java: 🔹 Scanner (User Input) 🔹 Identifiers & Naming Conventions Scanner Class-Scanner is a built-in class present in the java.util package. It is used to read input from the keyboard. Step 1: Import Scanner Java import java.util.Scanner; Step 2: Create Scanner Object Java Scanner sc = new Scanner(System.in); Step 3: Read Values int val = sc.nextInt(); System.out.println("value = " + val); 📌 Common Scanner Methods nextInt() → reads integer nextFloat() → reads float nextDouble() → reads double nextBoolean() → reads boolean next() → reads single word nextLine() → reads full line If invalid input is entered → InputMismatchException occurs. 🔹 Reading a Character (Important Trick) Scanner does not provide a direct method to read char. So we use: char ch = sc.next().charAt(0); Here:next() reads input as String charAt(0) extracts the first character Identifiers – Naming in Java Any name given by the programmer is called an Identifier. Examples: Class names Method names Variable names 📌 Rules for Identifiers ✔ Must start with an alphabet ✔ Numbers are allowed (but not as first character) ✔ Cannot use Java keywords ✔ Cannot contain spaces ✔ Special characters like $ and _ are allowed but not recommended 🔹 Industry Naming Conventions ✔ Class Names → PascalCase ex- class StudentDetails class DatabaseTriggerManager ✔ Method & Variable Names → camelCase ex- void printBill() int employeeSalary void generateTextReport() Clean naming improves: Readability Maintainability Professionalism #Java #JavaFullStack #CoreJava #Scanner #Identifiers #CleanCode

Most Java developers get confused by this exception. Let me explain why. You run this code: System.out.println("12345".charAt(6)); And the stack trace says StringIndexOutOfBoundsException. But wait... shouldn't it be IndexOutOfBoundsException? 🤔 Here's the thing: it IS an IndexOutOfBoundsException. Java's exception hierarchy uses inheritance to give you MORE specific information, not different information. The hierarchy looks like this: RuntimeException  └── IndexOutOfBoundsException     ├── StringIndexOutOfBoundsException     └── ArrayIndexOutOfBoundsException This is polymorphism applied to exceptions 💡 → charAt() throws StringIndexOutOfBoundsException because the problem happened in a String → array[10] throws ArrayIndexOutOfBoundsException because the problem happened in an array → list.get(99) throws IndexOutOfBoundsException because the problem happened in a collection → A catch(IndexOutOfBoundsException e) block catches ALL of them Why does this matter? When you write catch blocks, you can choose your level of specificity. Catching the parent handles everything. Catching the child gives you precise control over what you handle and what you propagate. This is the same design principle behind Java's entire exception framework: specificity through inheritance. Understanding this hierarchy is what separates a developer who reads stack traces from one who truly understands them. ⚡ What other Java exceptions have tripped you up? Drop them in the comments 👇 📊 Oracle Java SE 17 Docs - IndexOutOfBoundsException API (2025) https://lnkd.in/eN_5XAp4 📊 Baeldung - Java ArrayIndexOutOfBoundsException (2025) https://lnkd.in/evZcjMHs 📊 Rollbar - How to Handle StringIndexOutOfBoundsException in Java (2022) https://lnkd.in/erHwcX4T #Java #SoftwareEngineering #Backend #ExceptionHandling #Programming #OOP #JavaDeveloper #CleanCode

DAY 24: CORE JAVA 💻 Understanding Buffer Problem & Wrapper Classes in Java While working with Java input using Scanner, many beginners face a common issue called the Buffer Problem. 🔹 What is the Buffer Problem? When we use "nextInt()", "nextFloat()", etc., the scanner reads only the number but leaves the newline character ("\n") in the input buffer. Example: Scanner scan = new Scanner(System.in); int n = scan.nextInt(); // reads number String name = scan.nextLine(); // reads leftover newline ⚠️ The "nextLine()" does not wait for user input because it consumes the leftover newline from the buffer. ✅ Solution: Use an extra "nextLine()" to clear the buffer. int n = scan.nextInt(); scan.nextLine(); // clears the buffer String name = scan.nextLine(); 📌 This is commonly called a dummy nextLine() to flush the buffer. 🔹 Wrapper Classes in Java Java provides Wrapper Classes to convert primitive data types into objects. Primitive Type| Wrapper Class byte| Byte short| Short int| Integer long| Long float| Float char| Character 💡 Wrapper classes allow: - Converting String to primitive values - Storing primitive data in collections - Using useful utility methods Example: String s = "123"; int num = Integer.parseInt(s); // String → int 🔹 Example Use Case Suppose employee data is entered as a string: 1,Swathi,30000 We can split and convert values using wrapper classes: String[] arr = s.split(","); int empId = Integer.parseInt(arr[0]); String empName = arr[1]; int empSal = Integer.parseInt(arr[2]); 🚀 Key Takeaways ✔ Always clear the buffer when mixing "nextInt()" and "nextLine()" ✔ Wrapper classes help convert String ↔ primitive types ✔ They are essential when working with input processing and collections 📚 Concepts like these strengthen the core Java foundation for developers and interview preparation. TAP Academy #Java #CoreJava #JavaProgramming #WrapperClasses #Programming #SoftwareDevelopment

🚀 Understanding Strings in Java | TAP Academy In Java, a String is a collection (sequence) of characters enclosed within double quotes (" ").A single character is enclosed within single quotes (' '). 🔹 Types of Strings in Java Strings are classified into two types: ✅ 1. Mutable String A mutable string can be modified or changed after creation. Example classes: StringBuilder, StringBuffer. ✅ 2. Immutable String An immutable string cannot be changed once created. The String class in Java is immutable — any modification creates a new object. 🔹 Creating an Immutable String in Java Like arrays, Strings are objects in Java. They are created using the new keyword or string literals, and memory is allocated in the Heap Segment of the JRE. Ways to create a String: Using String Literal → "Java" Using new Keyword → new String("Java") 🔹 Ways to Compare Two Strings in Java Java provides multiple methods to compare strings based on requirement: ✔ == → Compares memory reference (address) ✔ equals() → Compares actual content (values) ✔ compareTo() → Compares lexicographically (dictionary order) ✔ equalsIgnoreCase() → Compares content ignoring case differences 🔹 Memory Allocation of Strings (Heap Segment) The Heap is further divided into two pools: 📌 1. String Constant Pool (SCP) Strings created using literals. Duplicate values are not allowed (memory optimization). 📌 2. Non-Constant Pool (Heap Area) Strings created using the new keyword. Duplicate objects are allowed. ✨ Key Takeaway: Java Strings are powerful and memory-efficient because of immutability and the String Constant Pool, which help in security, performance, and reusability. #Java #StringsInJava #CoreJava #ProgrammingBasics #LearningJourney #TAPAcademy #JavaDevelopment

☕ JSON.simple in Java – Escaping Special Characters When working with JSON strings in Java, certain characters are considered reserved characters and cannot be used directly. These characters must be escaped properly to ensure the JSON format remains valid. java explanations (28) As shown on Page 1, JSON uses escape sequences to represent these special characters inside strings. 🔹 Reserved Characters in JSON The document lists the following characters and their escape sequences: Backspace → \b Form Feed → \f New Line → \n Carriage Return → \r Tab → \t Double Quote → \" Backslash → \\ These escape sequences allow JSON strings to safely include special characters. 🔹 Escaping Special Characters Using JSON.simple The library provides the JSONObject.escape() method to automatically escape reserved characters in a string. Example program shown on Page 2: import org.json.simple.JSONObject; public class JsonDemo { public static void main(String[] args) { JSONObject jsonObject = new JSONObject(); String text = "Text with special character /\"'\b\f\t\r\n."; System.out.println(text); System.out.println("After escaping."); text = jsonObject.escape(text); System.out.println(text); } } This program demonstrates how special characters are converted into their escaped versions. 🔹 Program Output As shown on Page 5, the output displays the original string and the escaped string. Original text: Text with special character /"' . After escaping: Text with special character \/\"'\b\f\t\r\n. This ensures the string becomes valid JSON-compatible text. 💡 Escaping special characters is essential when generating JSON data dynamically in Java applications, APIs, or microservices to prevent parsing errors and maintain data integrity. #Java #JSON #JSONSimple #JavaProgramming #BackendDevelopment #API #SoftwareDevelopment #AshokIT

Core Java (Deep Concepts): 1️⃣ What happens internally in HashMap when two keys generate the same hash? Collision occurs. HashMap stores entries in buckets indexed by hash(key). Before Java 8: linked list. Java 8+: red-black tree if list grows beyond 8. equals() is checked for key match. 2️⃣ How does ConcurrentHashMap achieve thread safety? Fine-grained locking or CAS for writes. Reads mostly lock-free. Allows concurrent read/write without locking the entire map. 3️⃣ Difference between Synchronized Collections and Concurrent Collections: Synchronized: coarse-grained, single-thread access, e.g., Collections.synchronizedList. Concurrent: fine-grained, multiple threads can access, e.g., ConcurrentHashMap. 4️⃣ Volatile vs Synchronization: Volatile: ensures visibility only, no mutual exclusion. Synchronization: ensures visibility + mutual exclusion. 5️⃣ Explain Java Memory Model (JMM): Defines thread interactions via memory. Key concepts: main memory vs CPU cache, happens-before relationship, visibility with volatile, atomicity with synchronized. 6️⃣ Difference between Future and CompletableFuture: Future: waits for the result, limited. CompletableFuture: async, chaining, handles exceptions, supports multiple futures. 7️⃣ Parallel Streams: Executes operations in parallel via ForkJoinPool. Avoid when shared mutable state exists, small datasets, or ordering matters. 8️⃣ ClassLoader in Java: Loads class bytecode into JVM. Types: Bootstrap, Extension, System/Application, Custom. 9️⃣ Sealed Classes Allows developers to restrict which classes can extend or implement a class or interface, improving domain modeling and security. 🔟 What is a record in Java? A record is a special type of class used to model immutable data objects with very little boilerplate code. It automatically generates: constructor getters equals() hashCode() toString()

Day 4 of My Java Learning Journey Today I learned about StringBuilder and StringBuffer in Java. In Java, String objects are immutable. That means once a String is created, its value cannot be changed. If we modify a String, a new object is created in memory. This can lead to unnecessary memory usage when we perform multiple modifications. To solve this problem, Java provides StringBuilder and StringBuffer. StringBuilder: StringBuilder is a mutable class. This means we can modify the same object without creating a new one in memory. It is mainly used when we need to perform multiple string operations like append, insert, delete, or reverse. It is not thread-safe, which means it is faster but should be used in single-threaded environments. Example: StringBuilder sb = new StringBuilder("Hello"); sb.append(" World"); sb.insert(5, ","); sb.reverse(); System.out.println(sb); Common methods: append() insert() delete() reverse() replace() capacity() length() StringBuffer: StringBuffer is also mutable, just like StringBuilder. The main difference is that StringBuffer is thread-safe. Its methods are synchronized, which means it can be safely used in multi-threaded environments. Because of synchronization, it is slightly slower than StringBuilder. Example: StringBuffer sbf = new StringBuffer("Java"); sbf.append(" Programming"); sbf.delete(4, 5); System.out.println(sbf); Difference between String, StringBuilder, and StringBuffer: String: >Immutable >Stored in String pool >Less efficient for multiple modifications StringBuilder: *Mutable *Not thread-safe *Faster Best for single-threaded applications StringBuffer: >Mutable >Thread-safe >Slower than StringBuilder Suitable for multi-threaded applications Understanding when to use each one is important for writing efficient and optimized Java programs. Learning step by step and building strong fundamentals. #Java #Programming #LearningInPublic #100DaysOfCode #JavaDeveloper