Taimoor Choudhary

With HATEOAS, we can expose additional information in a single API call. In this article, we'll be building a Hypermedia-Driven RESTful web Service in Java and Spring HATEOAS.

Spring HATEOAS: Hypermedia-Driven RESTful Web Services

<h2 id="introduction">Introduction</h2>
From picking your cherished pair of jeans from your wardrobe to choosing the next movie to watch with your partner, human life is filled with searching for things.
While in day-to-day life, humans usually search between a few, if not a dozen, items. Computers have to deal with searching through data of comparatively massive amounts in terms of their size and quantity.
This warrants a computer's need to have an efficient method to search inside its arrays and collections as efficiently as possible.
Being able to find information amidst a collection is one of the most basic functional points of an application.
<h2 id="binarysearch">Binary Search</h2>
Binary Search (sometimes known as Logarithmic Search) is a widely popular algorithm to search a sorted array for the position of a given element.
It works on a divide and conquer basis by comparing the target element with the middle element of the array. In case a match is found - its position is returned, otherwise if the target element is smaller than the middle element, it can't be on the right side of the middle element.
Therefore, the right half of the array (including middle element) is discarded and the search is continued on the left half using the same approach.
Similarly in case the target element is larger than the middle element, it cannot be on a place preceding the middle of the array. Therefore, the left half of the array is discarded and the search is continued on the right half.
<blockquote>
This is repeated until a match is found.
</blockquote>
We can make this assumption simply because we know that the array is sorted beforehand. If it weren't sorted, we couldn't implement Binary Search.
Here's a visual representation of how Binary Search works:
<img src="https://stackabuse.s3.amazonaws.com/media/binary-search-in-java-1.gif" alt="binary search">
<h2 id="implementation">Implementation</h2>
Since we have a repeating step (checking for the middle element and discarding one half of the array), we can implement the algorithm using two approaches - an iterative approach and a recursive approach.
As usual, there's no clear winner between these two and you can choose to use any one of these based on your personal preference.
<h3 id="iterative">Iterative</h3>
Let's start off with the iterative implementation:
<pre><code class="hljs">public static int iterativeSearch(int[] arrayToSearch, int element) {
 int lowIndex = 0;
 int highIndex = arrayToSearch.length-1;

 // Holds the position in array for given element
 // Initial negative integer set to be returned if no match was found on array
 int elementPos = -1;

 // If lowIndex less than highIndex, there&#x27;s still elements in the array
 while (lowIndex &lt;= highIndex) {
 int midIndex = (lowIndex + highIndex) / 2;
 if (element == arrayToSearch[midIndex]) {
 elementPos = midIndex;
 break;
 } else if (element &lt; arrayToSearch[midIndex]) {
 highIndex = midIndex-1;
 } else if (element &gt; arrayToSearch[midIndex]) {
 lowIndex = midIndex+1;
 }
 }
 return elementPos;
}
</code></pre>
We need to keep track of the <code>lowIndex</code> (the first index) and the <code>highIndex</code> (last index) to get the arithmetic middle for the array. The <code>elementPos</code> by default is <code>-1</code> which signifies that the element hasn't been found.
If it hasn't, we simply return this position. If it has, we adjust the <code>elementPos</code> to reflect the location in the array.
Then, through a <code>while</code> loop, we check if the middle element is the one we're searching for. If not, we adjust the <code>lowIndex</code> and <code>highIndex</code> to disregard the half of the array that the target element isn't in.
<h3 id="recursive">Recursive</h3>
The recursive implementation is fairly straightforward too, but we simply call the method recursively until the element has been found:
<pre><code class="hljs">public static int recursiveSearch(int[] arrayToSearch, int element) {
 return recursiveSearch(arrayToSearch, element, 0, arrayToSearch.length-1);
}

private static int recursiveSearch(int[] arrayToSearch, int element, int lowIndex, int highIndex) {
 // If lowIndex surpasses highIndex, the element has not been found
 if (lowIndex &gt; highIndex) return -1;

 // Default assumption is that the element is not found
 int elementPos = -1;

 int midIndex = (lowIndex + highIndex) / 2;

 if (element == arrayToSearch[midIndex]) {
 elementPos = midIndex;
 } else if (element &lt; arrayToSearch[midIndex]) {
 recursiveSearch(arrayToSearch, element, lowIndex, midIndex-1);
 } else if (element &gt; arrayToSearch[midIndex]) {
 recursiveSearch(arrayToSearch, element, midIndex+1, highIndex);
 }
 return elementPos;
}
</code></pre>
<h2 id="benchmarkingbinarysearch">Benchmarking Binary Search</h2>
To analyze how efficiently Binary Search algorithm works with given integer datasets, let's run the code against integer arrays of varied sizes and observe the runtimes it takes for a binary search to find a given number, expressed in nanoseconds:
<table class="table table-striped">
 <tr>
 <th>Array Size</th>
 <th>1st run (ns)</th>
 <th>2nd run (ns)</th>
 <th>3rd run (ns)</th>
 <th>Average (ns)</th>
 </tr>
 <tr>
 <td>10</td>
 <td>568,500</td>
 <td>755,000</td>
 <td>644,700</td>
 <td>656,066</td>
 </tr>
 <tr>
 <td>100</td>
 <td>846,100</td>
 <td>713,000</td>
 <td>724,100</td>
 <td>761,066</td>
 </tr>
 <tr>
 <td>1000</td>
 <td>1,323,600</td>
 <td>942,900</td>
 <td>735,800</td>
 <td>1,000,766</td>
 </tr>
</table>
<h2 id="bigoanalysis">Big-O Analysis</h2>
On each of its search iterations, Binary Search halves the set of items it searches. This leads the Binary Search algorithm to retain a worst case efficiency of logarithmic time. In <a target="_blank" href="/big-o-notation-and-algorithm-analysis-with-python-examples/">Big-O Notation terms</a>, an O(log n) complexity.
More so, in case the target element was found in the very middle of the array on the first go, the operation would have completed in linear time. From that we can deduce that Binary Search has a best case efficiency of O(1).
Therefore, conclusively Binary Search algorithm has an average performance of O(log n) .
It's also critical to mention that although the algorithm is greatly effective for searching arrays, its logic requires the searched array to be sorted beforehand.
In case you plan to use the algorithm on an unsorted array, you would have to sort it first - causing an increased complexity. In this case even a typical linear search would typically dominate Binary Search with its O(n) complexity.
<h2 id="conclusion">Conclusion</h2>
Since first being mentioned way back in 1946 by <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/John_Mauchly">John Mauchly</a>, Binary Search has been preserved to this date as an easy-to-understand and highly efficient algorithm for searching sorted arrays for positions of its target elements.
It works on a divide and conquer basis by comparing the target element with the middle element of the array. In this article, we've implemented both the Iterative and Recursive approaches and benchmarked the algorithm with three different sets of integers.
Additionally, we've done a quick Big-O Analysis to prove the efficiency of this basic, yet effective search algorithm.

Dasun Nirmitha

Binary Search is a really simple yet effective searching algorithm. In this article, we'll implement iterative and recursive Binary Search in Java and analyze its performance.

