تحويل النصوص إلى أعداد

Written Explanation

Text is not a number

In BEG-009 you learned that "42" (a String) and 42 (an int) are different things. Adding 1 shows it:

String text = "42";
System.out.println(text + 1);                    // 421
System.out.println(Integer.parseInt(text) + 1);  // 43

The first line uses + as text joining, so "42" and 1 become "421". The second line first converts the text to the number 42, then adds. The output of the compiled program is:

421
43

The two parse methods

Both are static methods: you call them on the class name, Integer or Double, without creating an object. (Integer and Double are the classes that go with int and double; BEG-009 mentioned that primitives and classes are different. For now, treat the two names as part of the method name.) Both are in java.lang, so no import is needed.

Here is a short tour, compiled and run:

System.out.println(Double.parseDouble("3.5") * 2);       // 7.0
System.out.println(Double.parseDouble("3") * 2);         // 6.0
System.out.println(Integer.parseInt("+7") + Integer.parseInt("-7"));  // 0

Notice that Double.parseDouble("3") is fine: a whole number is a valid decimal. The Javadoc for Integer.parseInt says an optional minus or plus sign is accepted as the first character, so "+7" and "-7" both parse.

What does not parse

Parsing is strict. For Integer.parseInt, the Javadoc says a NumberFormatException is thrown when:

• the text is empty (or null);
• any character is not a decimal digit, apart from one leading sign;
• the value is outside the range of int, from -2,147,483,648 to 2,147,483,647.

That list has some consequences that surprise beginners:

When parsing fails the program stops with an error message. Two real ones, from the compiled test programs:

Exception in thread "main" java.lang.NumberFormatException: For input string: "3.5"
Exception in thread "main" java.lang.NumberFormatException: For input string: " 42"

Read the message: it names the exact text that failed. The second one is the sneaky one, because a space is hard to see. This is why the [ ] trick from Lesson 2 pays off.

Double.parseDouble follows the same idea but is more lenient: its Javadoc says surrounding whitespace is ignored, as if trim() had been applied. So Double.parseDouble(" 2.5 ") works and gives 2.5, while the same spaces break parseInt. It also accepts the special words NaN and Infinity, which we will meet again in Lesson 5. It follows Java's decimal-point notation: "2,5" is not a number to parseDouble, regardless of your locale. (This differs from nextDouble(), which uses the locale; see Lesson 1.)

Cleaning the text with trim()

The String method trim() removes spaces, tabs, and similar whitespace from both ends. It returns a new string and leaves the original unchanged (strings are immutable, as BEG-009 explained). So the safe habit is to trim before parsing an integer:

int n = Integer.parseInt(line.trim());

Reading a whole form as lines

Now the fix promised in Lesson 2. Read every answer with nextLine(), and parse the numbers:

int age = Integer.parseInt(in.nextLine().trim());
String name = in.nextLine();
double height = Double.parseDouble(in.nextLine().trim());

Every read consumes its own line break, so there is no leftover and no trap. The code is longer per number, but it behaves the same for every question. The cost is that a bad number now fails at the parse call instead of the nextInt call; the failure is the same kind, an exception that stops the program.

Checking before you read: hasNextInt()

You have no way yet to catch an exception (that comes in a later module), so you need another way to avoid the crash: look before you leap. Scanner has methods that ask "is the next token of this kind?" without reading it:

The Javadoc says hasNextInt() returns true if the next token can be interpreted as an int, and does not advance past anything. It may wait for the user to type, like any read. To use the answer you need a decision, and you have not met if formally yet: that is the first lesson of the next module, BEG-012. Here is the shape only, so you can read it:

if (in.hasNextInt()) {
    // true: it is safe to call nextInt()
} else {
    // false: the next token is not a whole number
}

Read it as English: "if a whole number is waiting, do the first block, otherwise do the second block." We will use this in the examples below, and Lesson 5 puts it inside a loop.