Input Stream Where Data Is Sent to and Read by a Program

How-do-you-do! The lessons and tasks in Level iii taught you how to display stuff on the console, and, moving in the other direction, how to read data from the keyboard.

You even learned to use the following complex construct to accomplish this:

                      BufferedReader reader = new BufferedReader(new InputStreamReader(Organization.in));                  

But there'due south 1 question nosotros haven't answered yet.

How in the world does this work?

In reality, programs are rarely entirely independent. They communicate with other programs, systems, the Internet, etc. Past "communicate", we mainly mean "exchange information". That is, they receive some external data and as well ship internal program data somewhere. Examples of programs exchanging data grow in everyday life. For case, many websites let you sign in using your Facebook or Twitter account instead of registering. In this situation, two programs (e.1000. Twitter and the website yous're signing in to) exchange the necessary data. The final result is that you are successfully signed in. The give-and-take "stream" is used to describe the process of data exchange. Where did this name come from? In your experience, a "stream" may be more associated with rivers and than with programming. That's no blow :) A stream is, in essence, a moving slice of data. In other words, in programming, it isn't h2o that flows — but rather data in the form of bytes and characters. We tin receive bits of data from a information stream and and so use them. Again, we'll apply the water/menses analogy: yous tin can scoop water from a river to brand soup, put out a fire, or h2o your flowers. Streams let you lot work with any data source: whether the Net, your computer's file system, or something else — it makes no divergence. Streams are a universal tool. They allow a program to receive data from anywhere (input streams) and send it anywhere (output streams). Their task is the same: to take data from one place and send information technology to some other. At that place are 2 types of streams:

1. Input streams are used to receive data
2. Output streams are for sending information.

In Java, these streams are implemented by the InputStream and OutputStream classes. Simply the streams can be categorized some other way. In improver to input and output streams, we also speak of byte streams and graphic symbol streams. The pregnant here should be clear enough: byte stream sends information as a set of bytes, while a character stream sends it as a set of characters. In this lesson, we'll dwell on input streams. I'll put a link with information well-nigh output streams at the cease of the lesson. You can read information technology on your own :) Now take a expect at this code:

                      BufferedReader reader = new BufferedReader(new InputStreamReader(Organisation.in));                  

When going through the lessons, didn't you recollect this line was adequately intimidating? :) That won't be the example once we've explored how it works. Let'south put things right. We'll start at the cease. System.in is an InputStream object, an instance of the class we spoke about early. It is an input stream linked to a system input device (the keyboard). By the way, you're indirectly familiar with this stream. Later on all, you often utilise its "coworker" — Organization.out! Arrangement.out is the organisation output stream. It is used to output data to the console via your favorite method Organization.out.println(), which you use constantly :) System.out is a stream for sending information to the console, while System.in is for getting data from the keyboard. It'due south all simple :) What's more than, we can read information from the keyboard without this huge construct. We tin can merely write: System.in.read();

                      public grade Master {     public static void chief(String[] args) throws IOException {         while (true) {            int 10 = Organization.in.read();            Organization.out.println(ten);        }    } }                  

The InputStream class (think, Organisation.in is an InputStream object) has a read() method that lets you read data. In that location'southward one problem: it reads bytes, not characters. It is boring to use English letters only so let's effort reading the Chinese grapheme "魚" from the keyboard (merely re-create this alphabetic character from hither and paste information technology to console using ctrl + v on PC or Command + five on Mac). This grapheme means 'a fish' past the way. Panel output: 魚 233 173 154 10 This symbol and many other Chinese occupy 3 bytes in the computer's memory (unlike Latin letters, which occupy just 1 byte). In this instance, four bytes are read from the stream: the first three correspond the character "魚", and other byte represents a new line (Enter). Accordingly, Arrangement.in in its unadorned form is not an selection for united states. Humans (with rare exceptions!) don't know how to read bytes. But the InputStreamReader class comes to the rescue! Allow's see what kind of animal this is.

                      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));                  

We laissez passer System.in to the InputStreamReader object. The class name says it! We create an InputStreamReader object and laissez passer it an input stream that it will read information from. In this instance...

                      new InputStreamReader(Arrangement.in)                  

