We've studied working with I/O streams. We've studied working with files. What should we study next? What about working with the network, including the Internet? Sounds promising, doesn't it?
In Java, working with the Internet is no more difficult than working with files. Well, perhaps just a little bit.
To work with Internet resources, Java has a special class —
URL. It's as simple as a stool, as you will now see.
Getting a web page
How many lines of code do you think you need to write to download some text file from the Internet and display its contents on the screen? 10? 100? 1000? Or maybe 5?
|Creates a URL object with the path to the page
InputStream from the URL object
Reads all the bytes and returns an array of bytes
Convert the array to a string
Display the string
The contents of an HTML file will be displayed on the screen:
Comparing working with
URL is similar to
Path stores the path to a resource in the file system, and
URL stores the path to a resource on the Internet.
All the magic happens when we get an
InputStream object thanks to a single call to the
openStream() method. This is an ordinary object, and we have already studied it inside and out. Everything becomes obvious after we get the
InputStream object. After all, we already know how to get data from it.
Take a look: only the first two lines are different, and only slightly. And now you can see it — the advantage of standardization and working with chains of data streams:
|Working with the Internet
|Working with a file
In addition to simply reading data from the Internet, we can also upload data. Uploading data is a much more complicated than reading it. You're going to need a few more methods. For example:
|Create a URL object with the path to the page
Create a two-way connection
Get an output stream
Put data in it
Get an input stream
Read data from it
Note that we no longer call the
url.openStream() method here. Instead, we take a longer route:
- We first establish a stable two-way connection using the
- Then we get a stream to send data using the
connection.getOutputStream()method and send data to the server
- Then we get a stream for reading data using the
connection.getInputStream()method and start reading data from it.
Strictly speaking, we should wrap all streams in a
try-with-resources block for safe handling. And it wouldn't hurt to wrap the bare
OutputStream in something more convenient. For example, in
If we do all that, then our code will look something like this:
URL url = new URL("https://codegym.cc");
URLConnection connection = url.openConnection();
// Send data
try (OutputStream output = connection.getOutputStream();
PrintStream sender = new PrintStream(output))
// Read data
try(InputStream input = connection.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(input)))
3. Examples of working with the network
Let's download something from the Internet. And not just download it, but save it to disk.
For example, let's write a program that saves an image from the Google homepage to disk.
In principle, there's nothing complicated here. In its simplest form, this code would look like this:
|Saving a file to disk
With the help of the first three lines, we receive a data stream from an Internet resource — from a picture.
In the fourth line, we create the name of the file to which we will save the image. The name can be anything, but the file extension must match the extension of the picture on the Internet. That will allow local image viewers to open it correctly.
And finally, the last line is one of the
copy methods. The
Files class has several of them. This method, which we used, takes a byte stream (
InputStream) as its first parameter, and as the second parameter — the name of the file where the data should be written.
Theoretically, if the
URL of the image were short, then this code could even be written in a single line:
|Copying data from a stream to a file
Of course, you don't have to write it like this, but this example demonstrates how convenient and powerful I/O streams are in Java.