Binary Search in Java

<h2 id="introduction">Introduction</h2>
Design patterns are a collection of programming methodologies used in day-to-day programming. They represent solutions to some commonly occurring problems in the programming industry, which have intuitive solutions.
Sooner or later, a desktop program, mobile app, or some other type of software will inevitably become complex and start exhibiting certain kinds of problems. These problems are typically related to the complexity of our codebase, non-modularity, inability to separate certain parts from each other, etc.
For this reason, design patterns have become the de facto standard in the programming industry since their initial use a few decades ago due to their ability to solve many of these problems. In this article, we will dive deeper into one of these methodologies - namely, the Factory Method Pattern.
<h2 id="creationaldesignpatterns">Creational Design Patterns</h2>
The Factory Method Pattern is one of several <a target="_blank" href="/creational-design-patterns-in-java/">Creational Design Patterns</a> we often use in Java. Their purpose is to make the process of creating objects simpler, more modular, and more scalable.
These patterns control the way we define and design the objects, as well as how we instantiate them. Some encapsulate the creation logic away from users and handles creation (<a target="_blank" href="/creational-design-patterns-in-java/#factorymethod">Factory</a> and <a target="_blank" href="/creational-design-patterns-in-java/#abstractfactory">Abstract Factory</a>), some focus on the process of building the objects themselves (<a target="_blank" href="/the-builder-design-pattern-in-java/">Builder</a>), some minimize the cost of creation (<a target="_blank" href="/creational-design-patterns-in-java/#prototype">Prototype</a>) and some control the number of instances on the whole JVM (<a target="_blank" href="/creational-design-patterns-in-java/#singleton">Singleton</a>).
Specifically, the Factory Method and Abstract Factory are very common in Java software development.
<h2 id="thefactorymethodpattern">The Factory Method Pattern</h2>
The Factory Method Pattern (also known as the Virtual Constructor or Factory Template Pattern) is a creational design pattern used in object-oriented languages.
The main idea is to define an interface or abstract class (a factory) for creating objects. Though, instead of instantiating the object, the instantiation is left to its subclasses.
Each object is created through a factory method available in the factory - which can either be an interface or an abstract class.
If the factory is an interface - the subclasses must define their own factory methods for creating objects because there is no default implementation.
If the factory is a class - the subclasses can use existing implementation or optionally override factory methods.
With the Factory Pattern, the object creation logic is hidden from the client. Instead of knowing the exact object class and instantiating it through a constructor, the responsibility of creating an object is moved away from the client.
The client can then create objects through a common interface which simplifies the process.
This approach separates the object creation from the implementation, which promotes loose coupling and thus easier maintenance and upgrades.
<h2 id="motivation">Motivation</h2>
After some theoretical introduction, let's see the Factory Pattern in practice.
Imagine we're trying to build our own spaceship. Since this is a simplified example, we'll also simplify the construction and say that our spaceship consists of a hull, an <code>Engine</code>, and a satellite <code>Dish</code>:
<pre><code class="hljs">public class SpaceshipHangar {
 public Spaceship createSpaceship() {
 Spaceship ship = new Spaceship();
 Engine engine = new SublightEngine();
 Dish dish = new RoundDish();

 ship.setEngine(engine);
 ship.setDish(dish);

 return ship;
 }
}
</code></pre>
Note: <code>SublightEngine</code> and <code>RoundDish</code> are subclasses of <code>Engine</code> and <code>Dish</code>, respectively.
Now imagine that you showed your new spaceship to a friend, and suddenly they want a spaceship of their own too. But instead of the <code>SublightEngine</code> they want to put a <code>HyperdriveEngine</code>, and instead of the <code>RoundDish</code> they want to put a <code>SquareDish</code>:
<pre><code class="hljs">public class SpaceshipHangar {
 public Spaceship createSpaceship() {
 Spaceship ship = new Spaceship();
 Engine engine = new HyperdriveEngine();
 Dish dish = new SquareDish();

 ship.setEngine(engine);
 ship.setDish(dish);

 return ship;
 }
}
</code></pre>
Since the instantiations are hard-coded, you could either create a duplicate of your original method or change its code.
If you duplicate the method each time someone else wants to make a slight modification to the ship, this quickly becomes a problem because you will have lots of almost identical methods with minimal difference.
If you change the original code, then the method itself looses the point because it needs to be rewritten every time someone wants to make a small change to the ship.
This goes on as you add more related variations of a logical collection - all spaceships for instance.
<h2 id="implementation">Implementation</h2>
To solve this problem, we can create a Factory of spaceships and leave the specifics (which engine or dish is used) to the subclasses to define.
Instead of hard-coding object creation into the <code>createSpaceship()</code> method with <code>new</code> operators, we'll create a <code>Spaceship</code> interface and implement it through a couple of different concrete classes.
Then, using a <code>SpaceshipFactory</code> as our communication point with these, we'll instantiate objects of <code>Spaceship</code> type, though, implemented as concrete classes. This logic will stay hidden from the end user, as we'll be specifying which implementation we want through the argument passed to the <code>SpaceshipFactory</code> method used for instantiation.
Let's start off with the <code>Spaceship</code> interface:
<pre><code class="hljs">public interface Spaceship {
 void setEngine(Engine engine);
 void setDish(Dish dish);
}
</code></pre>
Since we're working with the <code>Engine</code> and <code>Dish</code> classes, let's define them real quick:
<pre><code class="hljs">public class Engine {
 private String model;

 public Engine(String model) {
 this.model = model;
 }

 // Getters and Setters
}

public class Dish {
 private String model;

 public Dish(String model) {
 this.model = model;
 }

 // Getters and Setters
}
</code></pre>
And now, let's implement the interface through two concrete implementations, starting with the <code>SpaceshipMk1</code>:
<pre><code class="hljs">public class SpaceshipMk1 implements Spaceship {
 private Engine engine;
 private Dish dish;

 public SpaceshipMk1(Engine engine, Dish dish) {
 this.engine = engine;
 System.out.println(&quot;Powering up the Mk.1 Raptor Engine&quot;);

 this.dish = dish;
 System.out.println(&quot;Activating the Mk.1 Satellite Dish&quot;);
 }

 @Override
 public void setEngine(Engine engine) {
 this.engine = engine;
 }

 @Override
 public void setDish(Dish dish) {
 this.dish = dish;
 }
}
</code></pre>
And the <code>SpaceshipMk2</code>:
<pre><code class="hljs">public class SpaceshipMk2 implements Spaceship {
 private Engine engine;
 private Dish dish;

 public SpaceshipMk2(Engine engine, Dish dish) {
 this.engine = engine;
 System.out.println(&quot;Powering up the Mk.2 Raptor Engine&quot;);

 this.dish = dish;
 System.out.println(&quot;Activating the Mk.2 Satellite Dish&quot;);
 }

 @Override
 public void setEngine(Engine engine) {
 this.engine = engine;
 }

 @Override
 public void setDish(Dish dish) {
 this.dish = dish;
 }
}
</code></pre>
Now, instead of simply instantiating these as we typically would, let's create a <code>SpaceshipFactory</code> for them:
<pre><code class="hljs">public class SpaceshipFactory {
 public Spaceship getSpaceship(Engine engine, Dish dish) {
 if (engine.getModel().equals(&quot;Mk.2&quot;) &amp;&amp; dish.getModel().equals(&quot;Mk.2&quot;)) {
 return new SpaceshipMk2(engine, dish);
 } else if (engine.getModel().equals(&quot;Mk.1&quot;) &amp;&amp; dish.getModel().equals(&quot;Mk.1&quot;)) {
 return new SpaceshipMk1(engine, dish);
 } else {
 System.out.println(&quot;Incompatible models of engine and satellite dish.&quot;);
 }
 return null;
 }
}
</code></pre>
The factory typically has a single method called <code>getTypeName()</code> with the parameters you'd wish to pass. Then, through as many <code>if</code> statements required, we check which exact class should be used to serve the call.
And with this factory in place, when we'd like to instantiate any of these two spaceship classes, we use the factory:
<pre><code class="hljs">SpaceshipFactory factory = new SpaceshipFactory();

