<h2 id="introduction">Introduction</h2>
The <code>map()</code>, <code>filter()</code> and <code>reduce()</code> functions bring a bit of functional programming to Python. All three of these are convenience functions that can be replaced with <a target="_blank" href="/list-comprehensions-in-python/">List Comprehensions</a> or loops, but provide a more elegant and short-hand approach to some problems.
Before continuing, we'll go over a few things you should be familiar with before reading about the aforementioned methods:
<blockquote>
What is an anonymous function/method or lambda?
</blockquote>
An anonymous method is a method without a name, i.e. not bound to an identifier like when we define a method using <code>def method:</code>.
Note: Though most people use the terms &quot;anonymous function&quot; and &quot;lambda function&quot; interchangeably - they're not the same. This mistake happens because in most programming languages lambdas are anonymous and all anonymous functions are lambdas. This is also the case in Python. Thus, we won't go into this distinction further in this article.
<blockquote>
What is the syntax of a lambda function (or lambda operator)?
</blockquote>
<pre><code class="hljs">lambda arguments: expression
</code></pre>
Think of lambdas as one-line methods without a name. They work practically the same as any other method in Python, for example:
<pre><code class="hljs">def add(x,y):
 return x + y
</code></pre>
Can be translated to:
<pre><code class="hljs">lambda x, y: x + y
</code></pre>
Lambdas differ from normal Python methods because they can have only one expression, can't contain any statements and their return type is a <code>function</code> object. So the line of code above doesn't exactly return the value <code>x + y</code> but the function that calculates <code>x + y</code>.
<blockquote>
Why are lambdas relevant to <code>map()</code>, <code>filter()</code> and <code>reduce()</code>?
</blockquote>
All three of these methods expect a <code>function</code> object as the first argument. This <code>function</code> object can be a pre-defined method with a name (like <code>def add(x,y)</code>).
Though, more often than not, functions passed to <code>map()</code>, <code>filter()</code>, and <code>reduce()</code> are the ones you'd use only once, so there's often no point in defining a referenceable function.
To avoid defining a new function for your different <code>map()</code>/<code>filter()</code>/<code>reduce()</code> needs - a more elegant solution would be to use a short, disposable, anonymous function that you will only use once and never again - a lambda.
<h2 id="themapfunction">The map() Function</h2>
The <code>map()</code> function iterates through all items in the given iterable and executes the <code>function</code> we passed as an argument on each of them.
The syntax is:
<pre><code class="hljs">map(function, iterable(s))
</code></pre>
We can pass as many iterable objects as we want after passing the <code>function</code> we want to use:
<pre><code class="hljs"># Without using lambdas
def starts_with_A(s):
 return s[0] == &quot;A&quot;

fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
map_object = map(starts_with_A, fruit)

print(list(map_object))
</code></pre>
This code will result in:
<pre><code class="hljs">[True, False, False, True, False]
</code></pre>
As we can see, we ended up with a new list where the function <code>starts_with_A()</code> was evaluated for each of the elements in the list <code>fruit</code>. The results of this function were added to the list sequentially.
A prettier way to do this exact same thing is by using lambdas:
<pre><code class="hljs">fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
map_object = map(lambda s: s[0] == &quot;A&quot;, fruit)

print(list(map_object))
</code></pre>
We get the same output:
<pre><code class="hljs">[True, False, False, True, False]
</code></pre>
Note: You may have noticed that we've cast <code>map_object</code> to a list to print each element's value. We did this because calling <code>print()</code> on a list will print the actual values of the elements. Calling <code>print()</code> on <code>map_object</code> would print the memory addresses of the values instead.
The <code>map()</code> function returns the <code>map_object</code> type, which is an iterable and we could have printed the results like this as well:
<pre><code class="hljs">for value in map_object:
 print(value)
</code></pre>
If you'd like the <code>map()</code> function to return a list instead, you can just cast it when calling the function:
<pre><code class="hljs">result_list = list(map(lambda s: s[0] == &quot;A&quot;, fruit))
</code></pre>
<h2 id="thefilterfunction">The filter() Function</h2>
Similar to <code>map()</code>, <code>filter()</code> takes a <code>function</code> object and an iterable and creates a new list.
As the name suggests, <code>filter()</code> forms a new list that contains only elements that satisfy a certain condition, i.e. the <code>function</code> we passed returns <code>True</code>.
The syntax is:
<pre><code class="hljs">filter(function, iterable(s))
</code></pre>
Using the previous example, we can see that the new list will only contain elements for which the <code>starts_with_A()</code> function returns <code>True</code>:
<pre><code class="hljs"># Without using lambdas
def starts_with_A(s):
 return s[0] == &quot;A&quot;

fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
filter_object = filter(starts_with_A, fruit)

