Input, Output & Strings

What you'll learn

A program that can't communicate isn't much use. In this module your programs start talking: printing formatted output, reading what the user types, and working with text — the most common data type you'll ever handle.

By the end you'll be able to:

• Print with print, println, and formatted printf
• Read keyboard input with Scanner and avoid its classic pitfall
• Explain why String is immutable and what that means for you
• Use the essential String methods to slice, search, and transform text
• Compare strings correctly with .equals() instead of ==
• Use escape sequences, text blocks, and StringBuilder for efficient text building

Console output

You already know System.out.println(), which prints a line and moves to the next. System.out.print() is the same but without the newline, so the next output continues on the same line. For anything fancier, printf lets you build a formatted string using placeholders:

String name = "Sara";
int score = 95;
double gpa = 3.14159;

System.out.printf("Name:  %s%n", name);
System.out.printf("Score: %d%%%n", score);
System.out.printf("GPA:   %.2f%n", gpa);

Reading input with Scanner

To read what the user types, Java gives you the Scanner class. You import it from java.util, wrap it around System.in (the keyboard), and call methods like nextLine(), nextInt(), and nextDouble():

import java.util.Scanner;

public class Greet {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What's your name? ");
        String name = scanner.nextLine();

        System.out.print("How old are you? ");
        int age = scanner.nextInt();

        System.out.println("Hi " + name + ", next year you'll be " + (age + 1));
        scanner.close();
    }
}

Strings & immutability

A String is a sequence of characters — text. You create one with double quotes: "Hello". The single most important fact about strings in Java is that they are immutable: once created, a string's characters can never be changed. Every "modification" actually produces a brand-new string.

Essential String methods

Because strings are objects, they come loaded with useful methods. Remember: these all return a new value rather than changing the original. Here are the ones you'll reach for daily:

String s = "  Hello, Java  ";

System.out.println(s.trim());                 // "Hello, Java"
System.out.println("Java".length());          // 4
System.out.println("Java".charAt(0));         // J
System.out.println("Hello".substring(1, 4));  // ell
System.out.println("banana".indexOf("na"));   // 2
System.out.println("a,b,c".replace(",", "-")); // a-b-c
System.out.println("hi".toUpperCase());       // HI

Comparing strings correctly

This trips up almost every beginner. To compare the text of two strings, always use .equals() — not ==. The == operator checks whether two variables point to the exact same object in memory, which is a different question entirely.

Java keeps a string pool — a cache of string literals — so identical literals often share one object and == happens to return true. That coincidence makes the bug hide until a string comes from user input or new String(), then suddenly == is false. Don't rely on it:

String a = "hello";
String b = "hello";
String c = new String("hello");

System.out.println(a == b);       // true  (same pooled object)
System.out.println(a == c);       // false (different object)
System.out.println(a.equals(c));  // true  (same characters)
System.out.println(a.equalsIgnoreCase("HELLO")); // true

Escape sequences & text blocks

Some characters can't be typed directly inside a string — a newline, a tab, or a quote that would end the string early. For those you use escape sequences, which start with a backslash:

For multi-line text (like JSON, SQL, or HTML), text blocks (Java 15+) are far cleaner — just wrap the content in triple quotes and write it naturally, no escaping required:

String json = """
        {
          "name": "Sara",
          "level": "beginner"
        }
        """;

System.out.println(json);

StringBuilder

Because strings are immutable, joining many pieces with + — especially inside a loop — quietly creates a new object every time, which wastes memory. When you're building a string in many steps, use StringBuilder: a mutable companion you can efficiently append to, insert into, and reverse.

StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append(" is");
sb.append(" fun");
sb.insert(0, ">> ");

System.out.println(sb);            // >> Java is fun
System.out.println(sb.reverse());  // nuf si avaJ >>

Recap & quick check

Excellent — your programs can now read, write, and manipulate text like a pro. Next up: Module 4 — Decision Making & Control Flow, where your code starts making choices.