Input with Scanner, String basics, ++ and +=

This page combines two jobs: getting data from the user (Scanner) and working with text (String). There are also ++ and +=, the place where tracing questions set the most traps. In writing questions, every question that starts with “take a number from the user” wants the three Scanner lines; you should be able to write them by reflex.

Golden rules:

1. The three Scanner lines: import java.util.Scanner;, new Scanner(System.in), input.nextInt().
2. next() is one word, nextLine() is the whole line. After nextInt, nextLine comes back empty.
3. String indexes start at 0, and the last index is length() - 1.
4. Strings are compared with equals, never with ==.
5. x++ uses first then increments, ++x increments first then uses.

Reading from the keyboard with Scanner

Scanner is a class in Java’s ready-made library. Before using it you write an import at the very top of the file, then you create a Scanner object.

import java.util.Scanner;                    // 1) import, above the class

public class Profile {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);  // 2) a Scanner connected to the keyboard
        System.out.print("Enter age: ");
        int age = input.nextInt();               // 3) read according to the type
        System.out.print("Enter GPA: ");
        double gpa = input.nextDouble();
        System.out.print("Enter name: ");
        String name = input.next();
        System.out.println(name + " is " + age + ", GPA " + gpa);
    }
}

In the console (when the user types 19, 3.4 and Deniz):

Enter age: 19
Enter GPA: 3.4
Enter name: Deniz
Deniz is 19, GPA 3.4

It is customary to use print (not println) for the prompt text: the cursor stays on the same line and the user types the answer next to the question.

How tokens work

Scanner splits the input into pieces (tokens) at spaces. next, nextInt and nextDouble take the next piece. nextLine does not split; it takes the rest of the line as it is.

String first = input.next();
String line = input.nextLine();
System.out.println("[" + first + "]");
System.out.println("[" + line + "]");

When the input is Ali Veli Can:

[Ali]
[ Veli Can]

Notice the leading space: next took “Ali”, and nextLine took everything left, space included.

The nextLine after nextInt trap

System.out.print("Age: ");
int age = input.nextInt();
System.out.print("Full name: ");
String name = input.nextLine();
System.out.println("[" + name + "] " + age);

The user types 20 and presses Enter, and is about to type Deniz Yilmaz. But the program finishes without waiting:

Age: Full name: 
[] 20

nextInt took only 20; the line break produced by the Enter key stayed in the input. nextLine saw that line break and immediately returned an empty String. The fix: put an empty input.nextLine(); in between to swallow the line break.

int age = input.nextInt();
input.nextLine();                      // throw away the leftover line break
String name = input.nextLine();

Age: Full name: 
[Deniz Yilmaz] 20

(Because the input was given from a file during verification, the typed values were not echoed on screen.)

PITFALL · wrong type of input. If the user types abc when nextInt is expecting a number, the program crashes: java.util.InputMismatchException. This is a runtime error and does not show up at compile time.

String basics

A String is a sequence of characters. Every character has an index, and counting starts at 0.

 S   o   f   t   w   a   r   e
 0   1   2   3   4   5   6   7        length() = 8, last index 7

String s = "Software";
System.out.println(s.length());
System.out.println(s.charAt(0) + " " + s.charAt(7));
System.out.println(s.substring(4));        // from 4 to the end
System.out.println(s.substring(0, 4));     // 0,1,2,3 (4 excluded)
System.out.println(s.indexOf('w') + " " + s.indexOf("ware") + " " + s.indexOf('z'));
System.out.println(s.toUpperCase() + " " + s.toLowerCase());
System.out.println("  hi  ".trim() + "|");
System.out.println(s.equals("software") + " " + s.equalsIgnoreCase("software"));
System.out.println(s.charAt(s.length() - 1));

8
S e
ware
Soft
4 4 -1
SOFTWARE software
hi|
false true
e

A String is immutable

No String method changes the existing String. They all return a new String. If you do not assign the result somewhere, it is lost.

String t = "bau";
t.toUpperCase();          // the result was thrown away
System.out.println(t);
t = t.toUpperCase();      // assign the result to t
System.out.println(t);

bau
BAU

Concatenation

If either side of a + is a String, concatenation is done. The evaluation goes left to right, so the order decides everything.

int x = 3, y = 4;
System.out.println("x + y = " + x + y);     // "x + y = 3" + 4
System.out.println("x + y = " + (x + y));   // parentheses first
System.out.println(x + y + " toplam");      // 3 + 4 first
String msg = "Skor";
msg += ": ";
msg += 90;
System.out.println(msg);

x + y = 34
x + y = 7
7 toplam
Skor: 90

Increment and decrement: ++ and —

x++ and ++x both increase x by one. The difference is which value they give inside an expression:

• Postfix x++: gives the old value to the expression, then increments.
• Prefix ++x: increments first, gives the new value to the expression.

int i = 5;
int j = i++;        // j gets the old value
System.out.println(i + " " + j);
int k = ++i;        // increment first, then give
System.out.println(i + " " + k);
int n = 3;
System.out.println(n++ + " " + n);
System.out.println(--n * 2);

6 5
7 7
3 4
6

line               i    j    k    explanation
int i = 5          5
int j = i++        6    5         j took the old 5, i became 6 afterwards
int k = ++i        7    5    7    i became 7 first, k took the new 7

On a line by itself (x++; or ++x;) there is no difference between the two. The difference only shows up inside another operation.

Compound assignment

x += 3 is short for x = x + 3. The same goes for -=, *=, /=, %=.

int p = 10;
p += 5;  System.out.print(p + " ");
p -= 3;  System.out.print(p + " ");
p *= 2;  System.out.print(p + " ");
p /= 5;  System.out.print(p + " ");   // 24 / 5 = 4, int division
p %= 3;  System.out.println(p);
int c = 5;
c += 2.7;              // hidden cast: c = (int) (c + 2.7)
System.out.println(c);
int dd = 4;
dd *= 2 + 3;           // right side first: dd = dd * 5
System.out.println(dd);

15 12 24 4 1
7
20

PITFALL · *= takes the right side as a whole. The expression dd *= 2 + 3 is dd = dd * (2 + 3) (20), not dd = dd * 2 + 3 (11). Assignment operators have the lowest precedence; the right side is always computed first.

Common mistakes

Scanner input = new Scanner(System.in);
int a = input.nextInt();
int b = input.nextInt();
System.out.println(a / b + " " + a % b);

String w = input.next();
int n = input.nextInt();
System.out.println(w + n + 1);

int n = input.nextInt();
String rest = input.nextLine();
System.out.println(n + "|" + rest + "|");

String answer = input.next();
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

String s = "Bahcesehir";
System.out.println(s.length() + " " + s.charAt(3) + " " + s.substring(2, 5));

String s = "computer";
System.out.println(s.indexOf('t') + " " + s.indexOf("put") + " " + s.indexOf('x'));

String s = "java";
s.toUpperCase();
System.out.println(s + s.length());

int a = 5;
int b = a++ + ++a;
System.out.println(a + " " + b);

int x = 7;
x += 3;
x -= 2;
x *= 3;
x %= 5;

int q = 10;
q /= 4;
q += 1.9;
System.out.println(q);

String s = "Hello";
System.out.println(s.charAt(1) + s.charAt(2));
System.out.println("" + s.charAt(1) + s.charAt(2));