Java Input - Using Java Scanner

Introduction

Note: If you're looking for Java Scanner help, click here. The page contains some common
questions about them and a question form where you can ask your own questions about
Scanners in Java. Otherwise, for a Scanner example scroll down near the bottom of the
page. Otherwise, simply follow along with the tutorial. The screen shots throughout are of
the Eclipse IDE. If you don't have Eclipse, I highly recommend downloading it!

Want to get more tips and more personalized help on Java Scanner and other Java
topics? Need help with common problems found on quizzes, tests, or other exams? Click
here to sign up for the Fresh Cup Of Java Newsletter, a monthly e-zine full of sample
programs, general tips, and other Java related materials, free of charge!

A Java Scanner is the fastest, easiest way to get input from a user in Java. By this point you
should be able display some sort of output onto the screen. You should also be able to store
data inside of variables. Both of these concepts are great, but what's the point of a program
that has no interaction with a user?

For example, what good is a computer game if you can't control any of it? What we need is
input, and Java has plenty of ways of accepting input. However, we'll be using a Java
Scanner for this tutorial. We're also going to deal with the simplest kind, text input. This
means that we'll be inputting from the keyboard. Note: Looking for Java Scanner help?
Check out these frequently asked Scanner questions!

Getting Input

So, first thing's first, we're going to create a new class (a new Java file). If you already have
a Java project in Eclipse, then all you have to do is right click on the src folder and hit new
class. If you do not have a Java project, you will need to create one. If you don't know what
I'm talking about, you really need to read this tutorial. It will teach you everything you need
to know to get started with writing a program.

Call your new class Inputs. Remember, the class must start with a capital letter. Next, make
sure to checkmark the box that adds public static void main(String[] args). If you do not,
that's ok, but you'll have to add it in manually. When you've entered the name for your new
class, hit finish and you should see this:
There may also be some comments in there that are green and blue (mine did not have
those), and you can delete those if you want or leave them alone.

Now we're going to be doing all of our work inside of main. To make sure you're up and
running, add a print line inside of the main as shown below (remember, this means in
between the opening and closing curly brackets that belong to the main):

You should know how to do this basic output by now. Make sure that your program runs.
You should have seen Inputs on the bottom panel of the screen.
Okay, so now onto inputting. First of all you will need to use a Java Scanner that will get
this input for you. It acts like a variable but it's not one of the basic types that were talked
about in the previous tutorial. Add this line into the main: 

It is EXTREMELY important that you get the capitalization correct, or this will not work.

You will also notice that Eclipse has underlined Scanner in red, as shown in the next
screenshot. That means that Eclipse sees this as an error. That is okay, because the code is
actually missing something important. 

To fix this, right click on the main screen, go down to where it says Source, then
select Organize Imports. This will import everything that your program is missing. If a box
pops up asking you to choose a type to import, choose java.util.Scanner. This is the correct
import for the Java Scanner, as opposed to some other Scanner that might exist. For me it
was the first option. 
You'll notice that the following line was inserted after you organized your imports: 

The Java Scanner class is like any class you create, except it was created for you. Since
Java already comes with it, it had to be imported.

If you don't want to use the shortcut for importing classes, you can always just type in the
import statement manually at the top of the page before the public class line. More on this
for a future article though.

What we need to know for this tutorial is that we have a variable called scan, and it is a
Scanner. Just like int num = 3; means that num is an int, Scanner scan = new
Scanner(System.in); means that scan is a Scanner. It's pretty simple. Don't worry too much
about what it equals, it just means that it will be getting our input. Notice how it looks
awfully similar to System.out but with an "in" instead.

Just because we have this variable "scan" that will take input does not mean that's all we
need to be able to get some input. We have to make it accept some input. To do this, put
this line of code right under the line where you create the variable scan: 
This will receive the input of the next line of text someone types into the keyboard. It's
pretty simple. Now, how can we use the Java Scanner to receive the line of text from a
user? Well, we'll need to use a variable. If you're not up to speed on these, you'll need to go
take a look at the previous tutorial.

Okay, so now we're going to create a String variable, and we're going to make it be equal to
the input we get. Change the line you just wrote to: 

Keep in mind that the names of my variables are my preference. You could easily just do: 

It's up to you to choose what to name your variables, but in general you should try to make
them as descriptive as possible while keeping them short.

Okay, so now the input someone types in will be stored in your String variable from the
Java Scanner. You can use that variable to now output back the line of text. The
program will just echo whatever is typed in. You should be able to output the string on your
own, because you should have learned how to already. Go ahead and write the code to do
this.

If you did it correctly, you wrote this under the previous line of code: 

That will print the input you received using scan.nextLine();. Go ahead and try running the
program. When it runs, you'll have to type in the input yourself. To do this, go to the
bottom panel where you normally receive your output, and type on the first blank line you
see (if stuff is printed there, you need to go down to the first blank line and begin typing).
When you hit enter, Java should print out exactly what you typed. Neat stuff.

Note: nextLine() will read lines one at a time, including white spaces! If you want to skip
all white space, use next() instead. Next() will read up to the first white space and then
stop. If you do next() again, it will skip over the white space and continue reading the next
set of characters and stop at the next white space, etc. 
scan.nextLine(); will input all the text that was typed up to the point where the user hits
the enter key. It's a quick and easy way to get input and to store it into a String. 

Other Inputs

There are other ways of getting input. We can use scan.nextInt(); to get an integer
from the user and store it in an int variable. Like this: 

