As computer users we are familiar with the response computer programs have from user input and output. This lesson helps show the flip side of how programmers can code a Java program that considers, interprets, and responds to input and output.

Input and Output: Lesson

Now that we're familiar with how to set up our Scanner instances, let's dive into some of its functionalities and how to actually read input, whether that be from a file or from the console.

The first thing to know about the Scanner class is that it breaks up its input using a defined delimiter, and by default that delimiter is set to whitespace. This means every time there is a space or a new line in our input, the Scanner will recognize it as a new piece of the input, in fact, it can do its best to search the input for the specific type of information you are looking for, whether that be an integer, a word, or a character.

The next most important piece of the Scanner class is blocking. That means if the Scanner is waiting on user input from the terminal, it will block continued execution of the program until it gets its input.

The list below outlines some (but not all) of the different methods associated with the Scanner class that allow us to read the next piece of information we are looking for.

| Variable| Code                                     |
|---------|------------------------------------------|
| String  | `String myString = input.next();`        |
| Int     | `int num = input.nextInt();`             |
| Double  | `double numDouble = input.nextDouble();` |
| Byte    | `byte numByte = input.nextByte();`       |
| Boolean | `boolean isTrue = input.nextBoolean();`  |
| Long    | `long numLong = input.nextLong();`       |
| Short   | `short numShort = input.nextShort();`    |

The `Scanner` class has several additional methods that help support data validation and control flow. We can use these to make sure we don't try to process data that doesn't exist and thereby run into errors in our program, also known as exceptions.
                                                                                  
| Code                       | Function                          |
|----------------------------|-----------------------------------|
| `input.hasNext()`          | This function returns a boolean that indicates if there is another token left to process|
| `input.hasNextLine()`      | This function returns a boolean that indicates if there is another line in the input of the defined scanner.                                                                                   |
| `input.hasNextInt()`       | This function returns a boolean that validates if there is another int in the input of the defined scanner.                                                                                    |
| `input.useDelimiter(",")`: | This function helps us specify what delimiters we want to use. A _delimiter_ is used to separate data units. This `,` delimiter can be especially useful when a program is required to read csv (comma separated values) files. |

Let's go ahead and ask the user to enter a name and then wait for their input. This is your first truly interactive program! Get Excited! 😜 

Scanner Functionality

You've made it to the end! Let's review what we have learned so far:

- Printing output in a Java program can be done using the following three commands: `System.out.print()`, `System.out.println()`, and `System.out.printf()`
- The `Scanner` class is built into Java and is useful for reading input from different sources including user input, and text files.
- `FileWriter` is used to output data from a program into a file on your computer, and `FileReader` is used to read from a file. They both are specifically tailored to reading and writing character/text data to files.
- `IOExceptions` are exceptions related to input or output that a program may encounter. They can be handled by a programmer using try-catch blocks.
- Java programs must initially be compiled into Java byte code before they can be run using a terminal or command prompt. When running a Java program, a user can pass in multiple arguments through the command line.

image of the terminal open on a desktop computer

Conclusion

By now, you should be very familiar with how to print information to the console using `System.out.print()`, `System.out.println()`, and `System.out.printf()`, but have you ever asked yourself how or why these statements actually work? Let's take a look!