print(list(filter_object))
</code></pre>
Running this code will result in a shorter list:
<pre><code class="hljs">[&#x27;Apple&#x27;, &#x27;Apricot&#x27;]
</code></pre>
Or, rewritten using a lambda:
<pre><code class="hljs">fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
filter_object = filter(lambda s: s[0] == &quot;A&quot;, fruit)

print(list(filter_object))
</code></pre>
Printing gives us the same output:
<pre><code class="hljs">[&#x27;Apple&#x27;, &#x27;Apricot&#x27;]
</code></pre>
<h2 id="thereducefunction">The reduce() Function</h2>
<code>reduce()</code> works differently than <code>map()</code> and <code>filter()</code>. It does not return a new list based on the <code>function</code> and iterable we've passed. Instead, it returns a single value.
Also, in Python 3 <code>reduce()</code> isn't a built-in function anymore, and it can be found in the <code>functools</code> module.
The syntax is:
<pre><code class="hljs">reduce(function, sequence[, initial])
</code></pre>
<code>reduce()</code> works by calling the <code>function</code> we passed for the first two items in the sequence. The result returned by the <code>function</code> is used in another call to <code>function</code> alongside with the next (third in this case), element.
This process repeats until we've gone through all the elements in the sequence.
The optional argument <code>initial</code> is used, when present, at the beginning of this &quot;loop&quot; with the first element in the first call to <code>function</code>. In a way, the <code>initial</code> element is the 0th element, before the first one, when provided.
<code>reduce()</code> is a bit harder to understand than <code>map()</code> and <code>filter()</code>, so let's look at a step by step example:
<ol>
<li>
We start with a list <code>[2, 4, 7, 3]</code> and pass the <code>add(x, y)</code> function to <code>reduce()</code> alongside this list, without an <code>initial</code> value
</li>
<li>
<code>reduce()</code> calls <code>add(2, 4)</code>, and <code>add()</code> returns <code>6</code>
</li>
<li>
<code>reduce()</code> calls <code>add(6, 7)</code> (result of the previous call to <code>add()</code> and the next element in the list as parameters), and <code>add()</code> returns <code>13</code>
</li>
<li>
<code>reduce()</code> calls <code>add(13, 3)</code>, and <code>add()</code> returns <code>16</code>
</li>
<li>
Since no more elements are left in the sequence, <code>reduce()</code> returns <code>16</code>
</li>
</ol>
The only difference, if we had given an <code>initial</code> value would have been an additional step - 1.5. where <code>reduce()</code> would call <code>add(initial, 2)</code> and use that return value in step 2.
Let's go ahead and use the <code>reduce()</code> function:
<pre><code class="hljs">from functools import reduce

def add(x, y):
 return x + y

list = [2, 4, 7, 3]
print(reduce(add, list))
</code></pre>
Running this code would yield:
<pre><code class="hljs">16
</code></pre>
Again, this could be written using lambdas:
<pre><code class="hljs">from functools import reduce

list = [2, 4, 7, 3]
print(reduce(lambda x, y: x + y, list))
print(&quot;With an initial value: &quot; + str(reduce(lambda x, y: x + y, list, 10)))
</code></pre>
And the code would result in:
<pre><code class="hljs">16
With an initial value: 26
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As mentioned previously, these functions are convenience functions. They are there so you can avoid writing more cumbersome code, but avoid using both them and lambda expressions too much.
Don't force these tools because &quot;you can&quot;, as it can often lead to illegible code that's hard to maintain. Use them only when it's absolutely clear what's going on as soon as you look at the function or lambda expression.
If you catch yourself struggling to fit the necessary logic into one <code>map()</code> function, or one lambda expression, it's much better to just write a slightly longer for-loop/defined method and avoid unnecessary confusion later.

Olivera Popović

In this tutorial, we'll be going over examples of the map(), filter() and reduce() functions in Python - both using Lambdas and regular functions.

map(), filter(), and reduce() in Python with Examples

Marcus Sanatan

Janith Kasun

In this tutorial, we'll dive into Node's EventEmitter class to make an event-emitting application. We'll also extend it into a custom class and cover important functions.

Handling Events in Node.js with EventEmitter

Luka Čupić

In this tutorial, we'll be formatting Strings in Java using printf(), System.format(), String.format(), the Formatter and MessageFormat classes.

How to Format a String in Java with Examples

Format String in Java with printf(), format(), Formatter and MessageFormat

<h2 id="introduction">Introduction</h2>
SCP stands for Secure Copy Protocol. It is a tool that can be used to transfer files from a local host to a remote host, from a remote host to a local host, or between two remote hosts. In this article, we'll examine how to use SCP to copy between local and remote hosts.
SCP is almost exclusively run from the command-line using the <code>scp</code> command. It uses the <a rel="nofollow noopener" target="_blank" href="https://www.ssh.com/ssh/"><code>ssh</code></a> (Secure Shell) to transfer data to and from remote hosts. As such, it has a set of options that specify the authentication parameters, hosts and port like SSH.
By default, the SCP protocol operates on port <code>22</code> unless overridden by a command-line option. All <code>scp</code> commands follow the form:
<pre><code class="hljs">$ scp [OPTIONS] [SOURCE] [DESTINATION]
</code></pre>
Let's look at how SCP allows us to transfer a file on our local computer to a remote one.
<h2 id="transferringalocalfiletoaremotedestination">Transferring a Local File to a Remote Destination</h2>
Uploading a file from our local computer to a remote location is a common scenario for IT professionals. With <code>scp</code>, we can accomplish this with a command like:
<pre><code class="hljs">$ scp path/to/local/file.ext user@remote-host:path/to/remote/file.ext
</code></pre>
This command will copy the local file <code>file.ext</code> to the specified path (after the colon) on the <code>remote-host</code>.
<ul>
<li>The <code>user</code> supplied in the command is the username. The username has to belong to a user of the remote machine.</li>
<li>The <code>remote-host</code> supplied is the domain name or the IP address of the remote machine we are trying to connect to.</li>
<li>We then specify where we want to copy the file to on the remote machine after the colon (<code>:</code>).</li>
</ul>
After running this command, a prompt will display for the password corresponding to the remote host's user account:
<pre><code class="hljs">$ user@remote-host&#x27;s password:
</code></pre>
Once the password is entered, the file will be copied.
This user account must have access to the remote path specified in the command. If you can't use your credentials to log in remotely with <code>ssh</code>, then those credentials will not work when using <code>scp</code>.
Now that we know how to transfer a remote file to our local machine, let's discuss the reverse scenario - transferring a file from a remote host to the local host.
<h2 id="transferringaremotefiletoalocaldestination">Transferring a Remote File to a Local Destination</h2>
In a very similar fashion, we can copy a file from a remote computer to our local machine:
<pre><code class="hljs">$ scp user@remote-host:path/to/remote/file.ext path/to/local/file.ext
</code></pre>
This works essentially in the same way, except that the remote user, host, and path are now specified before the local path.
A prompt will still be displayed for the password belonging to the remote host's user account. But, when complete, you should have a new file in the folder you specified.
Let's have a look at transferring a file between two remote hosts.
<h2 id="transferringaremotefiletoaremotedestination">Transferring a Remote File to a Remote Destination</h2>
Finally, the following command format is used to transfer a file between two remote hosts:
<pre><code class="hljs">$ scp user1@remote-host1:path/to/remote/file.ext user2@remote-host2:path/to/remote/file.ext
</code></pre>
Notice that in this case, two remote users must be specified. Each has to have access to their respective remote server. A password prompt will be presented to accept login credentials for each user.
From all these variations of file copying we see that the <code>scp</code> command is flexible on what can be the source or destination path. This versatility makes it very useful for scripts.
We may transfer files between our local and remote machines to test and update the server or application configurations. We may transfer files between our main remote host and a backup server with <code>scp</code>. The simplicity and flexibility of SCP has made it popular with system administrators.
The SCP command also has configurations for greater flexibility in what and how we copy. Let's see how we can use command-line options to modify its behavior.
<h2 id="commonscpcommandlineoptions">Common SCP Command-Line Options</h2>
The <code>scp</code> command has some useful options (also known as flags) that can alter aspects of how it connects to a remote host.
<h3 id="changingtheport">Changing the Port</h3>
As mentioned before, SCP operates on port <code>22</code> by default. However, this can be overridden by supplying the <code>-P</code> flag, followed by the port number.
This is how we copy a file to a remote destination connecting to port <code>44</code> instead of <code>22</code>:
<pre><code class="hljs">$ scp -P 44 path/to/local/file.ext user@remote-host:path/to/remote/file.ext
</code></pre>
<h3 id="modificationaccesstime">Modification/Access Time</h3>
The difference between the <code>-P</code> and <code>-p</code> flag is worth noting. The <code>-p</code> flag preserves the file modification times, access times, and modes while transferring. This can be useful if keeping the file properties unchanged is desired:
<pre><code class="hljs">$ scp -p path/to/local/file.ext user@remote-host:path/to/remote/file.ext
</code></pre>
<h3 id="copyingdirectories">Copying Directories</h3>
The <code>-r</code> flag can be used to recursively copy a folder and its contents instead of a single file:
<pre><code class="hljs">$ scp -r path/to/local/folder user@remote-host:path/to/remote/folder
</code></pre>
This is cleaner than copying files from the folder using the <code>*</code> or <code>?</code> wildcards.
<h3 id="supressedmode">Supressed Mode</h3>
The <code>-q</code> flag supresses the progress meter and non-error messages so your terminal stays clean:
<pre><code class="hljs">$ scp path/to/local/file.ext user@remote-host:path/to/remote/file.ext
file.ext 100% 0 0.0KB/s 00:00

$ scp -q path/to/local/file.ext user@remote-host:path/to/remote/file.ext
$
</code></pre>
Notice that the second command we ran in this example, the transfer percentage is not displayed due to the <code>-q</code> flag.
<h3 id="authenticationkeypairfile">Authentication Keypair File</h3>
The <code>-i</code> flag can be used to authenticate the connection using a cryptographic keypair stored in a file instead of a username and password. This is common practice for authenticating against remote cloud servers, like those in AWS or Digital Ocean.
You can specify a keypair file like this:
<pre><code class="hljs">$ scp -i path/to/local/keypair.pem path/to/local/file.ext user@remote-host:path/to/remote/file.ext
</code></pre>
<h3 id="usingmultiplescpoptions">Using Multiple SCP Options</h3>
Flags can be used with each other as well. Here is an example that implements multiple flags to copy a folder from a remote host to our local machine using a keypair file for authentication on port <code>44</code>, while preserving file properties and supressing output:
<pre><code class="hljs">$ scp -p -q -P 44 -i path/to/local/keypair.pem -r path/to/local/folder user@remote-host:path/to/remote/folder
</code></pre>
With this foundation, you're equipped to use SCP for a variety of situations!
<h2 id="conclusion">Conclusion</h2>
In this article, we discussed SCP, a protocol which can be used to conveniently transfer files between hosts. We covered transferring files from the local host to a remote host, from a remote host to the local host, and between two remote hosts.
We also touched on a few important command-line options which may be used in specific scenarios.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software developer and consultant with passion for helping others improve their lives through code. Jacob is the author of the <a rel="noopener" target="_blank" href="https://initialcommit.com/store/coding-essentials-guidebook-for-developers">Coding Essentials Guidebook for Developers</a>, an introductory book that covers essential coding concepts and tools. It contains chapters on basic computer architecture, the Internet, Command Line, HTML, CSS, JavaScript, Python, Java, databases/SQL, Git, and more.

Jacob Stopak

Learn SCP (Secure Copy Protocol) - a command-line tool built on SSH that's used to transfer files between local and remote computers, through examples.

Using SCP to Copy and Securely Transfer Files and Folders

<h2 id="introduction">Introduction</h2>
Python's <code>print()</code> function is typically used to display text either in the command-line or in the interactive interpreter, depending on how the Python program is executed. However, we can change its behavior to write text to a file instead of to the console.
In this article, we'll examine the many ways we can write to a file with the <code>print()</code> function.
<h2 id="redirectingapythonsscriptoutputintheterminal">Redirecting a Python's Script Output in the Terminal</h2>
The quick and dirty way to redirect a Python script's output is directly from the command-line while executing the script.
For example, if we had a Python file called <code>hello.py</code> with the following contents:
<pre><code class="hljs">print(&quot;Hallo&quot;) # Deliberately in German
</code></pre>
We can redirect the output of the file in the shell using a single right angle bracket:
<pre><code class="hljs">$ python3 hello.py &gt; output.txt
</code></pre>
If we open our newly created <code>output.txt</code>, we'll see the following contents:
<pre><code class="hljs">Hallo
</code></pre>
However, with this method, all output of the script is written to a file. It is often more flexible to perform this redirection from within the Python script itself.
<h2 id="redirectingthestandardoutputstream">Redirecting the Standard Output Stream</h2>
In Python, the <code>print()</code> function is more flexible than you might think. It was not hard-coded in such a way that specified text can only be written to the display. Instead, it sends text to a location called the standard output stream, also known as <code>stdout</code>.
All UNIX systems have three main pipes - standard input pipe (<code>stdin</code>), standard output pipe (<code>stdout</code>) and standard error pipe (<code>stderr</code>).
By default, the standard output pipe points to the interactive window used to execute the program, so we normally see text printed out on the screen. However, the standard output can be redirected to other locations, such as files, for convenience.
If the standard output is redirected to a specific file, the text specified in the <code>print()</code> function will be written to that file instead of being displayed on the screen.
In Python, a reference to the standard output can be obtained using the <code>stdout</code> object of the <code>sys</code> module. It is a file-like object, meaning it has methods that allow Python to read and write from it like an actual file.
Let's see an example where we change <code>stdout</code> to be a file:
<pre><code class="hljs">import sys

print(&#x27;This message will be displayed on the screen.&#x27;)

original_stdout = sys.stdout # Save a reference to the original standard output

with open(&#x27;filename.txt&#x27;, &#x27;w&#x27;) as f:
 sys.stdout = f # Change the standard output to the file we created.
 print(&#x27;This message will be written to a file.&#x27;)
 sys.stdout = original_stdout # Reset the standard output to its original value
</code></pre>
The <code>print()</code> function takes the supplied string argument, appends a newline character to the end, and calls the <code>stdout.write()</code> method to write it to standard output.
In the example above, we first print a line of text as we're accustomed to, which will be displayed in the console when we run the file. We then reassigned <code>stdout</code> to our custom file object - <code>f</code>. Since a file object has a perfectly valid <code>write()</code> method, our printed value gets written to the file without a problem.
Note that it is good practice to store the original value of the standard output in a variable before changing it. This way we can reset the standard output to its original value after we're done, which can help avoid confusion.
Let's save the code to a new file, <code>printToFile.py</code>. And then, let's execute it:
<pre><code class="hljs">$ python3 printToFile.py
</code></pre>
We'll see the following output in the Terminal:
<pre><code class="hljs">This message will be displayed on the screen.
</code></pre>
And the script will create a new file called <code>filename.txt</code> with the following contents:
<pre><code class="hljs">This message will be written to a file.
</code></pre>
You successfully redirected data from the standard output stream to a file. Let's see how we can do this to another popular file-like object that's dedicated to programming errors.
<h2 id="redirectingthestandarderrorstream">Redirecting the Standard Error Stream</h2>
In Python, errors are written to the standard error stream, also known as <code>stderr</code>. This also defaults to the interactive window but can be changed via the <code>sys.stderr</code> object. If we wanted to print values to the <code>stderr</code>, we could simply redirect the <code>sys.stdout</code> to point to the <code>sys.stderr</code>.
Create a file called <code>printToStderr.py</code> and add the following code:
<pre><code class="hljs">import sys

print(&#x27;This message will be displayed via standard output.&#x27;)

original_stdout = sys.stdout # Save a reference to the original standard output

sys.stdout = sys.stderr # Redirect the standard output to the standard error.
print(&#x27;This message will be displayed via the standard error.&#x27;)

sys.stdout = original_stdout # Reset the standard output to its original value
</code></pre>
This example is almost identical to the previous one, except that instead of redirecting the standard output stream to a file, we redirect it to the standard error stream. If the standard error stream was also redirected somewhere else, the output would be sent to that location instead of to the screen.
Let's run this file:
<pre><code class="hljs">$ python3 printToStderr.py
</code></pre>
Our output would show:
<pre><code class="hljs">This message will be displayed via standard output.
This message will be displayed via the standard error.
</code></pre>
While it may appear like regular output to us, for the computer it is displayed through different pipelines.
<h2 id="printusingthefileparameter">Print Using the &quot;file&quot; Parameter</h2>
In the previous examples, we explicitly redirected the standard output to another file-like object by changing the <code>stdout</code> object. However, for convenience we can do this directly from within the <code>print()</code> function by specifying the output location with the <code>file</code> parameter:
For example, if we wanted to print directly to a file without changing the entire script's <code>stdout</code>, we would write:
<pre><code class="hljs">import sys

print(&#x27;This message will be displayed on the screen.&#x27;)

with open(&#x27;filename.txt&#x27;, &#x27;w&#x27;) as f:
 print(&#x27;This message will be written to a file.&#x27;, file=f)
</code></pre>
As we did not fiddle with redirecting the standard output explicitly, we no longer have to reset it to its initial value. As a result, this is the preferred way to write to a file with the <code>print()</code> function.
Note: Although the parameter's name is <code>file</code>, remember that it works with any file-like object. If you wanted to print to <code>stderr</code>, for example, you would change the <code>print()</code> statement to:
<pre><code class="hljs">print(&#x27;This message will be written to stderr.&#x27;, file=sys.stderr)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we discussed redirecting Python's <code>print()</code> function output using various methods. These methods included redirecting the output of a Python script from the command-line, redirecting the standard output within Python scripts, and specifying a file-like object in the <code>file</code> parameter directly in the <code>print()</code> function.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software developer and consultant with passion for helping others improve their lives through code. Jacob is the author of the <a rel="nofollow noopener" href="https://initialcommit.com/store/coding-essentials-guidebook-for-developers" target="_blank">Coding Essentials Guidebook for Developers</a>, an introductory book that covers essential coding concepts and tools. It contains chapters on basic computer architecture, the Internet, Command Line, HTML, CSS, JavaScript, Python, Java, databases/SQL, Git, and more.

Python's print function is typically used to display text either in the console. We can also use the print function to write to a file. This article shows you how.

Writing to a File with Python's print() Function

<h2 id="introduction">Introduction</h2>
The Bridge Design Pattern is a <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Structural_pattern">Structural Design Pattern</a>, which splits the abstraction from the implementation. In this article, we'll be covering the motivation and implementation of the Bridge Design Pattern in Python.
Design Patterns refer to a set of standardized practices or solutions to common architectural problems in software engineering.
<h2 id="motivationbehindthebridgedesignpattern">Motivation Behind the Bridge Design Pattern</h2>
The Bridge Pattern prevents what's called the <a rel="nofollow noopener" target="_blank" href="https://www.mathstopia.net/sets/cartesian-product">cartesian product complexity</a> explosion.
The problem will be obvious going through an example. Suppose you're implementing an <code>Airplane</code>. It can be a military or commercial airplane. Furthermore, it can be a passenger/soldier or cargo airplane.
One approach to implementing this is by having a <code>MilitaryPassenger</code>, <code>MilitaryCargo</code>, <code>CommercialPassenger</code> and <code>CommercialCargo</code> airplanes.
Here the cartesian product complexity is <code>2 x 2 = 4</code>. This number isn't ground-breaking at this scale, but when you include more classes and variations, it can rise exponentially and it'll very quickly become unmanageable.
The Bridge Pattern is used, well, as a bridge between classes (<code>Airplane</code> implementation) and their characteristics (is it a passenger or cargo plane). It favors <a target="_blank" href="https://stackabuse.com/object-oriented-design-principles-in-java/#thecompositionoverinheritanceprinciple">composition over inheritance</a>.
Using the pattern, you create one class for each of the types in different categories. For instance, in our example, we'd have a <code>CommercialPlane</code> and <code>MilitaryPlane</code> as entities, with <code>CargoCarrier</code> and <code>PassengerCarrier</code> as separate entities.
It might not look like we've done a lot since we've still got 4 classes, but imagine this on a scale. You can have <code>nPlane</code> classes and only have <code>CargoCarrier</code> and <code>PassengerCarrier</code> which you can apply to these planes.
An even better way would be to have parent classes - <code>Carrier</code> and <code>Plane</code>. For the <code>Carrier</code> parent class, you can create two child classes: <code>Cargo</code> and <code>Passenger</code>. Similarly, for the <code>Plane</code> parent class, two child classes: <code>Military</code> and <code>Commercial</code>.
Next, you will need a way to connect, or in other words, bridge <code>Carrier</code> and <code>Plane</code> subclasses. You can do so by passing one of these two classes as a parameter value in the constructor of the other class. By implementing the pattern, we'll be able to combine any of the subclasses.
Finally, let's see how we can implement the Bridge Design Pattern in Python.
<h2 id="implementingthebridgedesignpatterninpython">Implementing the Bridge Design Pattern in Python</h2>
As I said earlier, we will create a parent class <code>Carrier</code> with two abstract methods: <code>carry_military()</code>, and <code>carry_passenger()</code>. Next, we can create a child class <code>Cargo</code> which inherits from the <code>Carrier</code> class and implements the <code>carry_military()</code> and <code>carry_commercial()</code> methods.
To avoid the slippery slope of adding variations of classes, we'll define a <code>Carrier</code> with two abstract methods - <code>carry_military()</code> and <code>cary_passenger()</code>.
The <code>Carrier</code> class will additionally have two child classes - <code>Cargo</code> and <code>Passenger</code> which both inherit its abstract methods and implement them:
<pre><code class="hljs"># Passenger &amp; Cargo Carriers

class Carrier:
 def carry_military(self, items):
 pass
 
 def carry_commercial(self, items):
 pass
 
class Cargo(Carrier):
 def carry_military(self, items):
 print(&quot;The plane carries &quot;, items,&quot; military cargo goods&quot;)
 
 def carry_commercial(self, items):
 print(&quot;The plane carries &quot;, items,&quot; commercial cargo goods&quot;) 

class Passenger(Carrier):
 def carry_military(self, passengers):
 print(&quot;The plane carries &quot;, passengers , &quot; military passengers&quot;)
 
 def carry_commercial(self, passengers):
 print(&quot;The plane carries &quot;, passengers , &quot; commercial passengers&quot;) 
</code></pre>
In the same vein, we'll create a <code>Plane</code> class with two abstract methods - <code>display_description()</code> and <code>add_objects()</code>, as well as two child classes - <code>Commercial</code> and <code>Military</code>. We'll be passing a <code>Carrier</code> to the constructor of the <code>Plane</code> class. This is the bridge.
If the plane is a <code>Commercial</code> plane, it's <code>Cargo</code> and <code>Passenger</code> will return <code>carry_commercial()</code>, and vice versa.
The number of passengers/goods will be stored in the <code>self.objects</code> variable which is passed as a parameter to the <code>carry_commercial()</code> method:
<pre><code class="hljs"># Military &amp; Commercial Planes
class Plane:
 def __init__(self, Carrier):
 self.carrier = Carrier
 
 def display_description(self):
 pass
 
 def add_objects(self):
 pass
 
class Commercial(Plane):
 def __init__(self, Carrier, objects):
 super().__init__(Carrier)
 self.objects = objects

 def display_description(self):
 self.carrier.carry_commercial(self.objects)

 def add_objects(self, new_objects):
 self.objects += new_objects 

class Military(Plane):
 def __init__(self, Carrier, objects):
 super().__init__(Carrier)
 self.objects = objects

 def display_description(self):
 self.carrier.carry_military(self.objects)

 def add_objects(self, new_objects):
 self.objects += new_objects
</code></pre>
Our classes are primed and ready. Now is the time to create some objects and have them bridge between themselves through the previously mentioned constructor call.
Let's take a look at an example:
<pre><code class="hljs">cargo = Cargo()
passenger = Passenger()

# Bridging Military and Cargo classes
military1 = Military(cargo , 100)
military1.display_description()
military1.add_objects(25)
military1.display_description()
</code></pre>
Here, we've instantiated objects for the <code>Cargo</code> and <code>Passenger</code> classes. Then, in a constructor call to the <code>Military</code> class, we've passed the <code>cargo</code> instance. Since it's a military plane, the cargo is considered military cargo.
Therefore, the <code>display_description()</code> method will print out details regarding military cargo. Furthermore, we've added another <code>25</code> objects on top of this load:
<pre><code class="hljs">The plane carries 100 military cargo goods
The plane carries 125 military cargo goods
</code></pre>
In the same vein, we can bridge the <code>Military</code> and <code>Passenger</code> classes as well:
<pre><code class="hljs">cargo = Cargo()
passenger = Passenger()

# Bridging Military and Passenger classes
military2 = Military(passenger , 250)
military2.display_description()
military2.add_objects(10)
military2.display_description()
</code></pre>
Naturally, the <code>display_description()</code> method results in the number of military passengers we're carrying:
<pre><code class="hljs">The plane carries 250 military passengers
The plane carries 260 military passengers
</code></pre>
Similarly, we can bridge <code>Commercial</code> and <code>Passenger</code>:
<pre><code class="hljs"># Bridging Commercial and Passenger
commercial1 = Commercial(passenger , 400)
commercial1.display_description()
commercial1.add_objects(50)
commercial1.display_description()
</code></pre>
Which will result in:
<pre><code class="hljs">The plane carries 400 commercial passengers
The plane carries 450 commercial passengers
</code></pre>
And finally, we can bridge the <code>Commercial</code> and <code>Cargo</code> classes:
<pre><code class="hljs"># Bridging Commercial and Cargo
commercial2 = Commercial(cargo, 150)
commercial2.display_description()
commercial2.add_objects(15)
commercial2.display_description()
</code></pre>
Which results in:
<pre><code class="hljs">The plane carries 150 commercial cargo goods
The plane carries 165 commercial cargo goods
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The Bridge Design Pattern is a Structural Design Pattern, which splits the abstraction from the implementation. In this article, we've explored the motivation behind the Bridge Design Pattern and how it works.
Afterwards, we've implemented the pattern in Python, showcasing how the pattern works.

Usman Malik

In this tutorial, we'll be exploring the motivation behind the Bridge Design Pattern and implement it in Python.

The Bridge Design Pattern in Python

The Bridge Design Pattern with Python

<h2 id="introduction">Introduction</h2>
Be it searching through a play-list for your favorite song or searching through a catalog to pick the restaurant to have your next meal in, our lives are filled with searching for things.
In quite the same way, computers perform search queries on their data collections and structures. However, in contrast to humans, computers have to carry out searches on much larger datasets in times that are orders of magnitude faster than humans.
This drove Computer Scientists to come up with many search algorithms, where each is typically more optimal than some other on certain collections.
<h2 id="jumpsearch">Jump Search</h2>
Jump Search (also referred to as Block Search) is an algorithm used to search for the position of a target element on a sorted data collection or structure.
Instead of searching the array element-by-element (Linear Search) - Jump Search evaluates blocks of elements. Or rather, since it's a sorted array - the element with the highest value in each block.
<blockquote>
If the value is smaller than the target element, the next block is considered. 
If the value is higher than the target element, the target element is in the current block. 
If the value is the target element - just return it.
</blockquote>
By iteratively shifting, or rather jumping forward, we'll either find the target element or reach the end of the collection without finding it.
Here’s a visual representation of how Jump Search works:
<img src="https://stackabuse.s3.amazonaws.com/media/jump-search-in-java-1.gif" alt="jump search visualization gif">
Evidently, Jump Search always seeks forward on its arrays unlike back and forth search methods like Binary Search. This behavior makes Jump Search much more efficient for searches on data stored on physical drives with spinning mediums.
Furthermore, another way to understand this search is without blocks - there's simply a Jump Gap between the evaluated elements. No real block is being saved in the memory as the algorithm executes.
<h2 id="implementation">Implementation</h2>
That being said, let's implement Jump Search. There are two approaches that you can take, without a real &quot;winner&quot; between these two - the iterative and recursive implementation.
Choosing between these two is up to you and unless you're working on insanely huge datasets, there shouldn't be a difference in performance. Recursion leads to higher processor/memory space usage but is typically cleaner to read and write.
Then again, if you're working on really big datasets, you'd probably use more efficient, optimized search algorithms.
<h3 id="iterativeimplementation">Iterative Implementation</h3>
That being said, let's start off with the iterative approach:
<pre><code class="hljs">public static int jumpSearch(int[] arrayToSearch, int element) {
 int blockSize = (int) Math.floor(Math.sqrt(arrayToSearch.length));

 int currentLastIndex = blockSize-1;
 
 // Jump to next block as long as target element is &gt; currentLastIndex
 // and the array end has not been reached
 while (currentLastIndex &lt; arrayToSearch.length &amp;&amp; element &gt; arrayToSearch[currentLastIndex]) {
 currentLastIndex += blockSize;
 }

 // Find accurate position of target element using Linear Search
 for (int currentSearchIndex = currentLastIndex - blockSize + 1;
 currentSearchIndex &lt;= currentLastIndex &amp;&amp; currentSearchIndex &lt; arrayToSearch.length; currentSearchIndex++) {
 if (element == arrayToSearch[currentSearchIndex]) {
 return currentSearchIndex;
 }
 }
 // Target element not found. Return negative integer as element position.
 return -1;
}
</code></pre>
First off, we've calculated the block size. Generally, a square root of the array's length is a good size to choose. This is further explained in the Big-O Analysis section. Searching through a block like this, in the end, will also be cheap for an algorithm like Linear Search.
Since the array is sorted, if our target element's value is greater than the value of the current element, then the target element surely cannot be inside the current block. So we jump to the next block and compare the target element with the new block’s last index element value.
<blockquote>
This jump is repeated until the block that contains the target element is found.
</blockquote>
If the target element is no longer greater than the value of the last element in a block, then it has to be inside the block if it exists at all.
<blockquote>
So we will find the accurate position of the target element using Linear Search
</blockquote>
If we reach the end of the array without finding a block that contains our target element - it's not present in the array and we return <code>-1</code> to signify that.
<h3 id="recursiveimplementation">Recursive Implementation</h3>
With the iterative implementation out of the way, let's explore the recursive implementation as well:
<pre><code class="hljs">public static int jumpSearchInit(int[] arrayToSearch, int element) {
 int blockSize = (int) Math.sqrt(arrayToSearch.length);

 // Hold the last index of the current block
 int currentLastIndex = blockSize-1;

 return jumpSearch(arrayToSearch, element, blockSize, currentLastIndex);
}

public static int jumpSearch(int[] arrayToSearch, int element, int blockSize, int currentLastIndex) {
 if (currentLastIndex &lt; arrayToSearch.length &amp;&amp; element &gt; arrayToSearch[currentLastIndex]) {
 currentLastIndex += blockSize;
 // Make recursive call to jumpSearch method
 return jumpSearch(arrayToSearch, element, blockSize, currentLastIndex);
 } else {
 // Find accurate position of target element using linear search
 for (int currentSearchIndex = currentLastIndex - blockSize + 1;currentSearchIndex &lt;= currentLastIndex &amp;&amp; currentSearchIndex &lt; arrayToSearch.length; currentSearchIndex++) {
 if (element == arrayToSearch[currentSearchIndex]) {
 return currentSearchIndex;
 }
 }
 }
 // Target element not found. Return negative integer as element position.
 return -1;
}
</code></pre>
Recursively performing a Jump Search works in the same way. We just call the method recursively instead of having a <code>while</code> loop.
We need the use of an initializer method to make some initial calculations. Namely, the optimum block size and the last index of the very first block.
Thereafter, for as long as our target element is greater than the current block’s last index element value, we recursively call Jump Search method passing the parameters of the subsequent block to it.
<blockquote>
This recursion ends once the block containing the target element was found, or if the array end was reached eventually
</blockquote>
In case such a target block was found, we perform a Linear Search on it to find the position of the target element.
<h2 id="benchmarkingjumpsearch">Benchmarking Jump Search</h2>
Let’s benchmark Jump Search by running it against sorted integer arrays of varied sizes. Of course, we'll be searching for the worst-case scenario in all of these (the last element):
<table class="table table-striped">
 <tr>
 <th>Array Size</th>
 <th>1st run (ms)</th>
 <th>2nd run (ms)</th>
 <th>3rd run (ms)</th>
 <th>Average (ms)</th>
 </tr>
 <tr>
 <td>10</td>
 <td>0.3595</td>
 <td>0.2267</td>
 <td>0.3477</td>
 <td>0.3119</td>
 </tr>
 <tr>
 <td>10,000</td>
 <td>0.2210</td>
 <td>0.5809 </td>
 <td>0.2225</td>
 <td>0.3410</td>
 </tr>
 <tr>
 <td>1,000,000</td>
 <td>0.7754</td>
 <td>0.7788</td>
 <td>0.7906</td>
 <td>0.7816</td>
 </tr>
</table>
Compared to Linear Search which takes 5.4209ms, it's evident that Jump Search is significantly faster.
<h2 id="bigoanalysis">Big-O Analysis</h2>
Consider a sorted integer array of size <code>n</code> with a block size of <code>m</code>.
In the best case, Jump Search would find the target element at the edge of the very first block it searches in. In turn, this causes Jump Search to have a best-case efficiency of O(1) complexity in <a target="_blank" href="/big-o-notation-and-algorithm-analysis-with-python-examples/">Big-O Notation terms</a>.
By contrast, considering its worst case, Jump Search would consecutively jump to its very last block searching for the target element, in turn causing an <code>n/m</code> number of jumps. Additionally, if the last element’s value of this block was greater than the target element, Jump Search would perform a linear search with <code>m-1</code> iterations.
This causes Jump Search to make <code>(n/m)</code> jumps with additional <code>m-1</code> iterations. This value is minimum at <code>m = √n</code>. Therefore, the optimum block size is <code>√n</code>.
Accordingly, Jump Search maintains a worst and average case efficiency of O(√n) complexity.
This makes it noteworthy to mention that although Jump Search is highly efficient for searching arrays especially when its only-seeks-forward behavior is favorable - its average performance makes it sit somewhere between <a target="_blank" href="/binary-search-in-java/">Binary Search</a> with its O(log n) complexity and Linear Search with an O(n) complexity.
And also, Jump Search consistently requires its searched arrays to be sorted in ascending order, in advance.
<h2 id="conclusion">Conclusion</h2>
Jump Search performs by jumping ahead block-by-block of the array until a block that might contain a given element is found.
In this article, we've implemented iterative and recursive Jump Search and benchmarked the algorithm with arrays of different sizes.
Furthermore, we undertook a Big-O Analysis proving how Jump Search acquired its average and worst-case efficiency of O(√n).

Dasun Nirmitha

Jump Search is a fairly efficient algorithm for searching sorted arrays by jumping through blocks. In this article, we'll implement Jump Search in Java and perform Big-O analysis.

Jump Search in Java

<h2 id="introduction">Introduction</h2>
In this article, we will overview the functionality of the Future interface as one of Java's concurrency constructs. We'll also look at several ways to create an asynchronous task, because a <code>Future</code> is just a way to represent the result of an asynchronous computation.
The <code>java.util.concurrent</code> package was added to Java 5. This package contains a set of classes that makes the development of concurrent applications in Java easier. In general, concurrency is a fairly complex subject and it may seem a bit daunting.
A Java <code>Future</code> is very similar to a JavaScript <a target="_blank" href="/promises-in-node-js/"><code>Promise</code></a>.
<h2 id="motivation">Motivation</h2>
A common task for asynchronous code is providing a responsive UI in an application running a costly computation or data reading/writing operation.
Having a frozen screen or no indication that the process is in progress results in fairly bad user experience. The same goes for applications that are outright slow:
<blockquote>
Minimization of idle time by switching tasks can improve the performance of an application drastically, though it depends on what kind of operations are involved.
</blockquote>
Fetching a web resource can be delayed or slow in general. Reading a huge file can be slow. Waiting for a result of cascading microservices can be slow. In synchronous architectures, the application waiting for the result waits for all of these processes to complete before proceeding.
In asynchronous architectures, it continues doing things that it can without the returned result in the meantime.
<h2 id="implementation">Implementation</h2>
Before starting with examples, let's look at the basic interfaces and classes from the <code>java.util.concurrent</code> package that we are going to use.
The Java <code>Callable</code> interface is an improved version of <code>Runnable</code>. It represents a task that returns a result and may throw an exception. To implement <code>Callable</code>, you have to implement the <code>call()</code> method with no arguments.
To submit our <code>Callable</code> for concurrent execution, we'll use the <code>ExecutorService</code>. The easiest way to create an <code>ExecutorService</code> is to use one of the factory methods of the <code>Executors</code> class. After the creation of the asynchronous task, a Java <code>Future</code> object is returned from the executor.
If you'd like to read more about <a target="_blank" href="/concurrency-in-java-the-executor-framework/">The Executor Framework</a>, we've got an in-depth article on that.
<h3 id="thefutureinterface">The Future Interface</h3>
The <code>Future</code> interface is an interface that represents a result that will eventually be returned in the future. We can check if a <code>Future</code> has been fed the result, if it's awaiting a result or if it has failed before we try to access it, which we'll cover in the upcoming sections.
Let's first take a look at the interface definition:
<pre><code class="hljs">public interface Future&lt;V&gt; {
 V get() throws InterruptedException, ExecutionException;
 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
 boolean isCancelled();
 boolean isDone();
 boolean cancel(boolean mayInterruptIfRunning)
}
</code></pre>
The <code>get()</code> method retrieves the result. If the result has not yet been returned into a <code>Future</code> instance, the <code>get()</code> method will wait for the result to be returned. It's crucial to note that <code>get()</code> will block your application if you call it before the result has been returned.
You can also specify a <code>timeout</code> after which the <code>get()</code> method will throw an exception if the result hasn't yet been returned, preventing huge bottlenecks.
The <code>cancel()</code> method attempts to cancel the execution of the current task. The attempt will fail if the task has already completed, has been canceled, or could not be canceled because of some other reasons.
The <code>isDone()</code> and <code>isCancelled()</code> methods are dedicated to finding out the current status of an associated <code>Callable</code> task. You'll typically use these as conditionals to check if it makes sense to use the <code>get()</code> or <code>cancel()</code> methods.
<h3 id="thecallableinterface">The Callable Interface</h3>
Let's create a task that takes some time to complete. We'll define a <code>DataReader</code> that <code>implements Callable</code>:
<pre><code class="hljs">public class DataReader implements Callable {
 @Override
 public String call() throws Exception {
 System.out.println(&quot;Reading data...&quot;);
 TimeUnit.SECONDS.sleep(5);
 return &quot;Data reading finished&quot;;
 }
}
</code></pre>
To simulate a costly operation, we're using <code>TimeUnit.SECONDS.sleep()</code>. It calls <code>Thread.sleep()</code>, but is a bit cleaner for longer periods of time.
Similarly, let's have a processor class that processes some other data at the same time:
<pre><code class="hljs">public class DataProcessor implements Callable {
 @Override
 public String call() throws Exception {
 System.out.println(&quot;Processing data...&quot;);
 TimeUnit.SECONDS.sleep(5);
 return &quot;Data is processed&quot;;
 }
}
</code></pre>
Both of these methods take 5 seconds each to run. If we were to simply call one after another synchronously, reading and processing would take ~10s.
<h2 id="runningfuturetasks">Running Future Tasks</h2>
Now, to call these methods from another, we'll instantiate an executor and submit our <code>DataReader</code> and <code>DataProcessor</code> to it. The executor returns a <code>Future</code>, so we'll pack the result of it into a <code>Future</code>-wrapped object:
<pre><code class="hljs">public static void main(String[] args) throws InterruptedException, ExecutionException {
 ExecutorService executorService = Executors.newFixedThreadPool(2);

 Future&lt;String&gt; dataReadFuture = executorService.submit(new DataReader());
 Future&lt;String&gt; dataProcessFuture = executorService.submit(new DataProcessor());

 while (!dataReadFuture.isDone() &amp;&amp; !dataProcessFuture.isDone()) {
 System.out.println(&quot;Reading and processing not yet finished.&quot;);
 // Do some other things that don&#x27;t depend on these two processes
 // Simulating another task
 TimeUnit.SECONDS.sleep(1);
 }
 System.out.println(dataReadFuture.get());
 System.out.println(dataProcessFuture.get());
}
</code></pre>
Here, we've created an executor with two threads in the pool since we have two tasks. You can use the <code>newSingularThreadExecutor()</code> to create a single one if you only have one concurrent task to execute.
If we submit more than these two tasks into this pool, the additional tasks will wait in the queue until a free spot emerges.
Running this piece of code will yield:
<pre><code class="hljs">Reading and processing not yet finished.
Reading data...
Processing data...
Reading and processing not yet finished.
Reading and processing not yet finished.
Reading and processing not yet finished.
Reading and processing not yet finished.
Data reading finished
Data is processed
</code></pre>
The total runtime will be ~5s, not ~10s since both of these were concurrently running at the same time. As soon as we've submitted the classes to the executor, their <code>call()</code> methods have been called. Even having a <code>Thread.sleep()</code> of one second five times doesn't affect the performance much since it's running on its own thread.
It's important to note that the code didn't run any faster, it just didn't wait redundantly for something it didn't have to and performed other tasks in the meantime.
What's important here is the usage of the <code>isDone()</code> method. If we didn't have the check, there wouldn't be any guarantee that the results were packed in the <code>Future</code>s before we've accessed them. If they weren't, the <code>get()</code> methods would block the application until they did have results.
<h2 id="futuretimeout">Future Timeout</h2>
If there were no checks for the completion of future tasks:
<pre><code class="hljs">public static void main(String[] args) throws InterruptedException, ExecutionException {
 ExecutorService executorService = Executors.newFixedThreadPool(2);

 Future&lt;String&gt; dataReadFuture = executorService.submit(new DataReader());
 Future&lt;String&gt; dataProcessFuture = executorService.submit(new DataProcessor());

 System.out.println(&quot;Doing another task in anticipation of the results.&quot;);
 // Simulating another task
 TimeUnit.SECONDS.sleep(1);
 System.out.println(dataReadFuture.get());
 System.out.println(dataProcessFuture.get());
}
</code></pre>
The execution time would still be ~5s, though, we'd be faced with a big issue. It takes 1 second to complete an additional task, and 5 to complete the other two.
Sounds just like last time?
<blockquote>
4 out of 5 seconds in this program are blocking. We've tried getting the result of the future before it was returned and have blocking 4 seconds until they do return.
</blockquote>
Let's set a constraint for getting these methods. If they don't return within a certain expected time frame, they'll throw exceptions:
<pre><code class="hljs">String dataReadResult = null;
String dataProcessResult = null;

try {
 dataReadResult = dataReadFuture.get(4, TimeUnit.SECONDS);
 dataProcessResult = dataProcessFuture.get(0, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
 e.printStackTrace();
}

System.out.println(dataReadResult);
System.out.println(dataProcessResult);
</code></pre>
Both these take 5s each. With a head start wait of a second from the other task, the <code>dataReadFuture</code> is returned within an additional 4 seconds. The data process result is returned at the same time and this code runs well.
If we gave it an unrealistic time to execute (less than 5s total), we'd be greeted with:
<pre><code class="hljs">Reading data...
Doing another task in anticipation of the results.
Processing data...
java.util.concurrent.TimeoutException
 at java.util.concurrent.FutureTask.get(FutureTask.java:205)
 at FutureTutorial.Main.main(Main.java:21)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
 at java.lang.reflect.Method.invoke(Method.java:497)
 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
null
null
</code></pre>
Of course, we wouldn't simply print the stack trace in an actual application, but rather reroute the logic to handle the exceptional state.
<h2 id="cancelingfutures">Canceling Futures</h2>
In some cases, you might want to cancel a future. For example, if you don't receive a result within <code>n</code> seconds, you might just decide to not use the result at all. In that case, there's no need to have a thread still execute and pack the result since you won't be using it.
This way, you free up a space for another task in the queue or simply release the resources allocated to an unnecessary costly operation:
<pre><code class="hljs">boolean cancelled = false;
if (dataReadFuture.isDone()) {
 try {
 dataReadResult = dataReadFuture.get();
 } catch (ExecutionException e) {
 e.printStackTrace();
 }
} else {
cancelled = dataReadFuture.cancel(true);
}
if (!cancelled) {
 System.out.println(dataReadResult);
} else {
 System.out.println(&quot;Task was cancelled.&quot;);
}
</code></pre>
If the task had been done, we get the result and pack it in our result String. Otherwise, we <code>cancel()</code> it. If it wasn't <code>cancelled</code>, we print the value of the resulting String. By contrast, we notify the user that the task was canceled otherwise.
What's worth noting is that the <code>cancel()</code> method accepts a <code>boolean</code> parameter. This <code>boolean</code> defines whether we allow the <code>cancel()</code> method to interrupt the task execution or not. If we set it as <code>false</code>, there's a possibility that the task won't be canceled.
We have to assign the return value of the <code>cancel()</code> method to a <code>boolean</code> as well. The returned value signifies if the method ran successfully or not. If it fails to cancel a task, the <code>boolean</code> will be set as <code>false</code>.
Running this code will yield:
<pre><code class="hljs">Reading data...
Processing data...
Task was cancelled.
</code></pre>
And if we try getting the data from a canceled task, a <code>CancellationException</code> is generated:
<pre><code class="hljs">if (dataReadFuture.cancel(true)) {
 dataReadFuture.get();
}
</code></pre>
Running this code will yield:
<pre><code class="hljs">Processing data...
Exception in thread &quot;main&quot; java.util.concurrent.CancellationException
 at java.util.concurrent.FutureTask.report(FutureTask.java:121)
 at java.util.concurrent.FutureTask.get(FutureTask.java:192)
 at FutureTutorial.Main.main(Main.java:34)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
 at java.lang.reflect.Method.invoke(Method.java:497)
 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
</code></pre>
<h2 id="limitationsofthefuture">Limitations of the Future</h2>
The Java <code>Future</code> was a good step towards asynchronous programming. But, as you already may have notices, it's rudimentary:
<ul>
<li><code>Future</code>s can not be explicitly completed (setting its value and status).</li>
<li>It doesn't have a mechanism to create stages of processing that are chained together.</li>
<li>There is no mechanism to run <code>Future</code>s in parallel and after to combine their results together.</li>
<li>The <code>Future</code> does not have any exception handling constructs.</li>
</ul>
Fortunately, Java provides concrete Future implementations that provide these features (<code>CompletableFuture</code>, <code>CountedCompleter</code>, <code>ForkJoinTask, FutureTask</code>, etc).
<h2 id="conclusion">Conclusion</h2>
When you need to wait for another process to complete without blocking, it can be useful to go asynchronous. This approach helps to improve the usability and performance of applications.
Java includes specific constructs for concurrency. The basic one is the Java <code>Future</code> that represents the result of asynchronous computation and provides basic methods for handling the process.

Victoria Seniuk

The Future interface represents a result that will eventually be returned. In this article, we'll use the Future and Callable interfaces to create a concurrent Java application.

Guide to the Future Interface in Java

David Landup

In this tutorial, we'll be encoding and decoding Base64 Strings in Java with examples. We'll also perform Base64 encoding using Apache Commons.