{"title":"Input & Output","description":"","content":"Every program needs a way to talk to the outside world. In Java, the standard library provides a small set of tools for printing messages to the screen and reading what the user types in. This lesson covers the everyday I/O used in almost every program: `System.out` for output, `Scanner` for input, and `System.err` for error messages.\n\n---\n\n# Printing Output with `System.out`\n\nThe `System.out` object represents the standard output stream, which is the terminal window in most setups. It exposes three commonly used methods: `println`, `print`, and `printf`.\n\n`println` prints whatever it receives and then moves the cursor to the next line. `print` does the same thing without the newline. The difference in practice:\n\n\n```java\npublic class ProductBanner {\n public static void main(String[] args) {\n System.out.println(\"Welcome to MyShop\");\n System.out.print(\"Today's deal: \");\n System.out.print(\"Wireless Headphones\");\n System.out.println(\" - $79\");\n System.out.println(\"Free shipping included\");\n }\n}\n```\n\n\nThe two `print` calls join their output onto the same line, then the next `println` finishes that line and starts a new one. Use `print` to build up a line in pieces and `println` to finish it.\n\nAny type works with these methods, not just strings. Java converts numbers and booleans to their text form automatically:\n\n\n```java\npublic class CartSummary {\n public static void main(String[] args) {\n int itemCount = 3;\n double cartTotal = 149.97;\n boolean freeShipping = true;\n\n System.out.println(\"Items in cart: \" + itemCount);\n System.out.println(\"Cart total: $\" + cartTotal);\n System.out.println(\"Free shipping: \" + freeShipping);\n }\n}\n```\n\n\nThe `+` between a `String` and another type concatenates them, converting the non-string side to text first.\n\n---\n\n# Formatted Output with `printf`\n\nString concatenation is fine for simple messages, but once columns need to line up or decimal places need control, it falls apart fast. `System.out.printf` solves that. Pass a format string with placeholders, followed by the values to fill them in.\n\n\n```java\npublic class PriceTag {\n public static void main(String[] args) {\n String product = \"Wireless Headphones\";\n int quantity = 2;\n double price = 79.50;\n\n System.out.printf(\"Product: %s%n\", product);\n System.out.printf(\"Quantity: %d%n\", quantity);\n System.out.printf(\"Unit price: $%.2f%n\", price);\n System.out.printf(\"Subtotal: $%.2f%n\", quantity * price);\n }\n}\n```\n\n\nEach `%` in the format string is a placeholder that gets replaced by the next argument. The letter after `%` says what kind of value goes there.\n\n### Format Specifier Reference\n\n\n| Specifier | Meaning | Example | Result |\n| --------- | ------- | ------- | ------ |\n| `%d` | Integer | `printf(\"%d\", 42)` | `42` |\n| `%f` | Floating-point | `printf(\"%f\", 3.14)` | `3.140000` |\n| `%.2f` | Float, 2 decimal places | `printf(\"%.2f\", 3.14159)` | `3.14` |\n| `%s` | String | `printf(\"%s\", \"cart\")` | `cart` |\n| `%b` | Boolean | `printf(\"%b\", true)` | `true` |\n| `%n` | Platform newline | `printf(\"a%nb\")` | `a` newline `b` |\n| `%%` | Literal `%` | `printf(\"%d%%\", 50)` | `50%` |\n\n\n`%n` is worth a closer look. It prints the right line separator for the operating system (`\\n` on Linux and macOS, `\\r\\n` on Windows). Use it for portable output instead of hardcoding `\\n` into format strings.\n\nField width can also align columns. `%10s` reserves 10 characters of space and right-aligns the string in it. `%-10s` does the same but left-aligns. A clean cart receipt:\n\n\n```java\npublic class CartReceipt {\n public static void main(String[] args) {\n System.out.printf(\"%-20s %5s %10s%n\", \"Item\", \"Qty\", \"Price\");\n System.out.printf(\"%-20s %5d %10.2f%n\", \"Wireless Headphones\", 1, 79.00);\n System.out.printf(\"%-20s %5d %10.2f%n\", \"Phone Case\", 2, 12.50);\n System.out.printf(\"%-20s %5d %10.2f%n\", \"USB Cable\", 3, 4.99);\n }\n}\n```\n\n\nThe columns line up because every row uses the same widths. This kind of formatting is painful with plain string concatenation but trivial with `printf`.\n\n---\n\n# Building Strings with `String.format`\n\nSometimes a formatted string is needed but printing should happen later: storing it, returning it from a method, or logging it. `String.format` takes the same format string and arguments as `printf` but returns the result as a `String` instead of writing it to the terminal.\n\n\n```java\npublic class InvoiceLine {\n public static void main(String[] args) {\n String product = \"Smart Watch\";\n double price = 129.99;\n\n String line = String.format(\"%s costs $%.2f\", product, price);\n System.out.println(line);\n System.out.println(\"Saved invoice line: \" + line);\n }\n}\n```\n\n\nThink of `String.format` as `printf` that hands you the result instead of printing it.\n\n---\n\n# Writing to `System.err`\n\nJava has a second standard stream for output: `System.err`. It works exactly like `System.out`, with the same `println`, `print`, and `printf` methods, but it's meant for error messages and diagnostics. The operating system treats it as a separate channel, so normal output and error output can be redirected to different places.\n\n\n```java\npublic class StockCheck {\n public static void main(String[] args) {\n int stock = 0;\n String product = \"Wireless Headphones\";\n\n if (stock > 0) {\n System.out.println(product + \" is in stock\");\n } else {\n System.err.println(\"WARNING: \" + product + \" is out of stock\");\n }\n }\n}\n```\n\n\nIn a terminal, both streams usually print to the same window, so the message looks identical. The difference shows up when output is redirected to a file or piped to another program. `System.out` is for what the program produces; `System.err` is for what went wrong.\n\n---\n\n# Reading Input with `Scanner`\n\nTo read what the user types, the standard tool is `Scanner` from `java.util`. Wrap it around `System.in`, the standard input stream, and call methods to pull values out.\n\n\n```java\nimport java.util.Scanner;\n\npublic class GreetCustomer {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n\n System.out.print(\"Enter your name: \");\n String name = sc.nextLine();\n\n System.out.println(\"Welcome back, \" + name + \"!\");\n\n sc.close();\n }\n}\n```\n\n\n**Sample Input:**\n\n\n```shell\nAlex\n```\n\n\nThree things happen here. First, `import java.util.Scanner` brings the class into scope. Second, `new Scanner(System.in)` creates a scanner that reads from the keyboard. Third, `sc.nextLine()` waits for the user to type a line and press Enter, then returns what they typed (without the newline).\n\n`Scanner` has a method for each common type:\n\n\n| Method | Reads | Example input |\n| ------ | ----- | ------------- |\n| `nextLine()` | Whole line (string) | `Alex Smith` |\n| `next()` | Next word (no spaces) | `Alex` |\n| `nextInt()` | Integer | `42` |\n| `nextDouble()` | Floating-point number | `19.99` |\n| `nextBoolean()` | `true` or `false` | `true` |\n\n\nThe diagram below shows what happens when the program calls `sc.nextLine()`:\n\n\n```mermaid\nflowchart LR\n A[Program calls
sc.nextLine]:::cyan --> B[Scanner waits
for input]:::orange\n B --> C[User types
and hits Enter]:::teal\n C --> D[Scanner reads
the line]:::green\n D --> E[Returns String
to program]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe program blocks (pauses) until the user presses Enter. While it's waiting, nothing else runs. This is why printing a prompt before reading matters: the user has no way to know the program is waiting otherwise.\n\n---\n\n# A Small Interactive Program\n\nA typical use of `Scanner`. The program asks for a product name, a quantity, and a unit price, then prints a formatted invoice.\n\n\n```java\nimport java.util.Scanner;\n\npublic class Invoice {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n\n System.out.print(\"Product name: \");\n String product = sc.nextLine();\n\n System.out.print(\"Quantity: \");\n int quantity = sc.nextInt();\n\n System.out.print(\"Unit price: \");\n double price = sc.nextDouble();\n\n double total = quantity * price;\n\n System.out.println();\n System.out.printf(\"%-20s %5s %10s%n\", \"Item\", \"Qty\", \"Total\");\n System.out.printf(\"%-20s %5d %10.2f%n\", product, quantity, total);\n\n sc.close();\n }\n}\n```\n\n\n**Sample Input:**\n\n\n```shell\nWireless Headphones\n2\n79.50\n```\n\n\nThe flow of an interactive program:\n\n\n```mermaid\nflowchart LR\n A[Print prompt]:::cyan --> B[Read input
via Scanner]:::orange\n B --> C[Parse and
store value]:::teal\n C --> D{More inputs
needed?}:::orange\n D -->|Yes| A\n D -->|No| E[Compute result]:::green\n E --> F[Print output
via printf]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nEach prompt corresponds to one read. The order of prompts has to match the order the program reads in, which sounds obvious but becomes tricky when `nextInt` and `nextLine` are mixed. That's the next topic.\n\n---\n\n# The `nextInt` / `nextLine` Pitfall\n\n`nextInt`, `nextDouble`, and `next` all read a single token. They stop at the next whitespace (space, tab, or newline), and they leave that whitespace in the input buffer. `nextLine`, on the other hand, reads everything up to and including the next newline.\n\nA call to `nextInt` followed by `nextLine` makes the `nextLine` consume the leftover newline from the integer and return an empty string. The program looks like it skipped the prompt.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Scanner;\n\npublic class OrderLookup {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n\n System.out.print(\"Order ID: \");\n int orderId = sc.nextInt();\n\n System.out.print(\"Customer email: \");\n String email = sc.nextLine();\n\n System.out.println(\"Order \" + orderId + \" for \" + email);\n }\n}\n```\n\n\n**Sample Input:**\n\n\n```shell\n1042\nalex@example.com\n```\n\n\nThe program never gives the user a chance to type the email. `nextInt` read `1042` and left the newline in the buffer. `nextLine` then consumed that newline and returned an empty string.\n\n**Fix:** Call `sc.nextLine()` after the integer read to consume the leftover newline before the real `nextLine` call:\n\n\n```java\nimport java.util.Scanner;\n\npublic class OrderLookup {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n\n System.out.print(\"Order ID: \");\n int orderId = sc.nextInt();\n sc.nextLine();\n\n System.out.print(\"Customer email: \");\n String email = sc.nextLine();\n\n System.out.println(\"Order \" + orderId + \" for \" + email);\n\n sc.close();\n }\n}\n```\n\n\n**Sample Input:**\n\n\n```shell\n1042\nalex@example.com\n```\n\n\nThe extra `sc.nextLine()` after `nextInt()` throws away the trailing newline. Now the real `nextLine` waits for fresh input.\n\n---\n\n# Validating Input Before Reading\n\nIf the user types the wrong type, `Scanner` throws `InputMismatchException`. For example, calling `nextInt()` when the user typed `abc` throws at runtime.\n\nCheck ahead of time with the `hasNextXxx` methods. They return `true` if the next token can be read as that type, without consuming it.\n\n\n```java\nimport java.util.Scanner;\n\npublic class StockUpdate {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n\n System.out.print(\"New stock count: \");\n if (sc.hasNextInt()) {\n int stock = sc.nextInt();\n System.out.println(\"Stock updated to \" + stock);\n } else {\n System.err.println(\"Error: stock must be a whole number\");\n }\n\n sc.close();\n }\n}\n```\n\n\n**Sample Input:**\n\n\n```shell\nabc\n```\n\n\n`hasNextInt` returns `false` because `abc` isn't an integer, so the program prints an error message instead of crashing. `hasNextLine`, `hasNextDouble`, and `hasNext` work the same way.\n\n---\n\n# Closing the Scanner\n\nCalling `sc.close()` releases the resources the scanner holds. One point worth noting: closing a `Scanner` that wraps `System.in` also closes `System.in` itself. For a small standalone program that reads input once and exits, this is fine. For a larger program that might want to read from the keyboard again later, closing the scanner shuts that door permanently.\n\nA safe default for short programs: close the scanner at the end of `main`. For longer-running code, keep one `Scanner` for the lifetime of the program and only close it when stdin is no longer needed.\n\n---\n\n# Command-Line Arguments\n\nOne more way to get input into a Java program: command-line arguments. `String[] args` in `main` holds anything the user typed after the class name when running the program. This is useful when the input is known up front and the program doesn't need to prompt for it.\n\n\n```java\npublic class Greeting {\n public static void main(String[] args) {\n if (args.length > 0) {\n System.out.println(\"Hello, \" + args[0] + \"!\");\n } else {\n System.out.println(\"Hello, stranger!\");\n }\n }\n}\n```\n\n\nRunning `java Greeting Alex` prints `Hello, Alex!`. Running `java Greeting` with no arguments prints `Hello, stranger!`. Command-line arguments suit utilities; interactive programs usually use `Scanner`.\n\n---\n\n# A Faster Alternative for Big Inputs\n\n`Scanner` is convenient, but it's not the fastest tool. Each call parses the input and handles type conversion, which adds overhead. For programs that read thousands of lines (competitive programming, log processing, large files), the standard speedup is `BufferedReader` wrapped around `InputStreamReader`.\n\n\n```java\nimport java.io.BufferedReader;\nimport java.io.InputStreamReader;\n\npublic class FastInput {\n public static void main(String[] args) throws Exception {\n BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));\n String line = reader.readLine();\n System.out.println(\"You typed: \" + line);\n }\n}\n```\n\n\n`Scanner` can be 5 to 10 times slower than `BufferedReader` when reading large amounts of input, because it does more parsing work per call. For everyday programs the difference doesn't matter; for tight read loops over big inputs, switch to `BufferedReader`.\n\nFor everything in the next few lessons, `Scanner` is the appropriate choice.","pageType":"java"}

Input & Output

Get Premium