Used to represent a single character. Example:

char grade = 'A';

In Java, the number of bytes a char, String, or any text content (like a chat message) takes depends on character encoding. Here’s a breakdown:

• A char in Java is always 2 bytes (16 bits).
• Java uses UTF-16 internally for char and String.

Let’s say your chat message is stored as a String:

String chat = "DIY Spring JDBC Client ...";

• Each character takes 2 bytes.

• So:

  int bytes = chat.length() * 2;
  

• When sending or saving (e.g., over network or file), String is encoded using a charset (e.g., UTF-8 or UTF-16).

• Use:

  byte[] utf8Bytes = chat.getBytes(StandardCharsets.UTF_8);
  int size = utf8Bytes.length;
  

String chat = "DIY Spring JDBC Client";
System.out.println("UTF-8 Bytes: " + chat.getBytes(StandardCharsets.UTF_8).length);
System.out.println("UTF-16 Bytes: " + chat.getBytes(StandardCharsets.UTF_16).length);

UTF-8 Bytes: 24
UTF-16 Bytes: 50

Note: UTF-16 adds a 2-byte BOM (Byte Order Mark) in many cases, hence 50 instead of 48.

Strings lie at the heart of almost every Java program. You’ll learn how they’re represented under the hood, how to build and manipulate them efficiently, and the rich set of tools Java provides for searching, splitting, and templating text.

• Java 8 and earlier: a char[] array storing UTF-16 code units.
• Java 9+: a compact byte[] plus a coder flag (LATIN1 vs. UTF-16), saving memory for ASCII-heavy text.
• Immutable: once created, the contents never change; concatenation always produces a new object.

• Why: Fast, mutable sequence of characters—ideal for repeated concatenation.

• How:

  StringBuilder sb = new StringBuilder();
  sb.append("Hello");
  sb.append(", ").append("World!");
  String result = sb.toString();
  

• When: In loops or any situation where + would create many temporary String objects.

• API: java.util.regex.Pattern & Matcher.

• Pattern.compile creates a regex; matcher() applies it to input.

  Pattern p = Pattern.compile("\\d{3}-\\d{2}-\\d{4}");
  Matcher m = p.matcher("123-45-6789");
  if (m.matches()) { /* valid SSN format */ }
  

• Use cases: Validation (emails, phone numbers), search/replace (Matcher.replaceAll), complex parsing.

• Why: Inject variables into a template without manual concatenation.

• Syntax: Format specifiers like %s, %d, %f.

  String template = "User %s has %d new messages.";
  String msg = String.format(template, "Alice", 5);
  // "User Alice has 5 new messages."
  

• Advanced: Use java.text.MessageFormat for locale-aware templating and named parameters.

With this toolkit—knowing how strings live in memory, when to use mutable builders, how to leverage regex, and how to split or template text—you’ll handle almost any textual requirement efficiently and cleanly.

In Java, special character sequences like \n, \t, etc., are called escape sequences.

Escape sequences are used in Java (and many programming languages) to represent special characters that cannot be typed directly or would be interpreted differently in a string or character literal.

Each escape sequence starts with a backslash (\), which tells the compiler to interpret the following character(s) in a special way.

public class EscapeDemo {
    public static void main(String[] args) {
        System.out.println("Line1\nLine2");      // Prints in two lines
        System.out.println("Name:\tSathish");    // Adds tab space
        System.out.println("She said: \"Hello\"");// Prints double quotes
        System.out.println("Path: C:\\Users\\");  // Prints backslash
    }
}