Now num has the integer that the user typed. If the user types in something other than an
integer, the program will crash, so you must be careful. There are ways of dealing with
these kinds of errors but as with a lot of details, it's beyond the scope of this tutorial. To
print this num variable you do as you normally would for any int variable. 

Using Both Input And Output

Now that we can do both input and output, let's make a little addition program that makes
full use of the Java Scanner class. The program will ask the user to type in a number,
ask the user to type in a second number, and then display the addition of the two numbers.
You can create a new Java class or you can just delete everything inside of the main
method you're working with now(everything in between main's two curly brackets). If
you're making a new file, name the class whatever you want, as long as the first letter is
capitalized.

To begin, we must ask the user to type in the first number to add. This means you will
output a question for the user onto the screen. You know how to do this, so do it.

Next, we will have the user input the number. Remember how to do this? First, we need to
create the Scanner variable: 

Remember to right click on the main page, select source, and then select organize imports.
Next you need to create an int variable to store the first input. 

Now repeat the process to ask for the second number. Remember to create a new int
variable and to call it differently than the other integer variable you created.

Last, do the addition, and output the result. Do you remember how?

I'll skip some lines before spoiling the answer.

If you do not remember how to do all of this, I suggest rereading the previous tutorials as it
is VITAL to get these basic concepts. Notice how I did not create two Scanner variables;
you only need one to do all inputs.

Also notice the last line of code above. Remember our trick of adding strings together? Well,
that's an example of adding a string and a number together. The variable has no quotes
because it is a variable. But wait? Isn't num3 an int? Yes, and remember we do not need
quotes to print out ints, so this would work anyway. Easy and useful isn't it?

The Java Scanner can do nextDouble() instead of just nextInt(); if you want decimal
numbers. It also has a lot of other options that I won't discuss here, but keep that in mind.

Oh, one last thing, don't try to scan text with nextLine(); AFTER using nextInt()
with the same scanner! It doesn't work well with Java Scanner, and many Java
developers opt to just use another Scanner for integers. You can call these scanners scan1
and scan2 if you want.

So there you have it, that's how you get input using a Java Scanner. I strongly suggest
playing around with what you learned and try to make your own little program that accepts
user input. In the next tutorial we'll learn how to make decisions with the user's input. If
you have any questions feel free to contact me using the form below. 

Read more: http://www.java-made-easy.com/java-scanner.html#ixzz1XtTFXWwd
Scanning and Formatting
Programming I/O often involves translating to and from the neatly formatted data
humans like to work with. To assist you with these chores, the Java platform provides
two APIs. The scanner API breaks input into individual tokens associated with bits of
data. The formatting API assembles data into nicely formatted, human-readable form.

Scanning
Objects of type Scanner are useful for breaking down formatted input into tokens and
translating individual tokens according to their data type.

Breaking Input into Tokens

By default, a scanner uses white space to separate tokens. (White space characters
include blanks, tabs, and line terminators. For the full list, refer to the documentation
for Character.isWhitespace.) To see how scanning works, let's look at ScanXan, a
program that reads the individual words in xanadu.txtand prints them out, one per
line.
import java.io.*;
import java.util.Scanner;

public class ScanXan {

public static void main(String[] args) throws IOException {
Scanner s = null;
try {
s = new Scanner(new BufferedReader(new FileReader("xanadu.txt")));

while (s.hasNext()) {
System.out.println(s.next());
}
} finally {
if (s != null) {
s.close();
}
}
}
}
Notice that ScanXan invokes Scanner's close method when it is done with the scanner
object. Even though a scanner is not a stream, you need to close it to indicate that
you're done with its underlying stream.

The output of ScanXan looks like this:

In
Xanadu
did
Kubla
Khan
A
stately
pleasure-dome
...
To use a different token separator, invoke useDelimiter(), specifying a regular
expression. For example, suppose you wanted the token separator to be a comma,
optionally followed by white space. You would invoke,
s.useDelimiter(",\\s*");

Translating Individual Tokens

The ScanXan example treats all input tokens as simple String values. Scanner also

supports tokens for all of the Java language's primitive types (except for char), as well
as BigInteger and BigDecimal. Also, numeric values can use thousands separators.
Thus, in a US locale, Scanner correctly reads the string "32,767" as representing an
integer value.

We have to mention the locale, because thousands separators and decimal symbols are
locale specific. So, the following example would not work correctly in all locales if
we didn't specify that the scanner should use the US locale. That's not something you
usually have to worry about, because your input data usually comes from sources that
use the same locale as you do. But this example is part of the Java Tutorial and gets
distributed all over the world.

The ScanSum example reads a list of double values and adds them up. Here's the
source:

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Scanner;
import java.util.Locale;

public class ScanSum {

public static void main(String[] args) throws IOException {
Scanner s = null;
double sum = 0;
try {
s = new Scanner(
new BufferedReader(new FileReader("usnumbers.txt")));
s.useLocale(Locale.US);

while (s.hasNext()) {
 if (s.hasNextDouble()) {
sum += s.nextDouble();
} else {
s.next();
}
}
} finally {
s.close();
}

System.out.println(sum);
}
}

And here's the sample input file, usnumbers.txt

8.5
32,767
3.14159
1,000,000.1
The output string is "1032778.74159". The period will be a different character in some
locales, because System.out is a PrintStream object, and that class doesn't provide a
way to override the default locale. We could override the locale for the whole
program — or we could just use formatting, as described in the next
topic, Formatting.