...we tell it, "you will read data from the system input stream (from the keyboard)". But this isn't its only function! The InputStreamReader doesn't only receive data from the stream. It also converts byte streams to character streams. In other words, you no longer need to catechumen the data from "ones and zeros" to a "human-readable language". InputStreamreader does everything for y'all. Of class, InputStreamReader isn't limited to reading data from the console. It can read data from other places, too. For instance, from a file:

                      import coffee.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader;  public course Principal {     public static void main(String[] args) throws IOException {        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("C:\\Users\\username\\Desktop\\testFile.txt"));    } }                  

Here we create a FileInputStream (one flavor of InputStream), pass in the file path, and laissez passer the stream itself to the InputStreamReader. Now it will be able to read data from the file (if a file really exists at the path, of form). We also use the InputStreamReader class'south read() method to read data (the source of the data doesn't thing: the panel, a file, or somewhere else). What's the difference between System.in.read() and InputStreamReader.read() ?\ Let's over again try to read the character "魚" with an InputStreamReader. I remind you lot of what was actually read by System.in.read(): 魚 233 173 154 10 And how does the InputStreamReader do the same piece of work?

                      public course Main {     public static void chief(String[] args) throws IOException {         InputStreamReader reader = new InputStreamReader(System.in);        while (true) {            int x = reader.read();            System.out.println(x);        }    } }                  

Console output: 魚 39770 10 The divergence is immediately apparent. The last byte (representing the new line) remains unchanged (the number 10), merely the character "魚" was converted into a unmarried code "39770". This is what it means to read characters! If you don't believe that 39770 represents the letter "魚", information technology's easy to convince yourself :)

          import java.io.IOException;  public course Principal {     public static void master(Cord[] args) throws IOException {         char x = 39770;        System.out.println(x);    } }                  

Console output: 魚 Just if InputStreamReader is then not bad, why do we also need BufferedReader ? InputStreamReader knows how to read data and convert bytes into characters. What more than could we ask for? Why another Reader? :/ The answer is very uncomplicated: for greater performance and convenience. Let's start with performance. When BufferedReader reads information, it uses a special expanse chosen a buffer, where it "stores" the characters it reads. Ultimately, when these characters are needed in the program, they will exist taken from the buffer, not directly from the information source (keyboard, file, etc.). This saves a lot of resources. To empathize how this works, imagine a courier in a large company. The courier sits in an office, waiting for someone to bring packages for delivery. Each time he receives a new packet, he tin can immediately hit the road. But in that location could be lots of packages during the 24-hour interval. He would have to brand lots of trips between the office and the delivery addresses. Instead, the courier puts a box in his office. Everyone puts their packages into the box. Now the courier tin calmly take the box and move from address to address. This saves a lot of time, because he doesn't have to return to the function every time. In this example, the box is just a buffer, and the office is a data source. It'southward much easier for the courier to have packages from a single box when making deliveries than to go back to the role every time. He'll save gasoline, besides. Similarly, in a program it's much less resource-intensive to take data from a buffer than to refer to the data source each time. As a upshot, BufferedReader+InputStreamReader is faster than InputStreamReader alone. Nosotros've considered performance. What virtually convenience? The master advantage is that Bufferedreader can read data not only one character at a fourth dimension (though it can do this with its read() method), but besides whole lines at a time! This is washed using the readLine() method;

                      public class Main {     public static void main(String[] args) throws IOException {         BufferedReader reader = new BufferedReader(new InputStreamReader(Organization.in));        Cord s = reader.readLine();        System.out.println("We read this line from the keyboard:");        Organization.out.println(south);    } }                  

Panel output: CodeGym is the all-time website for learning Coffee! We read this line from the keyboard: CodeGym is the best website for learning Coffee! This is especially useful when reading large amounts of data. Reading one or two lines of text character past character is however viable. But reading in "War and Peace" one letter at a fourth dimension would be somewhat problematic :)

More reading:
Adapter design pattern

polohisilat.blogspot.com

Source: https://codegym.cc/groups/posts/4-reading-from-keyboard

Share this post