Engine engineMk1 = new Engine(&quot;Mk.1&quot;);
Dish dishMk1 = new Dish(&quot;Mk.1&quot;);

Engine engineMk2 = new Engine(&quot;Mk.2&quot;);
Dish dishMk2 = new Dish(&quot;Mk.2&quot;);

Spaceship spaceshipMk1 = factory.getSpaceship(engineMk1, dishMk1);
Spaceship spaceshipMk2 = factory.getSpaceship(engineMk2, dishMk2);
Spaceship spaceshipMkHybrid = factory.getSpaceship(engineMk1, dishMk2);
</code></pre>
Here, instead of using the <code>new</code> operator to instantiate either spaceship, we call upon the common interface <code>Spaceship</code> and using the factory construct/instantiate the objects. Running this code would yield:
<pre><code class="hljs">Powering up the Mk.1 Raptor Engine
Activating the Mk.1 Satellite Dish
Powering up the Mk.2 Raptor Engine
Activating the Mk.2 Satellite Dish
Incompatible models of engine and satellite dish.
</code></pre>
Note: Ideally, we'd also have factories for engines and dishes, especially if we have derived types such as <code>HyperdriveEngine</code> and <code>SquareDish</code>. Having multiple factories would end up with multiple <code>new</code> keywords - which is against what the Factory Method stands for.
<blockquote>
What is the fix then? Haven't we only made a roundabout and ended up with the same problem?
</blockquote>
That's where the <a target="_blank" href="/creational-design-patterns-in-java/#abstractfactory">Abstract Factory Design Pattern</a> jumps in. It's like a factory of factories which would, using the same approach, instantiate all spaceship-related factories with only a single <code>new</code> call at the start.
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>Allows loosely-coupled code, making changes less disruptive</li>
<li>Easy to unit test and mock as code is decoupled</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>Makes code less readable since all object creation code is behind a layer of abstraction</li>
<li>If used with the Abstract Factory Pattern (a factory of factories), the code quickly becomes cumbersome but functional</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Factory Method and other design patterns are tested and proven-to-work techniques. Regardless if used in personal projects or very large industry codebases. They offer clever solutions to some common problems and encourage developers and entire teams to do architecture design first, programming second. This almost always leads to a higher-quality code rather than jumping right into programming.
It's a misconception that design patterns are holy solutions to all problems. Design patterns are techniques to help mitigate some common problems, invented by people who have solved these problems numerous times.

Luka Čupić

The Factory Method Pattern is a creational design pattern used in OO languages. In this article, we'll be diving into the theory and implementation of The Factory Method/Template. 

Factory Method Design Pattern in Java

