#system.in

First Java “Hello World” Program

First Java “Hello World” Program

Here is the first Java program “Hello World” program for basic understanding about the Java Syntax and execution of a program.

public class HelloWorldFirstProgram { public static void main(String[] args) { // Prints the string to the console. System.out.println("Hello World!"); } }

Output

Hello World !

See Also :

How to execute a Java…

Recently I was asked a simple question;

This may not be necessary at my level, but I'm asking for input of money and it breaks if the user enters a decimal

So, this is going to be hopefully a quick article about how to use the Scanner with regards to using it with the System.in input stream.

The Scanner class works by reading input from an input stream (System.in); it, by default, always reads input in as a String. This is a safe assumption on the part of the Scanner because there will be no mismatch problems with just reading into a String.

Scanner reads “tokens”, as it calls them, based upon a delimiter, which is defaulted to whitespace characters. This means that if you input a line, such as;

“Well hello there”

Then it will process this as “Well”, “hello” and “there”. As the Scanner reads from the input stream, when the line is input, it will buffer the input and read from it left to right. More on this bit later, under discussion of “nextLine”.

When it is asked to read in a specific type (for example, `scanner.nextInt()`), internally it is doing the following;

If yes, use that

If no, read input from the stream

If it does not, throw an InputMismatchException

This is a simple way of breaking down the logic, but the main important thing to understand is that the Scanner internally checks the input against a distinct pattern in order to determine if the input can be assigned / cast into the requested type.

So, as we are asking for an int, the pattern is going to determine; a) if the input is numerical, and b) the input does not have any decimal values. If the input fails these two checks, then the input does not match the expected value; this is an InputMismatchException which, if unhandled, will cause problems.

Ultimately, the Scanner has a number of preset patterns in order to make our lives easier;

nextBigDecimal

nextBigInteger

nextBoolean

nextByte

nextDouble

nextFloat

nextInt

nextLong

nextShort

next

There is no “nextString” because “next” returns a String.

So, as long as we know what the input that we’re expecting is, we can safely select which type we want from our scanner.

But, wait! One of the key aspects of programming applications is understanding that The User is an Idiot. No offense to any user, but if something can be made to go wrong, they’ll find it and just completely mess things up. We have to defensively program in order to help our users not mess everything up.

Luckily, Scanner has thought of that already and it has methods to help us determine things about the next input. These are the “has” methods.

When you call a one of Scanner’s ‘has’ methods, it brings in the next input and keeps a hold of it, storing it internally. The ‘has’ methods return a boolean; if the input can be assigned to the type requested, then it returns true. Otherwise, it returns false.

For example;

    if (scanner.hasNextDouble()) {         System.out.println(”$” + scanner.nextDouble());     } else {         System.out.println(”This was not a double: “ + scanner.next());     }

This allows us to create distinct conditionals and control the flow of applications, while also defensively programming against user input. We want to avoid throwing exceptions as much as possible at this point; instead we want to be programming around them.

The final important part of the Scanner is nextLine and tokens. As noted before, when the Scanner reads in from the terminal, it will buffer all “tokens” in a list. So, with the input;

Hello darkness my old friend. I’ve come to see you yet again.

The token buffer then becomes;

Hello

darkness

my

old

friend.

I’ve

come

to

see

you

yet

again.

Now, so when we call methods that check the input, it will read from that buffer instead of the terminal. So, you can call “next()” 12 times before it will attempt to read from the terminal.

This can be seen with the following;

    Scanner scanner = new Scanner(System.in);     while (scanner.hasNext()) {         System.out.println(scanner.next());      }

This will take an input, then for each token in that input, it will output the token, essentially splitting up your input into each individual “word” and repeating it on a different line.

To read in a whole line without worrying about whitespace, you can use scanner.nextLine() which will read in up to the New Line Character. 

Hopefully, you have learned something about the Scanner class.

original source : http://tutorials.jenkov.com/java-io/system-in-out-error.html

The 3 streams System.in, System.out, and System.err are also common sources or destinations of data. Most commonly used is probably System.out for writing output to the console from console programs.

These 3 streams are initialized by the Java runtime when a JVM starts up, so you don't have to instantiate any streams yourself (although you can exchange them at runtime).

System.in

System.in is an InputStream which is typically connected to keyboard input of console programs. System.in is not used as often since data is commonly passed to a command line Java application via command line arguments, or configuration files. In applications with GUI the input to the application is given via the GUI. This is a separate input mechanism from Java IO.

System.out

System.out is a PrintStream. System.out normally outputs the data you write to it to the console. This is often used from console-only programs like command line tools. This is also often used to print debug statements of from a program (though it may arguably not be the best way to get debug info out of a program).

System.err

System.err is a PrintStream. System.err works like System.out except it is normally only used to output error texts. Some programs (like Eclipse) will show the output to System.err in red text, to make it more obvious that it is error text.

Simple System.out + System.err Example:

Here is a simple example that uses System.out and System.err:

try {  InputStream input = new FileInputStream("c:\\data\\...");  System.out.println("File opened..."); } catch (IOException e){  System.err.println("File opening failed:");  e.printStackTrace(); }

Exchanging System Streams

Even if the 3 System streams are static members of the java.lang.System class, and are pre-instantiated at JVM startup, you can change what streams to use for each of them. Just set a new InputStream for System.in or a new OutputStream for System.out or System.err, and all further data will be read / written to the new stream.

To set a new System stream, use one of th emethods System.setIn(), System.setOut() or System.setErr(). Here is a simple example:

OutputStream output = new FileOutputStream("c:\\data\\system.out.txt"); PrintStream printOut = new PrintStream(output); System.setOut(printOut);