- [`System`](https://docs.oracle.com/javase/9/docs/api/java/lang/System.html) is a class in the `lang` package that is part of every Java installation. It contains several properties and methods to interface with various high-level aspects of the computer environment.
- `out` is an instance of a `PrintStream`, included as part of the `System` class, that is already open and provides output to the user's default console or display.

The `PrintStream` instance of `out` is a robust class. Let's take a look at some of the functions that `out` provides through the examples provided below.

`System.out.print()` prints to the same line when a program is running. The example below shows us how two `System.out.print()` statements called in the `main` method, print on the same line.

```java
System.out.print("Hello ");
System.out.print("World!");
```
This code would show the following output in your program:
```
Hello World!
```

You may also choose to _concatenate_ the string you wish to print with other strings or variables. To concatenate simply means to join multiple strings together, and in Java, we use the `+` symbol to achieve this:

```java
String world = "World";
int day = 1;
System.out.print("Hello " + world + "! Today is Day: " + day + " of your Intermediate Java course!");
```

This code would show the following output in your program:
```
Hello World! Today is Day: 1 of your Intermediate Java course!
```

`System.out.println()` prints output to a new line:
```java
System.out.println("Hello");
System.out.println("World!");
```
This code would show the following output in your program:
```
Hello
World!
```

Concatenation using `System.out.println()` works similar to `System.out.print()`, using the '+' symbol to combine strings.

`System.out.printf()` allows us to output strings that are formatted in the code using [_format specifiers_](https://docs.oracle.com/javase/9/docs/api/java/util/Formatter.html#syntax). Format specifiers begin with the '%' sign, followed by the type of variable we want to print. Some examples include `%s` for a string,` %c` for a character, and `%d` for an integer.

Let's look at a modified version of the Java program that uses `System.out.printf()`. Notice that variables in our print statement are stated in the order that the format specifiers appear.

```java
String world = "World";
int day = 1;
System.out.printf("Hello %s! Today is Day: %d of your Intermediate Java course!", world, day); 
```

This code would show the following output in your program:
```
Hello World! Today is Day: 1 of your Intermediate Java course!
```

Java also allows special characters to be included in our print statements to help with formatting. One such character is the new line indicator, `\n`. We can insert this anywhere in our strings to break the string and start processing on the next line.

```java
System.out.print("Name: Will\nAge:35\nBirthplace: Cincinnati");

// Prints:
Name: Will
Age: 35
Birthplace: Cincinnati
```


Review: Printing with System.out

As computer users we are familiar with the response computer programs have from user input and output. This lesson helps show the flip side of how programmers can code a Java program that considers, interprets, and responds to input and output. As this is your first adventure into the realms of more advanced Java, we want to encourage you to explore the Java documentation, the official technical data that goes along with each version of Java that is released.

Java is a powerful programming language that provides us with many ways to read input and write output to consoles, files, etc. In this lesson, we will learn about some of the built-in classes that are useful for completing these tasks, specifically, reading and writing text to a file. Some of these classes include:

| Class              | Definition                                                                                       |
|--------------------|--------------------------------------------------------------------------------------------------|
| [`System.out`](https://docs.oracle.com/javase/9/docs/api/java/lang/System.html#out)       | A class that holds functions to display out in a terminal or command prompt application.         |
| [`Scanner`](link)          | A class used to read input passed into a Java program.                                           |
| [`FileWriter`](https://docs.oracle.com/javase/9/docs/api/java/io/FileWriter.html) | A class that holds functions to convert byte data into readable text files.                      |
| [`FileReader`](https://docs.oracle.com/javase/9/docs/api/java/io/FileReader.html)  | A class that has functions that convert input from files to byte data for a Java program to use. |

We will also learn how to handle potential exceptions that occur due to input and output in a Java program and introduce `FileInputStream` and `FileOutputStream` two classes used for reading and writing binary information from files that will be very useful in our continued exploration of Java serialization. By the end of this lesson, we will have successfully run a Java program through the terminal that is capable of reading and writing to the file system!

Introduction

[`FileReader`](https://docs.oracle.com/javase/9/docs/api/java/io/FileReader.html) and [`FileWriter`](https://docs.oracle.com/javase/9/docs/api/java/io/FileWriter.html) are two of Java’s built-in input stream classes and can be extremely useful when your program is working with external files when those files contain text information. Both of these classes are specifically made to write character information to and from files.

As with `Scanner`, we will need to import these classes in order to use them in our program. They both reside in the `java.io` package. Unlike with Scanner however, these classes throw a specific type of exception, an `IOException`, if something goes wrong during the read/write process. This `IOException` also needs to be imported from the same package. We'll dive into how exceptions work later in the lesson, for now we'll add a line to our main method declaration that simply throws the `IOException` out of the program.

```java
public static void main (String[] args) throws IOException {}
```

Now, let's take a look at how to implement a `FileReader` instance into our program to read text from a file.

##### Step 1: Declare and initialize your FileReader.

As with nearly all Java objects, we follow the pattern `ObjectClass objectName = new ObjectClass();`
```java
FileReader reader = new FileReader(filePath);
```
You will notice here in the constructor that we are passing in a `filePath`, this is a String that represents the path of the file to be read.

- An example of how an absolute path may look is `FileReader input = new FileReader("C:/SampleFolder/input.txt")`
- An example of how a relative path may look is `FileReader input = new FileReader("../documents/SampleFolder/input.txt")`

Alternatively, you may choose to create an object of the variable type `File` to pass into the `FileReader`. This is useful if you plan to have the user pass in a path to the input file. The code block below shows an example of how you may do this.

```java
//Option 1: Pass file path/name directly to FileReader
FileReader input1 = new FileReader("input.txt");

// Option 2: Use File object to pass file info to FileReader
// Save file path that has been passed in by the user into a string variable.
String fileName = args[0];
// Pass path to File object
File inputFile = new File(fileName);
// Pass File object to FileReader
FileReader input2 = new FileReader(inputFile);
```
##### Step 2: Read your file.
Also much like `Scanner`, `FileReader` has methods to validate content and read contents, these are `.ready()` and `.read()`. The `.ready()` method makes sure that there is content to read and the `.read()` method reads the file one character at a time. The following code shows how to print each character in the file, which will effectively print the contents of the file as written.

```java
while (reader.ready()) {
  System.out.print((char) reader.read());
}
```

##### Step 3: Wrapping Up Loose Ends

It is critically important to close resources such as files and input streams. These can tie up memory on the processor and in some file systems only one asset can access a file at a time, essentially blocking all access to the file from other sources. These resources can either be manually closed like we will do here, or automatically closed with a `try-with-resources` block like we will implement in future exercises.

Closing `FileReader` also has the added benefit of `flushing` the stream as well, making sure that any information that is still in the `FileReader`'s buffer is written to the console.

```java
input.close();
```

FileReader

_Errors_ are unwanted issues that occur in a program that cannot be handled by a program. They may even result in a program crashing. _Exceptions_ are issues that may occur when a program is running that can be foreseen, or caught by the program. For example, if a user passes an incorrect file path in the arguments of a Java program.

There are two types of exceptions: _checked_ and _unchecked_. Checked exceptions are exceptions that are thrown when a program is compiling and unchecked exceptions typically occur during runtime. A developer can check if a block of code is going to throw an exception by using a `try-catch` block, essentially trying some code out to see if an exception occurs or not, and then catching the exception and running a separate block of code in those situations. This allows us to prevent the Exception (unless we want it to) from being thrown out of our `main` method and crashing the program.

`IOExceptions` are exceptions that are related to input and/or output in a program and are classified as checked exceptions.

Some examples of when `IOExceptions` occur include:

- Failed attempts at trying to access a file.
- The end of a file has been reached.
- The file a program is attempting to access cannot be found.
- An input/output operation has been interrupted.

We can code our program to handle `IOExceptions` in areas of our code where we are dealing with input and output. To start off we must first import the `IOExceptions` class into our program using `import java.io.IOException.`

Have a look at the block of code below to see how we have modified one of the examples from the previous exercises to use catch `IOExceptions`. When we catch exceptions in this manner, we no longer have to declare that our method `throws` the exception, since we've handled it at this level.
There are many ways we may choose to handle an exception. We may choose to print an error using `System.out.println()` or run a new instance of the program.

```java
String statement = "Hello World!";

try {
  FileWriter output = new FileWriter("output.txt");
  output.write(statementBytes);
  output.close();
} catch (IOException e) {
  // Handle exception
  System.out.println("There has been an IO exception");
  System.out.println(e); // Prints the actual exception
}
```


IOExceptions

Just like `System`, the `Scanner` class is predefined and built into Java for your use. It's used to read user input in a Java program. When we declare a scanner we need to tell it what type of input we are going to be scanning, this gets passed into the constructor when we initialize it.

For this exercise, we will build a program that walks us through writing code using the `Scanner` class along with the input from the console, which we get from `System.in`. The `Scanner` class comes with Java in the package `java.util`, therefore before we can use the `Scanner` class in our own code we must import it from that package, which you can do using the following: 

```java
import java.util.Scanner;
```

>**Note:** Everything that is contained in the [`java.lang`](https://docs.oracle.com/javase/9/docs/api/java/lang/package-summary.html) package is automatically imported into every Java program. Every Java SDK installation comes with everything in the `java.base` module, a collection of resources that make Java what it is. The other packages contained in [`java.base`](https://docs.oracle.com/javase/9/docs/api/java.base-summary.html) such as [`java.util`](https://docs.oracle.com/javase/9/docs/api/java/util/package-summary.html) and [`java.io`](https://docs.oracle.com/javase/9/docs/api/java/io/package-summary.html) provide helper functionality that isn't necessary to every program, but is used in special circumstances, such as when we need a `Scanner`. We access these extra classes by importing them in our program. This tells the compiler to go to those packages and make sure the resource is available for use when we build our programs. So why don't we include everything in all Java programs? If we did that, our programs would be huge when compiled, including many many files we will never use. Importing specific classes from these packages keeps our software lean and efficient.

Now that we have access to the Scanner class, let's begin by declaring the `Scanner` class as an instance variable called `input`: 

```java
Scanner input = new Scanner(System.in);
```

Notice how we have placed `System.in` within parenthesis in our declaration. This is what will allow our program to read user input from the console. Similar to how the `out` property of System was a `PrintStream`, the `in` property is an instance of an `InputStream`, read more about it [here](https://docs.oracle.com/javase/9/docs/api/java/lang/System.html#in). 

The `Scanner` class can also read input from a file; we will cover that in a later exercise.



The Scanner Class

Now, let’s take a closer look at `FileWriter`. As the name suggests, `FileWriter` is used to output data, specifically text or character data, from a program into a file. Like `FileReader`, `FileWriter` writes to the file using the standard character encoding (this is set by your computer and locale).

`FileWriter` also is contained in the `java.io` package and needs to be imported so we can use it:

```java
import java.io.FileWriter;
```

#### Step 1: Declare your output stream.

The statement `FileWriter output = new FileWriter("output.txt")` will create a file named **output.txt** in the same folder where your Java program is saved. You may also choose to place an absolute or relative file path in the parenthesis. Creating a file this way WILL NOT create directories (folders), only the file. If the directories don't exist, you will end up with a `FileNotFoundException` being thrown, which is a subclass of `IOException`.

Alternatively, you may choose to create an object of the variable type `File` to pass into the `FileWriter`. This is useful if you plan to have the user pass in a path for storing the output or if you want to test if it's a viable file before writing to it:

```java
//Option 1: Pass file path/name directly to FileWriter
FileWriter output1 = new FileWriter("output.txt");

// Option 2: Use File object to pass file info to FileWriter
// Save file path that has been passed in by the user into a string variable.
String fileName = args[0];
// Pass path to File object
File outputFile = new File(fileName);
// Pass File object to FileWriter
FileWriter output2 = new FileWriter(outputFile);
```

#### Step 2: Write to your file.

This is achieved using the `.write()` function. Since `FileWriter` is specifically tailored to writing text and character data to an output file, the `.write()` function accepts a string as an argument.

```java
// Declare FileWriter
FileWriter output = new FileWriter("output.txt");

// Declare statement
String statement = "Hello World!";

// Option 1:
// Write all contents to file
output.write(statement);

// Option 2:
// If you want to write specific portions of a string to a file you may choose to use the following statement
// output.write(String str, int offset, int length);
output.write(statement, 0, 5);
// Writes only "Hello" to the file
```

#### Step 3: Close the file.

It is important we close a file once we are done writing to it. To do this, we use the `.close()` method.

```java
output.close();
```

In Java, most classes that write output use a buffer-style memory, you can think of it as a middleman between the information you want to write and the file. The information gets loaded into the buffer, and as it gets full, it comes out the other side and into the file. One way to make sure the information makes it out of the buffer and into the file is to `.flush()` it out. If we are done with the `FileWriter` we can simply `.close()` it, which will flush the stream, destroy the internal memory holdings of the `FileWriter`, and free up the file for use elsewhere.