Software development is inherently full of challenges. This ranges from architecting your software, maintaining it, fixing bugs, deploying, and the list goes on. When starting out, you'd think that the easy part would be to share you code with others. After all, they're just text files, right? This may not be too difficult with extremely simple programs that have only one developer, but issues compound as the number of collaborators grows, as well as the size of the project.
For example, how do you share updates to a codebase with another developer working on the same project? Would you constantly email changed files back and forth? What if you're working on the same files simultaneously? How do you detect and merge these changes?
This was exactly why <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Version_control">version control</a> systems (VCS) were created, to allow simultaneous collaboration, sharing, and merging of changes to a project.
While there are a number of version control systems out there, like <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Concurrent_Versions_System">CVS</a>, <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Apache_Subversion">SVN</a>, <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Mercurial">Mercurial</a>, etc., <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Git">Git</a> has emerged as the most popular system by far.
Git, a distributed version control, was released in 2005 and created by Linus Torvalds, who is also the creator of Linux. It is so popular that it's at the core of multiple multi-billion dollar companies, like GitHub, GitLab, and Atlassian's BitBucket, which host public and private Git repositories.
With Git being so popular among developers, it's an essential skill to learn. In this article, we'll cover the basics of what Git is, how it works, and where you can find resources to learn more.
<h2 id="whatisgit">What is Git?</h2>
Various VCSs have different structures. Take SVN for example, which is a centralized repository, meaning it has one &quot;master&quot; repository. This differs from Git, which is decentralized and has no master. In practice, a single hosted repository is usually shared among a team, but projects can be more easily forked and not have any dependency on the original repo.
This is a big reason for Git's popularity, it isn't inherently constrained by its architecture, and it has some features (like branching and merging) that are &quot;first class citizens&quot;, as opposed to being an after-thought like in other VCSs.
You typically interact with Git through the command line tool, appropriately named <code>git</code>. Although, there are now quite a few GUI tools out there (i.e. <a rel="nofollow noopener" target="_blank" href="https://desktop.github.com/">GitHub Desktop</a>, <a rel="nofollow noopener" target="_blank" href="https://www.sourcetreeapp.com/">SourceTree</a>, and <a rel="nofollow noopener" target="_blank" href="https://www.gitkraken.com/">GitKraken</a>) that helps you use some of the more common features, like committing, branching, and merging. With Git being a bit complex to use, some beginners opt to start off with these GUI tools. And while they can be extremely useful and help you be productive, I'd recommend you at least become comfortable with the command line version as well to deepen your understanding.
Git works by tracking what changed in each file in a project, who made that change, and why. Internally, this is done in a graph structure, and each new commit creates a new node in the graph.
<img alt="git master tree" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-1.svg">
A branch in Git creates a new node off of the main tree (the yellow node in the image below) in which you can make any change you want without affecting the main codebase. This way other developers can continue to work on their new features in separate branches while you work on yours, all without disrupting the progress of one another.
<img alt="git tree with branch" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-2.svg">
Once you've finished the updates on your branch, you can then merge it back in to the master branch. When this is done, everyone else working in the same repository will then pull in your changes to their local systems. By making changes in this way, you avoid disrupting the main branch.
<img alt="git tree with merged branch" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-3.svg">
<h2 id="gitbasics">Git Basics</h2>
Git can be complicated, which is probably why you're here. Because of that, we'll just cover a few of the main features of the command-line tool here, and provide resources if you want to dive deeper in to each function.
First of all, to get started you'll want to install <code>git</code> on your system. Most Mac and Linux distributions come with Git pre-installed, but just in case yours doesn't, here is how to do it:
MacOS
Install Git with either the <a rel="nofollow noopener" target="_blank" href="https://www.ics.uci.edu/~pattis/common/handouts/macmingweclipse/allexperimental/macxcodecommandlinetools.html">Xcode Command Line Tools</a> or using the installer from <a rel="nofollow noopener" target="_blank" href="https://git-scm.com/download/mac">this link</a>.
Debian-based Distros
<pre><code class="hljs">$ sudo apt install git-all
</code></pre>
RPM-based Distros
<pre><code class="hljs">$ sudo dnf install git-all
</code></pre>
Windows
<a rel="nofollow noopener" target="_blank" href="https://git-scm.com/download/win">Download the installer</a> for Git for Windows and follow the instructions.
Once installed, you can create a new repository by entering the directory of your project (a Node.js project in our example) and using the <code>init</code> command:
<pre><code class="hljs">$ cd my-project
$ git init
</code></pre>
This will initialize Git, but before anything is tracked, you need to explicitly add your project files to the repo:
<pre><code class="hljs">$ git add package.json config.json
</code></pre>
Git makes this process a bit easier and allows wildcards to select files in bulk:
<pre><code class="hljs">$ git add src/*.js
</code></pre>
Now, our files aren't yet committed to Git, they're just staged. We can view staged files using the <code>status</code> command:
<pre><code class="hljs">$ git status
On branch master

Initial commit

Changes to be committed:
 (use &quot;git rm --cached &lt;file&gt;...&quot; to unstage)

 new file: config.json
 new file: package.json
 new file: src/index.js
 new file: src/api.js
</code></pre>
Now we're ready to commit our changes to the repository using the <code>commit</code> command:
<pre><code class="hljs">$ git commit -am &quot;Initial commit&quot;
</code></pre>
The <code>-a</code> flag tells Git to commit all staged files, and the <code>-m</code> flag let's us add a commit message via the command line. If this is omitted then your default text editor will open, allowing you to enter the message there. This message is used to describe what changes took place.
From here you can do a lot of things, like, for example, tagging the commit with a version number, creating a branch to work on a new feature, or reverting back to an older commit if you made a mistake.
To complete our short example, let's push our changes to a remote repository, allowing other developers to get the changes. For this to work, we first need to create a repository on GitHub account, which we can then use to push to:
<pre><code class="hljs">$ git remote add origin https://github.com/scottwrobinson/my-project.git
$ git push origin master
</code></pre>
The first command above tells Git the location of our remote repository, which we've named &quot;origin&quot;. In the second command, we tell Git to push our code from the master branch to our origin server. Depending on how you've set up your GitHub account, you may be required to enter a password or specify an SSH key.
While it's helpful to see the basics of using a complicated tool like Git, there is still a lot to learn and this example just scratches the surface of what Git is capable of. Many of these features are out of the scope of this article, so we've provided a number of resources that dive in to more detail on more specific Git topics.
<h2 id="resourcestolearnmore">Resources to Learn More</h2>
<ul>
<li><a target="_blank" href="/git-create-a-new-repository/">Create a Git Repository</a></li>
<li><a target="_blank" href="/git-clone-a-repository/">Clone a Repository</a></li>
<li><a target="_blank" href="/git-create-a-new-branch/">Create a New Branch</a></li>
<li><a target="_blank" href="/git-checkout-a-remote-branch/">Checkout a Remote Branch</a></li>
<li><a target="_blank" href="/git-add-all-files-to-a-repo/">Add All Files to a Repo</a></li>
<li><a target="_blank" href="/git-merge-branch-into-master/">Merge Branch into Master</a></li>
<li><a target="_blank" href="/git-delete-branch-locally-and-remotely/">Delete Branch Locally and Remotely</a></li>
<li><a target="_blank" href="/git-push-local-branch-and-track-it/">Push Local Branch and Track it</a></li>
</ul>
For even more articles on the subject, check out all of our <a target="_blank" href="/tag/git/">Git articles</a>.

Scott Robinson

An introduction to Git, which covers the basics of what Git is, how it works, and where you can find resources to learn more.

Git: An Introduction for Beginners

Tom Kadwill

Sequelize is a popular and stable ORM used with Node.js. In this article, we'll be setting up a note-management app that performs CRUD operations against the database using Sequelize.

Using Sequelize ORM with Node.js and Express

As many programmers have found out the hard way, adding documentation is extremely important in being able to easily make modifications to your code, fix issues, pass off to others, etc. Just because your code makes sense now doesn't mean it'll make sense to you in 6 months (or even a week, really). You're probably used to documenting your actual code, but this same practice should also be followed with your version control commits as well.
In Git, there are a few ways to document your changes, but we'll be focusing mostly on how to do it for individual commits in this short article.
When viewing a repository on GitHub, you have probably noticed the messages next to a file or folder:
<img src="https://stackabuse.s3.amazonaws.com/media/git-adding-commit-message-1.png" alt="git commit messages in github">
These messages are typically added to the repository at the time in which you make the commit, although you can retroactively add commit messages as well.
In GitHub, the message next to the file or folder is from the last commit in which that file/folder changed. So these are not all necessarily from the last commit. Otherwise it wouldn't be very useful if GitHub displayed the same commit message from the last commit for all files.
In order to add this message, you need to specify the <code>-m</code> flag when executing <code>git commit</code>. Your message should immediately follow the flag and be wrapped in quotation marks. An example of this looks like this:
<pre><code class="hljs">$ git commit index.js -m &quot;Fixed world-ending bug (#281)&quot;
</code></pre>
<h2 id="multilinemessages">Multi-Line Messages</h2>
You can't always describe a complex change with a short, single-line comment. An interesting feature of the <code>-m</code> flag is that you can add multiple paragraphs to your message by using the <code>-m</code> flag multiple times in the same <code>commit</code> command:
<pre><code class="hljs">$ git commit index.js -m &quot;My Changes&quot; -m &quot;- Fixed a critical bug&quot; -m &quot;- Probably added more bugs&quot;
</code></pre>
These multiple messages will then look like this in the resulting commit:
<pre><code class="hljs">My Changes
- Fixed a critical bug
- Probably added more bugs
</code></pre>
Another option, which depends on the shell you're using, is to just enter a single or double quote and press <kbd>Enter</kbd>, without closing the quote. This works well in Bash, which doesn't enter the command until you've closed the quote:
<pre><code class="hljs">$ git commit index.js -m &quot;My Changes
- Fixed a critical bug
- Probably added more bugs
&quot;
</code></pre>
And finally, you don't actually need to use the <code>-m</code> flag at all. If you omit this flag then Git will automatically open a text editor for you to enter the commit message.

Adding documentation is important in being able to easily make modifications to your code, fix issues, pass it off to others, etc. In Git, there are a few ways to document your changes.

Git: Adding a Commit Message

<h2 id="introduction">Introduction</h2>
Checking for substrings within a String is a fairly common task in programming. For example, sometimes we wish to break a String if it contains a delimiter at a point. Other times, we wish to alter the flow if a String contains (or lacks) a certain substring, which could be a command.
There's a couple of ways to do this in Java, and most of them are what you'd expect to see in other programming languages as well. One approach that is unique to Java, however, is the use of a <code>Pattern</code> class, which we'll cover later in the article.
Alternatively, you can use Apache Commons and the helper class <code>StringUtils</code>, which offers many derived methods from the core methods for this purpose.
<h2 id="corejava">Core Java</h2>
<h3 id="stringcontains">String.contains()</h3>
The first and foremost way to check for the presence of a substring is the <code>.contains()</code> method. It's provided by the <code>String</code> class itself and is very efficient.
The method accepts a <code>CharSequence</code> and returns <code>true</code> if the sequence is present in the String we call the method on:
<pre><code class="hljs">String string = &quot;Java&quot;;
String substring = &quot;va&quot;;

System.out.println(string.contains(substring));
</code></pre>
Running this would yield:
<pre><code class="hljs">true
</code></pre>
Note: The <code>.contains()</code> method is case sensitive. If we tried looking for <code>&quot;Va&quot;</code> in our <code>string</code>, the result would be <code>false</code>.
Oftentimes, to avoid this issue, since we're not looking for case sensitivity, you'd match the case of both Strings before checking:
<pre><code class="hljs">System.out.println(string.toLowerCase().contains(substring.toLowerCase()));
// OR
System.out.println(string.toUpperCase().contains(substring.toUpperCase()));
</code></pre>
<h3 id="stringindexof">String.indexOf()</h3>
The <code>.indexOf()</code> method is a bit more crude than the <code>.contains()</code> method, but it's nevertheless the underlying mechanism that enables the <code>.contains()</code> method to work.
It returns the index of the first occurrence of a substring within a String, and offers a few constructors to choose from:
<pre><code class="hljs">indexOf(int ch)
indexOf(int ch, int fromIndex)
indexOf(String str)
indexOf(String str, int fromIndex)
</code></pre>
We can either search for a single character with or without an offset or search for a String with or without an offset.
The method will return the index of the first occurrence if present, and <code>-1</code> if not:
<pre><code class="hljs">String string = &quot;Lorem ipsum dolor sit amet.&quot;;

// You can also use unicode for characters
System.out.println(string.indexOf(&#x27;i&#x27;));
System.out.println(string.indexOf(&#x27;i&#x27;, 8));
System.out.println(string.indexOf(&quot;dolor&quot;));
System.out.println(string.indexOf(&quot;Lorem&quot;, 10));
</code></pre>
Running this code will yield:
<pre><code class="hljs">6
19
12
-1
</code></pre>
<ul>
<li>The first occurrence of <code>i</code> is in the word <code>ipsum</code>, 6 places from the start of the character sequence.</li>
<li>The first occurrence of <code>i</code> with an offset of <code>8</code> (i.e. the search starts at <code>s</code> of <code>ipsum</code>) is in the <code>sit</code> word, 19 places from the start.</li>
<li>The first occurrence of the String <code>dolor</code> is 12 places from the start.</li>
<li>And finally, there is no occurrence of <code>Lorem</code> with an offset of <code>10</code>.</li>
</ul>
Ultimately, the <code>.contains()</code> method calls upon the <code>.indexOf()</code> method to work. That makes <code>.indexOf()</code> inherently even more efficient than the counterpart (albeit a very small amount) - though it does have a slightly different use-case.
<h3 id="stringlastindexof">String.lastIndexOf()</h3>
As opposed to the <code>.indexOf()</code> method, which returns the first occurrence, the <code>.lastIndexOf()</code> method returns the index of the last occurrence of a character or String, with or without an offset:
<pre><code class="hljs">String string = &quot;Lorem ipsum dolor sit amet.&quot;;

// You can also use unicode for characters
System.out.println(string.lastIndexOf(&#x27;i&#x27;));
System.out.println(string.lastIndexOf(&#x27;i&#x27;, 8));
System.out.println(string.lastIndexOf(&quot;dolor&quot;));
System.out.println(string.lastIndexOf(&quot;Lorem&quot;, 10));
</code></pre>
Running this code will yield:
<pre><code class="hljs">19
6
12
0
</code></pre>
Some may be a bit surprised by the results and say:
<blockquote>
<code>lastIndexOf('i', 8)</code> should've returned <code>19</code> as that's the last occurrence of the character after the 8th character in the String
</blockquote>
What's worth noting is that when running the <code>.lastIndexOf()</code> method, the character sequence is reversed. The counting starts at the final character and goes towards the first.
That being said - yes. The expected output is <code>6</code>, as that's the last occurrence of the character after skipping 8 elements from the end of the sequence.
<h3 id="patternwithregexandmatcher">Pattern with Regex and Matcher</h3>
The <code>Pattern</code> class is essentially a compiled representation of a <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Regular_expression">regular expression</a>. It's used alongside the <code>Matcher</code> class to match character sequences.
This class works by compiling a pattern first. We then assign another pattern to a <code>Matcher</code> instance, which uses the <code>.find()</code> method to compare the assigned and compiled patterns.
If they match, the <code>.find()</code> method results in <code>true</code>. If the patterns don't match, the method results in <code>false</code>.
<pre><code class="hljs">Pattern pattern = Pattern.compile(&quot;.*&quot; + &quot;some&quot; + &quot;.*&quot;);

Matcher matcher = pattern.matcher(&quot;Here is some pattern!&quot;);
System.out.println(matcher.find());
</code></pre>
This would yield:
<pre><code class="hljs">true
</code></pre>
<h2 id="apachecommons">Apache Commons</h2>
Due to its usefulness and prevalence in Java, many projects have <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> included in the classpath. It's a great library with many useful features often used in production - and checking for substrings is no exception.
Apache Commons offers the <code>StringUtils</code> class with many helper methods for String manipulation, null-checking, etc. For this task, we can utilize any of the <code>.contains()</code>, <code>.indexOf()</code>, <code>.lastIndexOf()</code>, or <code>.containsIgnoreCase()</code> methods.
If not, including it is as easy as adding a dependency to your <code>pom.xml</code> file if you're using Maven:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;{version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or by adding it through Gradle:
<pre><code class="hljs">compile group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: &#x27;{version}&#x27;
</code></pre>
<h3 id="stringutilscontains">StringUtils.contains()</h3>
The <code>.contains()</code> method is pretty straightforward and very similar to the core Java approach.
The only difference is that we don't call the method on the String we're checking (as it doesn't inherit this method), but rather pass the String we're searching in alongside the String we're searching for:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;;

System.out.println(StringUtils.contains(string, &quot;common task&quot;));
</code></pre>
Running this code will yield:
<pre><code class="hljs">true
</code></pre>
Note: This method is case-sensitive.
<h3 id="stringutilsindexof">StringUtils.indexOf()</h3>
Naturally, the <code>.indexOf()</code> method also works very similarly to the core Java approach:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;;

// Search for first occurrence of &#x27;f&#x27;
System.out.println(StringUtils.indexOf(string, &#x27;f&#x27;));

// Search for first occurrence of &#x27;f&#x27;, skipping the first 12 elements
System.out.println(StringUtils.indexOf(string, &#x27;f&#x27;, 12));

// Search for the first occurrence of the &quot;String&quot; string
System.out.println(StringUtils.indexOf(string, &quot;String&quot;));
</code></pre>
Running this code will yield:
<pre><code class="hljs">9
45
32
</code></pre>
<h3 id="stringutilsindexofany">StringUtils.indexOfAny()</h3>
The <code>.indexOfAny()</code> method accepts a vararg of characters, instead of a single one, allowing us to search for the first occurrence of any of the passed characters:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;;

// Search for first occurrence of &#x27;f&#x27; or &#x27;n&#x27;, whichever comes first
System.out.println(StringUtils.indexOfAny(string, [&#x27;f&#x27;, &#x27;n&#x27;]));

// Search for the first occurrence of &quot;String&quot; or &quot;for&quot;, whichever comes first
System.out.println(StringUtils.indexOfAny(string, &quot;String&quot;, &quot;for&quot;));
</code></pre>
Running this code will yield:
<pre><code class="hljs">6
9
</code></pre>
<h3 id="stringutilsindexofanybut">StringUtils.indexOfAnyBut()</h3>
The <code>.indexOfAnyBut()</code> method searches for the first occurrence of any character that's not in the provided set:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;;

// Search for first character outside of the provided set &#x27;C&#x27; and &#x27;h&#x27;
System.out.println(StringUtils.indexOfAny(string, [&#x27;C&#x27;, &#x27;h&#x27;]));

// Search for first character outside of the provided set &#x27;C&#x27; and &#x27;h&#x27;
System.out.println(StringUtils.indexOfAny(string, [&quot;Checking&quot;, &quot;for&quot;]));
</code></pre>
Running this code will yield:
<pre><code class="hljs">2
14
</code></pre>
<h3 id="stringutilsindexofdifference">StringUtils.indexOfDifference()</h3>
The <code>.indexOfDifference()</code> method compares two character arrays, and returns the index of the first differing character:
<pre><code class="hljs">String s1 = &quot;Hello World!&quot;
String s2 = &quot;Hello world!&quot;

System.out.println(StringUtils.indexOfDifference(s1, s2));
</code></pre>
Running this code will yield:
<pre><code class="hljs">6
</code></pre>
<h3 id="stringutilsindexofignorecase">StringUtils.indexOfIgnoreCase()</h3>
The <code>.indexOfIgnoreCase()</code> method will return the index of the first occurrence of a character in a character sequence, ignoring its case:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;

System.out.println(StringUtils.indexOf(string, &#x27;c&#x27;));
System.out.println(StringUtils.indexOfIgnoreCase(string, &#x27;c&#x27;));
</code></pre>
Running this code will yield:
<pre><code class="hljs">3
0
</code></pre>
<h3 id="stringutilslastindexof">StringUtils.lastIndexOf()</h3>
And finally, the <code>.lastIndexOf()</code> method works pretty much the same as the regular core Java method:
<pre><code class="hljs">String string = &quot;Lorem ipsum dolor sit amet.&quot;;

// You can also use unicode for characters
System.out.println(StringUtils.lastIndexOf(string, &#x27;i&#x27;));
System.out.println(StringUtils.lastIndexOf(string, &#x27;i&#x27;, 8));
System.out.println(StringUtils.lastIndexOf(string, &quot;dolor&quot;));
System.out.println(StringUtils.lastIndexOf(string, &quot;Lorem&quot;, 10));
</code></pre>
Running this code will yield:
<pre><code class="hljs">19
6
12
0
</code></pre>
<h3 id="stringutilscontainsignorecase">StringUtils.containsIgnoreCase()</h3>
The <code>.containsIgnoreCase()</code> method checks if String contains a substring, ignoring the case:
<pre><code class="hljs">String string = &quot;Checking for substrings within a String is a fairly common task in programming.&quot;;

System.out.println(StringUtils.containsIgnoreCase(string, &quot;cOmMOn tAsK&quot;));
</code></pre>
Running this code will yield:
<pre><code class="hljs">true
</code></pre>
<h3 id="stringutilscontainsonly">StringUtils.containsOnly()</h3>
The <code>.containsOnly()</code> method checks if a character sequence contains only the specifies values.
This can be a bit misleading, so another way to put it is - it checks if the character sequence is made up of only the specified characters. It accepts either a String or a character sequence:
<pre><code class="hljs">String string = &quot;Hello World!&quot;
System.out.println(StringUtils.containsOnly(string, &#x27;HleWord!&#x27;));
System.out.println(StringUtils.containsOnly(string, &quot;wrld&quot;));
</code></pre>
Running this will yield:
<pre><code class="hljs">true
false
</code></pre>
The <code>&quot;Hello World!&quot;</code> String indeed is constructed of only the characters in the <code>'HleWord!'</code> sequence.
Note: Not all of the characters from the sequence need to be used in the <code>string</code> for the method to return true. What matters is that <code>string</code> doesn't contain a character that's not in the character sequence.
<h3 id="stringutilscontainsnone">StringUtils.containsNone()</h3>
The <code>.containsNone()</code> method checks if the String contains any of the &quot;forbidden&quot; characters from a set. If it does, <code>false</code> is returned, and vice-versa:
<pre><code class="hljs">String string = &quot;Hello World!&quot;
System.out.println(StringUtils.containsNone(string, &#x27;xmt&#x27;));
System.out.println(StringUtils.containsNone(string, &quot;wrld&quot;));
</code></pre>
Running this code yields:
<pre><code class="hljs">true
false
</code></pre>
<h3 id="stringutilscontainsany">StringUtils.containsAny()</h3>
And finally, the <code>.containsAny()</code> method returns <code>true</code> if a character sequence contains any of the passed parameters in the form of a character sequence or a String:
<pre><code class="hljs">String string = &quot;Hello World!&quot;
System.out.println(StringUtils.containsAny(string, [&#x27;h&#x27;, &#x27;m&#x27;]));
System.out.println(StringUtils.containsAny(string, &quot;hell&quot;));
</code></pre>
This code would yield:
<pre><code class="hljs">true
true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In conclusion, there are many ways to check for a substring in a String. The core Java approach will be enough in most cases, though if you need to check with more than a single condition - Apache Commons is a real time-saver.
In many cases, defining logic of your own for a method such as <code>.indexOfAnyBut()</code> would be a pain and simply redundant. Since most projects nowadays already have Apache Commons in the classpath, it's most likely that you can simply use the methods provided by the <code>StringUtils</code> class.

David Landup

Checking if a String contains a substring is a common task. In this article, we'll be exploring the core Java approach and the Apache Commons approach to solving this problem.

Java: Check if String Contains a Substring

Muhammad Junaid Khalid

The article provides a brief introduction to various image processing tasks with the help of the Python programming language. 

 Introduction to Image Processing in Python with OpenCV

<h2 id="introduction">Introduction</h2>
When writing any kind of code in Java, developers tend to work with objects more often than with primitive values (<code>int</code>, <code>boolean</code>, etc). This is because objects are at the very essence of object-oriented programming: they allow a programmer to write abstract code in a clean and structured manner.
Furthermore, every object in Java can either contain a value or not. If it does, its value is stored on the heap and the variable which we are using has a reference to that object. If the object contains no value, this defaults to <code>null</code> - a special placeholder denoting the absence of a value.
The fact that each object can become <code>null</code>, combined with the natural tendency to use objects instead of primitives, means that some arbitrary piece of code might (and often-times will) result in an unexpected <code>NullPointerException</code>.
Before the <code>Optional</code> class was introduced in Java 8, these kind of <code>NullPointerException</code> errors were much more common in everyday life of a Java programmer.
In the following sections, we will dive deeper into explaining <code>Optional</code> and seeing how it can be used to overcome some of the common problems concerning null values.
<h2 id="theoptionalclass">The Optional Class</h2>
An <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html">Optional</a> is essentially a container. It is designed either to store a value or to be &quot;empty&quot; if the value is non-existent - a replacement for the <code>null</code> value. As we will see in some later examples, this replacement is crucial as it allows implicit null-checking for every object represented as an <code>Optional</code>.
This means that explicit null-checking is no longer needed from a programmer's point of view - it becomes enforced by the language itself.
<h2 id="creatingoptionals">Creating Optionals</h2>
Let's take a look at how easy it is to create instances of <code>Optional</code> and wrap objects that we already have in our applications.
We'll be using our custom class for this, the <code>Spaceship</code> class:
<pre><code class="hljs">public class Spaceship {
 private Engine engine;
 private String pilot;

 // Constructor, Getters and Setters
}
</code></pre>
And our <code>Engine</code> looks like:
<pre><code class="hljs">public class Engine {
 private VelocityMonitor monitor;

 // Constructor, Getters and Setters
}
</code></pre>
And furthermore, we've got the <code>VelocityMonitor</code> class:
<pre><code class="hljs">public class VelocityMonitor {
 private int speed;

 // Constructor, Getters and Setters
}
</code></pre>
These classes are arbitrary and only serve to make a point, there's no real implementation behind them.
<h3 id="of">of()</h3>
The first approach to creating <code>Optional</code>s is using the <code>.of()</code> method, passing a reference to a non-null object:
<pre><code class="hljs">Spaceship falcon = new Spaceship();
Optional&lt;Spaceship&gt; optionalFalcon = Optional.of(falcon);
</code></pre>
If the <code>falcon</code> was <code>null</code>, the method <code>.of()</code> would throw a <code>NullPointerException</code>.
Without <code>Optional</code>, trying to access any of the fields or methods of <code>falcon</code> (assuming it's <code>null</code>), without performing a null-check would result in a crash of the program.
With <code>Optional</code>, the <code>.of()</code> method notices the <code>null</code> value and throws the <code>NullPointerException</code> immediately - potentially also crashing the program.
<blockquote>
If the program crashes in both approaches, why even bother using <code>Optional</code>?
</blockquote>
The program wouldn't crash somewhere deeper in the code (when accessing <code>falcon</code>) but at the very first use (initialization) of a <code>null</code> object, minimizing potential damage.
<h3 id="ofnullable">ofNullable()</h3>
If <code>falcon</code> is allowed to be a <code>null</code>, instead of the <code>.of()</code> method, we'd use the <code>.ofNullable()</code> method. They perform the same if the value is non-<code>null</code>. The difference is obvious when the reference points to <code>null</code> in which case - the <code>.ofNullable()</code> method is perfectly contempt with this piece of code:
<pre><code class="hljs">Spaceship falcon = null;
Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(falcon);
</code></pre>
<h3 id="empty">empty()</h3>
And finally, instead of wrapping an existing reference variable (<code>null</code> or non-<code>null</code>), we can create a <code>null</code> value in the context of an <code>Optional</code>. It's kind of like an empty container which returns an empty instance of <code>Optional</code>:
<pre><code class="hljs">Optional&lt;Spaceship&gt; emptyFalcon = Optional.empty();
</code></pre>
<h2 id="checkingforvalues">Checking for Values</h2>
After creating <code>Optional</code>s and packing information in them, it's only natural that we'd want to access them.
Before accessing though, we should check if there are any values, or if the <code>Optional</code>s are empty.
<h3 id="ispresent">isPresent()</h3>
Since catching exceptions is a demanding operation, it would be better to use one of the API methods to check if the value exists before trying to access it - and alter the flow if it doesn't.
If it does, then <code>.get()</code> method can be used to access the value. Though, more on that method in latter sections.
To check if the value is present inside an <code>Optional</code>, we use the <code>.isPresent()</code> method. This is essentially a replacement for the <code>null</code>-check of the old days:
<pre><code class="hljs">// Without Optional
Spaceship falcon = hangar.getFalcon();
if (falcon != null) {
 System.out.println(falcon.get());
} else {
 System.out.printn(&quot;The Millennium Falcon is out and about!&quot;);
}

// With Optional
Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (optionalFalcon.isPresent()) {
 System.out.println(falcon.get());
} else {
 System.out.println(&quot;The Millennium Falcon is out and about!&quot;);
}
</code></pre>
Since the <code>falcon</code> can also not be in the hangar, we can also expect a <code>null</code> value, thus <code>.ofNullable()</code> is used.
<h3 id="ifpresent">ifPresent()</h3>
To make things even easier, <code>Optional</code> also contains a conditional method which bypasses the presence check entirely:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
optionalFalcon.ifPresent(System.out::println);
</code></pre>
If a value is present, the contents are printed through a <a target="_blank" href="/method-references-in-java-8">Method Reference</a>. If there's no value in the container, nothing happens. You still might want to use the previous approach if you'd like to define an <code>else {}</code> statement, though.
This reflects what we mentioned earlier when we said that <code>null</code>-checks with <code>Optional</code> are implicit and enforced by the type-system.
<h3 id="isempty">isEmpty()</h3>
Another way to check for a value is to use <code>.isEmpty()</code>. Essentially, calling <code>Optional.isEmpty()</code> is the same as calling <code>!Optional.isPresent()</code>. There's no particular difference that exists:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (optionalFalcon.isEmpty()) {
 System.out.println(&quot;Please check if the Millennium Falcon has returned in 5 minutes.&quot;);
} else {
 optionalFalcon.doSomething();
}
</code></pre>
<h3 id="nestednullchecks">Nested Null-Checks</h3>
Our <code>Spaceship</code> class, as defined earlier, has an attribute <code>Engine</code>, which has an attribute <code>VelocityMonitor</code>.
Suppose now that we want to access the velocity monitor object and obtain the current velocity of the spaceship, taking into consideration that all these values could potentially be <code>null</code>.
Obtaining the velocity might look something like this:
<pre><code class="hljs">if (falcon != null) {
 Engine engine = falcon.getEngine();
 if (engine != null) {
 VelocityMonitor monitor = engine.getVelocityMonitor();
 if (monitor != null) {
 Velocity velocity = monitor.getVelocity();
 System.out.println(velocity);
 }
 }
}
</code></pre>
The above example shows how tedious it is to perform such checks, not to mention the amount of boilerplate code needed to make the checks possible in the first place.
An alternative solution using <code>Optional</code> would be:
<pre><code class="hljs">Velocity velocity = falcon
 .flatMap(Spaceship::getEngine)
 .flatMap(Engine::getVelocityMonitor)
 .map(VelocityMonitor::getVelocity);
</code></pre>
Note: Not sure what's going on above? Check out the <a href="#exampleexplanation">explanation below</a> for the details.
Using this kind of approach, no explicit checks are needed. If any of the objects contain an empty <code>Optional</code>, the end result will also be an empty <code>Optional</code>.
To make things work like this, we need to modify our existing definitions of the <code>Spaceship</code> and <code>Engine</code> classes:
<pre><code class="hljs">public class Spaceship {
 private Optional&lt;Engine&gt; engine;
 private String pilot;

 // Constructor, Getters and Setters
}
</code></pre>
<pre><code class="hljs">public class Engine {
 private Optional&lt;VelocityMonitor&gt; monitor;

 // Constructor, Getters and Setters
}
</code></pre>
What we have changed are the attribute definitions: they are now wrapped inside <code>Optional</code> objects to make this kind of alternative solution possible.
This might seem a bit tedious at first but if planned from the beginning, it takes almost the same amount of effort typing it.
Furthermore, having an <code>Optional</code> attribute instead of a regular object reflects the fact that the attribute might or might not exist. Notice how this is quite helpful since we don't have semantic meanings of this kind with regular attribute definitions.
<h3 id="exampleexplanation">Example Explanation</h3>
In this section, we'll take a bit of time to explain the previous example with <code>flatMaps</code> and <code>maps</code>. If you understand it without further explanation, please feel free to skip this section.
The first method call is performed on <code>falcon</code> which is of type <code>Optional&lt;Spaceship&gt;</code>. Calling the <code>getEngine</code> method returns an object of type <code>Optional&lt;Engine&gt;</code>. Combining these two types, the type of the returned object becomes <code>Optional&lt;Optional&lt;Engine&gt;&gt;</code>.
Since we would like to view this object as an <code>Engine</code> container and perform further calls on it, we need some kind of mechanism to &quot;peel off&quot; the outer <code>Optional</code> layer.
Such a mechanism exists and it is called <code>flatMap</code>. This API method combines the <code>map</code> and the <code>flat</code> operations by first applying a function to each of the elements and then flattening the result into a one-level stream.
The <code>map</code> method, on the other hand, only applies a function without flattening the stream. In our case, the use of <code>map</code> and <code>flatMap</code> would give us <code>Optional&lt;Optional&lt;Engine&gt;&gt;</code> and <code>Optional&lt;Engine&gt;</code> respectively.
Calling <code>flatMap</code> on an object of type <code>Optional</code> would therefore yield with a one-level <code>Optional</code>, allowing us to use multiple similar method calls in a succession.
This finally leaves us with<code>Optional&lt;Engine&gt;</code>, which we wanted in the first place.
<h3 id="alternativeresults">Alternative results</h3>
<h3 id="orelse">.orElse()</h3>
The previous example can be further expanded by using the <code>orElse(T other)</code> method. The method will return the <code>Optional</code> object upon which it is called only if there is a value contained within it.
If the <code>Optional</code> is empty, the method returns the <code>other</code> value. This is essentially an <code>Optional</code> version of the ternary operator:
<pre><code class="hljs">// Ternary Operator
Spaceship falcon = maybeFalcon != null ? maybeFalcon : new Spaceship(&quot;Millennium Falcon&quot;);

// Optional and orElse()
Spaceship falcon = maybeFalcon.orElse(new Spaceship(&quot;Millennium Falcon&quot;));
</code></pre>
As with the <code>ifPresent()</code> method, this kind of approach takes advantage of the <a target="_blank" href="/lambda-expressions-in-java/">lambda expressions</a> to make code more readable and less error-prone.
<h3 id="orelseget">.orElseGet()</h3>
Instead of providing the <code>other</code> value directly as an argument, we can use a 
<a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html">Supplier</a> instead. The difference between <code>.orElse()</code> and <code>.orElseGet()</code>, while maybe not evident at first glance, exists:
<pre><code class="hljs">// orElse()
Spaceship falcon = maybeFalcon.orElse(new Spaceship(&quot;Millennium Falcon&quot;));

// orElseGet()
Spaceship falcon = maybeFalcon.orElseGet(() -&gt; new Spaceship(&quot;Millennium Falcon&quot;));
</code></pre>
If <code>maybeFalcon</code> doesn't contain a value, both methods will return a new <code>Spaceship</code>. In this case, their behavior is the same. The difference becomes clear if <code>maybeFalcon</code> does contain a value.
In the first case, the <code>new Spaceship</code> object will not be returned but it will be created. This will happen regardless of whether or not the value exists. In the second case, the <code>new Spaceship</code> will be created only if <code>maybeFalcon</code> doesn't contain a value.
It's similar to how <code>do-while</code> does the task regardless of the <code>while</code> loop, at least once.
This might seem like a negligible difference but it becomes pretty important if creating spaceships is a demanding operation. In the first case, we're always creating a new object - even if it will never be used.
<code>.orElseGet()</code> should be preferred instead of <code>.orElse()</code> in such cases.
<h3 id="orelsethrow">.orElseThrow()</h3>
Instead of returning an alternative value (as we've seen in the previous two sections), we can throw an exception. This is accomplished with the <code>.orElseThrow()</code> method which instead of an alternative value accepts a supplier which returns the exception in case it needs to be thrown.
This can be useful in cases where the end result is of high importance and must not be empty. Throwing an exception in this case might be the safest option:
<pre><code class="hljs">// Throwing an exception
Spaceship falcon = maybeFalcon.orElseThrow(NoFuelException::new);
</code></pre>
<h2 id="gettingvaluesfromoptional">Getting Values from Optional</h2>
<h3 id="get">.get()</h3>
After seeing many different ways of checking and accessing the value inside <code>Optional</code>, let's now take a look at one final way of obtaining the value which also uses some of the previously shown methods.
The simplest way to access a value inside an <code>Optional</code> is with <code>.get()</code>. This method returns the value present, or throws a <code>NoSuchElementException</code> if the value is absent:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (falcon.isPresent()) {
 Spaceship falcon = optionalFalcon.get()

 // Fly the falcon
}
</code></pre>
As expected, the <code>.get()</code> method returns a non-<code>null</code> instance of the <code>Spaceship</code> class and assigns it to the <code>falcon</code> object.
<h2 id="conclusion">Conclusion</h2>
<code>Optional</code> was introduced to Java as a way to fix the issues with <code>null</code> references. Before <code>Optional</code>, every object was allowed to either contain a value or not (i.e. being <code>null</code>).
The introduction of <code>Optional</code> essentially enforces <code>null</code>-checking by the type-system making it unnecessary to perform such checks manually.
This was a big step both in improving the language and its usability by adding an additional layer of type-checking. Using this system instead of the old-fashioned <code>null</code>-checking allows writing clear and concise code without the need to add boilerplate and perform tiring checks by hand.

The Optional class was introduced in Java 8 to fix many of the issues with null references. In this article, we'll dive into the class, how it's used and improve code with Optionals.