Strings and basic I/O

Strings are sequences of characters treated as a single data type in programming. In Java (Cambridge AP standard), strings are immutable objects, meaning once created, their values cannot be changed—any modification creates a new string object.

Key String Concepts:

String Declaration: String name = "Cambridge"; creates a string literal. Alternatively, String name = new String("Cambridge"); uses the constructor (less common).

String Concatenation: The + operator joins strings: "Hello" + " " + "World" produces "Hello World". When concatenating strings with other data types, automatic type conversion occurs: "Score: " + 95 yields "Score: 95".

Escape Sequences: Special characters preceded by backslash (\):

• \n = newline
• \t = tab
• \" = double quote
• \\ = backslash

Basic Input/Output (I/O):

Output: System.out.println() prints with newline; System.out.print() prints without newline.

Input: The Scanner class enables user input:

Scanner input = new Scanner(System.in);
String name = input.nextLine(); // reads entire line
int age = input.nextInt(); // reads integer

Scanner input = new Scanner(System.in);
String name = input.nextLine(); // reads entire line
int age = input.nextInt(); // reads integer

Critical String Methods (zero-indexed):

• length() returns character count
• charAt(index) retrieves character at position
• substring(start, end) extracts portion (end exclusive)
• indexOf(str) finds first occurrence position
• equals(str) compares content (NOT == which compares references)

Memory Aid: SLICE for string operations: Substring, Length, IndexOf, CharAt, Equals

Strings as Building Blocks: Think of strings like DNA sequences—each character is a nucleotide, and the order matters immensely. Just as geneticists analyze DNA segments, programmers manipulate string segments for data processing.

Real-World Application 1: User Authentication When you log into an online system, your username is a string. The system uses equals() to compare your input against stored credentials. Using == would fail because it checks if two variables reference the same memory location, not if they contain the same characters. This distinction prevents security vulnerabilities.

Real-World Application 2: Data Validation E-commerce websites validate email addresses using string methods. indexOf("@") checks for the @ symbol's presence, while substring() extracts the domain portion. If indexOf("@") returns -1, the email is invalid.

Real-World Application 3: Text Processing Search engines process millions of strings daily. When you search "Cambridge exam tips", the engine uses toLowerCase() to standardize input, split() to separate words, and indexOf() to find matches in web pages.

The Immutability Advantage: Like frozen photographs, immutable strings ensure data integrity. When multiple parts of a program reference the same string, no component can accidentally corrupt the data. This makes debugging easier and programs more reliable.

Input/Output in Context: Consider an airline booking system. It uses Scanner to capture passenger names (nextLine()), ages (nextInt()), and seat preferences. The system concatenates this data into confirmation messages: "Booking confirmed for " + name + ", seat " + seatNumber. Proper input handling prevents errors like reading leftover newline characters (the infamous nextInt()-then-nextLine() bug).

Example 1: String Manipulation (Cambridge-style, 6 marks)

Question: Write a method that takes a full name (format: "FirstName LastName") and returns initials in uppercase (e.g., "John Smith" → "JS").

public static String getInitials(String fullName) {
    int spaceIndex = fullName.indexOf(" ");        // [1 mark: finding space]
    char firstInitial = fullName.charAt(0);        // [1 mark: first letter]
    char lastInitial = fullName.charAt(spaceIndex + 1); // [1 mark: last letter]
    String initials = "" + firstInitial + lastInitial;  // [1 mark: concatenation]
    return initials.toUpperCase();                 // [2 marks: conversion + return]
}

public static String getInitials(String fullName) {
    int spaceIndex = fullName.indexOf(" ");        // [1 mark: finding space]
    char firstInitial = fullName.charAt(0);        // [1 mark: first letter]
    char lastInitial = fullName.charAt(spaceIndex + 1); // [1 mark: last letter]
    String initials = "" + firstInitial + lastInitial;  // [1 mark: concatenation]
    return initials.toUpperCase();                 // [2 marks: conversion + return]
}

Examiner Note: Award full marks for alternative approaches using substring() or split(). Deduct 1 mark if case conversion is missing.

Example 2: Input Validation (8 marks)

Question: Create a program that reads a password and validates: minimum 8 characters, contains "@" or "#".

Scanner scan = new Scanner(System.in);
System.out.print("Enter password: ");           // [1 mark: prompt]
String password = scan.nextLine();              // [1 mark: input]

boolean validLength = password.length() >= 8;   // [2 marks: length check]
boolean hasSymbol = password.indexOf("@") != -1 || 
                    password.indexOf("#") != -1; // [3 marks: symbol check]

if (validLength && hasSymbol) {                  // [1 mark: combined logic]
    System.out.println("Valid password");
} else {
    System.out.println("Invalid password");
}

Scanner scan = new Scanner(System.in);
System.out.print("Enter password: ");           // [1 mark: prompt]
String password = scan.nextLine();              // [1 mark: input]

boolean validLength = password.length() >= 8;   // [2 marks: length check]
boolean hasSymbol = password.indexOf("@") != -1 || 
                    password.indexOf("#") != -1; // [3 marks: symbol check]

if (validLength && hasSymbol) {                  // [1 mark: combined logic]
    System.out.println("Valid password");
} else {
    System.out.println("Invalid password");
}

Examiner Note: Common error—students forget != -1 when checking indexOf() results.