<h2 id="introduction">Introduction</h2>
Dates are something we encounter in everyday life, whether they're used for calendars, scheduling appointments, or even remembering birthdays. Naturally, when working with dates we will often need to know if a certain date comes before or after another, or if they represent the same calendar date.
In this article, we'll take a look at how to compare two dates in Java.
<h2 id="comparingdates">Comparing Dates</h2>
The <code>java.util.Date</code> class represents a specific instant in time with millisecond precision.
It also has several built-in methods that allow us to compare each <code>Date</code> instance with other <code>Date</code> instances:
<ul>
<li><code>Date.compareTo(Date date)</code></li>
<li><code>Date.equals(Object obj)</code></li>
<li><code>Date.before(Date when)</code></li>
<li><code>Date.after(Date when)</code></li>
</ul>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Please note that the <code>Date</code> class has several deprecated methods, including the regular constructor. It's an old class, replaced with the new Date/Time API in Java 8, covered right after this section. If you're using Java 8+, please refer to the sections <a href="#comparinglocaldates">after this</a>.
If you're using a version prior to Java 8, please refer to the <a href="#comparingwithjodatime">Joda-Time Section</a>.

 </div>
 </div>
 </div>
 <h3 id="usingdatecompareto">Using Date.compareTo()</h3>
As usual with <code>compareTo()</code> methods implemented from the <code>Comparable</code> interface, this method accepts another <code>Date</code> argument and compares it to the value of the invoking <code>Date</code>, returning <code>0</code> if the values are equal, a value less than <code>0</code> if the invoking date is before the argument, and a value greater than <code>0</code> if the invoking date is after the argument.
Otherwise, it throws a <code>NullPointerException</code>, if the argument is <code>null</code>.
Let's instantiate two <code>Date</code> objects, and compare them:
<pre><code class="hljs">Date date1 = new Date(2020, 1, 1);
Date date2 = new Date(2020, 1, 1);
int result = date1.compareTo(date2);

if(result == 0)
 System.out.println(&quot;Both dates are equal&quot;);
else if (result &lt; 0)
 System.out.println(&quot;Date1 is before Date2&quot;);
else
 System.out.println(&quot;Date1 is after Date2&quot;);
</code></pre>
Running this code results in:
<pre><code class="hljs">Both dates are equal
</code></pre>
Note: Again, this only works for Java versions prior to Java 8. Since, the <code>Date(int year, int month, int day)</code> constructor has been deprecated, and only <code>Date(long date)</code> still stands.
<h3 id="usingdatebeforedateafteranddateequals">Using Date.before(), Date.after(), and Date.equals()</h3>
The <code>after()</code> method tests if the invoking <code>Date</code> is after the argument <code>Date</code> object, returning <code>true</code> or <code>false</code> values respectively. <code>before()</code> does the same, though, checks if the invoking <code>Date</code> is before the argument <code>Date</code>.
The <code>equals()</code> method compares two <code>Dates</code> for equality and returns <code>true</code> if and only if the argument is not <code>null</code> and is a <code>Date</code> object that represents the same point in time as the invoking object, else it will return <code>false</code>. In other words, it checks if the references point to the same object in memory.
All three throw a <code>NullPointerException</code> if the argument is <code>null</code>. Now, we can make the previous code snippet more user-friendly and readable, if we replace the integer checks with these methods:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;YYYY-MM-dd&quot;);
Date date1 = new Date(); // Returns the current date and time
Date date2 = new Date(2021, 2, 12);
 
String formatted1 = formatter.format(date1);
String formatted2 = formatter.format(date2);

if(date1.equals(date2))
 System.out.println(&quot;Both dates are equal&quot;);
else if(date1.after(date2))
 System.out.println(String.format(&quot;%s comes after %s&quot;, formatted1, formatted2));
else if(date1.before(date2))
 System.out.println(String.format(&quot;%s comes before %s&quot;, formatted1, formatted2));
</code></pre>
If you're unfamiliar with the <code>SimpleDateFormat</code> class, you can read our <a target="_blank" href="https://stackabuse.com/java-format-dates-with-simpledateformat/">Guide on Formatting Dates in Java with SimpleDateFormat</a>
Running this code results in:
<pre><code class="hljs">2021-03-24 comes after 2021-02-12
</code></pre>
<h2 id="comparinglocaldates">Comparing LocalDates</h2>
As of Java 8, we had some big changes regarding date and time. There were many issues with the existing date and time API, such as the lack of thread-safe classes and methods, lack of timezone logic, and the overall API design wasn't very easy to understand.
Lead by these issues, the author of <a rel="nofollow noopener" target="_blank" href="https://www.joda.org/joda-time/">Joda-Time</a> (a popular substitute for the lackluster API prior to Java 8) and Oracle, presented us the new Date/Time API through <code>java.time</code>.
<code>LocalDate</code> class is one of the most commonly used classes of <code>java.time</code>, alongside <code>LocalTime</code> and <code>LocalDateTime</code>. It represents a date without time or time zone fields with a default date format of <code>yyyy-mm-dd</code>.
The built-in methods for comparison are pretty similar to the <code>Date</code> class:
<ul>
<li><code>LocalDate.isAfter()</code></li>
<li><code>LocalDate.isBefore()</code></li>
<li><code>LocalDate.isEqual()</code></li>
<li><code>LocalDate.compareTo()</code></li>
<li><code>LocalDate.equals()</code></li>
</ul>
<h3 id="usinglocaldateisafterlocaldateisbeforeandlocaldateisequal">Using LocalDate.isAfter(), LocalDate.isBefore(), and LocalDate.isEqual()</h3>
All three methods check if the invoked <code>LocalDate</code> is before, after, or equal to the argument, returning <code>boolean</code> values respectively.
Let's instantiate two <code>LocalDate</code> instances, using the helper method <code>of()</code>, and passing in the <code>year</code>, <code>month</code> and <code>day</code> values:
<pre><code class="hljs">LocalDate date1 = LocalDate.of(2020, 3, 25);
LocalDate date2 = LocalDate.of(2020, 7, 29);

if (date1.isAfter(date2))
 System.out.println(String.format(&quot;%s comes after %s&quot;, date1, date2));
else if (date1.isBefore(date2))
 System.out.println(String.format(&quot;%s comes before %s&quot;, date1, date2));
else if (date1.isEqual(date2))
 System.out.println(&quot;Both dates are equal&quot;);
</code></pre>
This results in:
<pre><code class="hljs">2020-03-25 comes before 2020-07-29
</code></pre>
<h3 id="usinglocaldatecomparetoandlocaldateequals">Using LocalDate.compareTo() and LocalDate.equals()</h3>
Again, as usual, <code>compareTo()</code> compares instances and returns <code>-1</code>, <code>0</code>, or <code>1</code> depending on the values of the <code>LocalDate</code>s. On the other hand, the <code>equals()</code> method checks if the references point to the same object in memory:
<pre><code class="hljs">LocalDate date1 = LocalDate.of(2021, 12, 12);
LocalDate date2 = LocalDate.of(2021, 12, 12);
 
if(date1.equals(date2)) {
 System.out.println(&quot;Same LocalDate&quot;);
} else if(date1.compareTo(date2) &gt; 0) {
 System.out.println(String.format(&quot;%s is after %s&quot;, date1, date2));
} else if(date1.compareTo(date2) &lt; 0) {
 System.out.println(String.format(&quot;%s is before %s&quot;, date1, date2));
} else {
 System.out.println(String.format(&quot;%s and %s represent the same date&quot;, date1, date2));
}
</code></pre>
Since we've created two <code>LocalDate</code>s with the same values, without using the <code>new</code> keyword that ensures a <code>new Object</code>, these are the same <code>LocalDate</code>:
<pre><code class="hljs">Same LocalDate
</code></pre>
In fact, since <code>LocalDate</code> doesn't have a public constructor, we can't really ever call <code>new</code> on it.
<h2 id="comparingcalendars">Comparing Calendars</h2>
The <code>java.util.Calendar</code> class is a part of the old Date/Time API, and is mainly used for conversion between instants and calendar fields, such as <code>DAY_OF_MONTH</code>, etc.
They can also hold date-related data, and of course, they can be compared:
<pre><code class="hljs">Calendar c1 = Calendar.getInstance();
c1.set(2020, Calendar.AUGUST, 15);
Calendar c2 = Calendar.getInstance();
c2.set(2020, Calendar.JULY, 4);

if(c1.equals(c2))
 System.out.println(&quot;Calendars are equal&quot;);
else if(c1.after(c2))
 System.out.println(c1.getTime() + &quot; comes after &quot; + c1.getTime());
else if(c1.before(c2))
 System.out.println(c1.getTime() + &quot; comes before &quot; + c2.getTime());
</code></pre>
This results in:
<pre><code class="hljs">Sat Aug 15 14:22:24 UTC 2020 comes after Sat Aug 15 14:22:24 UTC 2020
</code></pre>
<h2 id="comparingwithjodatime">Comparing With Joda-Time</h2>
Joda-Time was the standardized third-party Date/Time library for Java, prior to Java 8. It addressed the issues present in the original API, which there were plenty of. It also served as an inspiration and starting point to overhaul the whole API, which resulted in the current <code>java.time</code> package.
With Joda-Time we can use up to eight different calendar systems, manipulate time zones, or even define our own custom calendars. But more importantly, we don't have to worry about mutability.
Rather than representing dates as instances in time, Joda-Time represents them as actual dates. To show how we compare dates using Joda-Time, we'll be using the <code>LocalDate</code> class (Joda-Time class) which is thread-safe.
<h3 id="usingdatetimecomparator">Using DateTimeComparator</h3>
The <code>DateTimeComparator</code> class is specifically made to compare dates. It works with <code>ReadableInstant</code>s, <code>String</code>s, <code>Date</code>s, <code>Calendar</code>s and <code>Long</code>s. So, we'll have to convert our Joda-Time <code>LocalDate</code>s, to <code>Date</code>s:
<pre><code class="hljs">LocalDate date1 = new LocalDate(2021, 11, 11);
LocalDate date2 = new LocalDate(2021, 12, 12);

int result = DateTimeComparator.getInstance()
 .compare(date1.toDate(), date2.toDate());
System.out.println(result);
</code></pre>
This method returns an integer result, just like the <code>compareTo()</code> method, where <code>-1</code> means the first date is before the second, <code>0</code> means they're the same, and <code>1</code> means that the first object is after the second:
<pre><code class="hljs">-1
</code></pre>
<h3 id="usinglocaldateisequal">Using LocalDate.isEqual()</h3>
In a similar vein to the current Date/Time API, we can use <code>isEqual()</code>:
<pre><code class="hljs">LocalDate date1 = new LocalDate(2021, 11, 11);
LocalDate date2 = new LocalDate(2021, 12, 12);

System.out.println(date1.isEqual(date2));
</code></pre>
This results in a <code>boolean</code>:
<pre><code class="hljs">false
</code></pre>
<h3 id="usinglocaldateisbeforeandlocaldateisafter">Using LocalDate.isBefore() and LocalDate.isAfter()</h3>
Again, much like the Java 8 API, we can use the <code>isBefore()</code> and <code>isAfter()</code> methods to compare two <code>LocalDate</code>s:
<pre><code class="hljs">LocalDate date1 = new LocalDate(2021, 11, 11);
LocalDate date2 = new LocalDate(2021, 12, 12);

System.out.println(date1.isBefore(date2));
System.out.println(date1.isAfter(date2));
</code></pre>
This results in:
<pre><code class="hljs">true
false
</code></pre>
<h3 id="usinglocaldatecompareto">Using LocalDate.compareTo()</h3>
Extending <code>Comparable</code>, the <code>LocalDate</code> class has a <code>compareTo()</code> method, which returns an integer greater, less, or equal to zero. The fields are compared in order and the first field that is non-equal is used to determine the result:
<pre><code class="hljs">LocalDate today = LocalDate.now();
LocalDate tomorrow = new LocalDate(today.getYear(),
 today.getMonthOfYear(), 
 today.getDayOfMonth() + 1);
int result = today.compareTo(tomorrow);

if(result == 0)
 System.out.println(&quot;Dates are equal&quot;);
else if (result &lt; 0)
 System.out.println(today + &quot; is before &quot; + tomorrow);
else
 System.out.println(today + &quot; is after &quot; + tomorrow);
 
</code></pre>
This results in:
<pre><code class="hljs">2021-04-14 is before 2021-04-15
</code></pre>
<h3 id="usinglocaldateequals">Using LocalDate.equals()</h3>
And finally, the <code>equals()</code> method checks for object reference equality:
<pre><code class="hljs">LocalDate date1 = new LocalDate(2021, 3, 25);
LocalDate date2 = new LocalDate(2021, 2, 25);
System.out.println(date1.equals(date2));
</code></pre>
This results in:
<pre><code class="hljs">false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered several ways to compare dates in Java. We've used the now-deprecated <code>java.util.Date</code> class, for older projects, and the <code>java.util.Calendar</code> class.
Then, we've jumped into the more modern Java 8 Date/Time API, and finally Joda-Time.

David Landup

Anđela Niketić

In this guide, we'll take a detailed look at how to compare dates in Java - using the old java.util package, the new java.time API, as well as Joda-Time.

How to Compare Dates in Java

In this tutorial, we'll be taking a look at how to convert a JSON String into a Java Map using <a rel="nofollow noopener" target="_blank" href="https://github.com/FasterXML/jackson">Jackson</a>, an extremely popular data-binding library for Java.
Specifically, we'll be working with this JSON object:
<pre><code class="hljs">{
&quot;Task 1&quot; : &quot;In_Progress&quot;,
&quot;Task 2&quot; : &quot;Done&quot;,
&quot;Task 3&quot; : &quot;Planned&quot;
}
</code></pre>
Since we're working with an external library, let's add the required dependency. If you're using Maven, you can add it to your project with:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt;
 &lt;version&gt;2.11.3&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or if you're using Gradle, you can add:
<pre><code class="hljs">implementation group: &#x27;com.fasterxml.jackson.core&#x27;, name: &#x27;jackson-databind&#x27;, version: &#x27;2.11.3&#x27;
</code></pre>
<h2 id="convertjsonstringtojavamap">Convert JSON String to Java Map</h2>
For our task status labels, let's define an Enum. We'll have a <code>Map&lt;String, TASK_STATUS&gt;</code> pair, though, you can go with any type here, really:
<pre><code class="hljs">enum TASK_STATUS {
 In_Progress, Done, Planned
}
</code></pre>
Naturally, Jackson's key class is the <code>ObjectMapper</code> class - the main API for object-related data-binding of the library.
Much like you'd map JSON values to other types, to convert JSON contents into a Java Map, you'll use the <code>readValue()</code> method of the <code>ObjectMapper</code> instance, which deserializes it into the provided class reference:
<pre><code class="hljs">String json = &quot;{\n&quot; +
 &quot;\&quot;Task 1\&quot; : \&quot;In_Progress\&quot;,\n&quot; +
 &quot;\&quot;Task 2\&quot; : \&quot;Done\&quot;,\n&quot; +
 &quot;\&quot;Task 3\&quot; : \&quot;Planned\&quot;\n&quot; +
 &quot;}&quot;;

// ObjectMapper instantiation
ObjectMapper objectMapper = new ObjectMapper();

// Deserialization into a Map
Map&lt;String, TASK_STATUS&gt; result = objectMapper.readValue(json, HashMap.class);
 
// Printing the results
System.out.println(result.entrySet());
</code></pre>
We've chucked the <code>json</code> contents into the <code>readValue()</code> method, and since it contains JSON that can be deserialized into a Map, given the key-value pairings, told Jackson to deserialize into a <code>HashMap</code>. Running this code results in:
<pre><code class="hljs">[Task 2=Done, Task 1=In_Progress, Task 3=Planned]
</code></pre>
Now, since <code>HashMap</code>s do not preserve the order of insertion, you might want to use a <code>LinkedHashMap</code> instead, if the order of insertion is important to you:
<pre><code class="hljs">Map&lt;String, TASK_STATUS&gt; result = objectMapper.readValue(json, LinkedHashMap.class);
</code></pre>
This results in:
<pre><code class="hljs">[Task 1=In_Progress, Task 2=Done, Task 3=Planned]
</code></pre>
An alternative to specifying the <code>JavaType</code> directly would be to use the <code>TypeReference</code> class from Jackson:
<pre><code class="hljs">Map&lt;String, TASK_STATUS&gt; result = objectMapper.readValue(json, 
 new TypeReference&lt;LinkedHashMap&gt;(){});
</code></pre>
Now, printing this map will also result in:
<pre><code class="hljs">[Task 1=In_Progress, Task 2=Done, Task 3=Planned]
</code></pre>
Both of these construct an object by calling the exact same deserialization process. So the only difference between these two calls is whether you're making a static (<code>JavaType</code>) or dynamic (<code>TypeReference</code>) reference to the type.

In this tutorial, we'll take a look at how to convert a JSON String to a Java Map with Jackson, with examples.

Convert JSON String to Java Map with Jackson

<h2 id="introduction">Introduction</h2>
In Java, there is a distinct difference between <code>null</code>, empty, and blank Strings.
<ul>
<li>An empty string is a <code>String</code> object with an assigned value, but its length is equal to zero.</li>
<li>A <code>null</code> string has no value at all.</li>
<li>A blank String contains only whitespaces, are is neither empty nor <code>null</code>, since it does have an assigned value, and isn't of <code>0</code> length.</li>
</ul>
<pre><code class="hljs">String nullString = null;
String emptyString = &quot;&quot;;
String blankString = &quot; &quot;;
</code></pre>
In this tutorial, we'll look at how to check if a String is Null, Empty or Blank in Java.
<h2 id="usingthelengthofthestring">Using the Length of the String</h2>
As mentioned before, a string is empty if its length is equal to zero. We will be using the <code>length()</code> method, which returns the total number of characters in our string.
<pre><code class="hljs">String blankString = &quot; &quot;;

if (blankString == null || blankString.length() == 0)
 System.out.println(&quot;This string is null or empty&quot;);
else
 System.out.println(&quot;This string is neither null nor empty&quot;);
</code></pre>
The code above will produce the following output:
<pre><code class="hljs">This string is null or empty
</code></pre>
The String is blank, so it's obviously neither <code>null</code> nor empty. Now, based just on the length, we can't really differentiate between Strings that only contain whitespaces or any other character, since a whitespace is a <code>Character</code>.
Note: It's important to do the <code>null</code>-check first, since the short-circuit OR operator <code>||</code> will break immediately on the first <code>true</code> condition. If the string, in fact, is <code>null</code>, all other conditions before it will throw a <code>NullPointerException</code>.
<h2 id="usingtheisemptymethod">Using the isEmpty() Method</h2>
The <code>isEmpty()</code> method returns <code>true</code> or <code>false</code> depending on whether or not our string contains any text. It's easily chainable with a <code>string == null</code> check, and can even differentiate between blank and empty strings:
<pre><code class="hljs">String string = &quot;Hello there&quot;;

if (string == null || string.isEmpty() || string.trim().isEmpty()) 
 System.out.println(&quot;String is null, empty or blank.&quot;);
else
 System.out.println(&quot;String is neither null, empty nor blank&quot;);
</code></pre>
The <code>trim()</code> method removes all whitespaces to the left and right of a String, and returns the new sequence. If the String is blank, after removing all whitespaces, it'll be empty, so <code>isEmpty()</code> will return <code>true</code>.
Running this piece of code will give us the following output:
<pre><code class="hljs">String is neither null, empty nor blank
</code></pre>
<h2 id="usingtheequalsmethod">Using the equals() Method</h2>
The <code>equals()</code> method compares the two given strings based on their content and returns <code>true</code> if they're equal or <code>false</code> if they are not:
<pre><code class="hljs">String string = &quot;Hello there&quot;;

if (string == null || string.equals(&quot;&quot;) || string.trim().equals(&quot;&quot;))
 System.out.println(&quot;String is null, empty or blank&quot;);
else
 System.out.println(&quot;String is neither null, empty nor blank&quot;);
</code></pre>
In much the same fashion as the before, if the trimmed string is <code>&quot;&quot;</code>, it was either empty from the get-go, or was a blank string with <code>0..n</code> whitespaces:
<pre><code class="hljs">String is neither null, empty nor blank
</code></pre>
<h2 id="usingthestringutilsclass">Using the StringUtils Class</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> is a popular Java library that provides further functionality. <code>StringUtils</code> is one of the classes that Apache Commons offers. This class contains methods used to work with <code>Strings</code>, similar to the <code>java.lang.String</code>.
If you're unfamiliar with Apache Commons' helper classes, we strongly suggest reading our <a target="_blank" href="https://stackabuse.com/guide-to-apache-commons-stringutils-class-in-java/">Guide to the StringUtils class</a>.
Since we'll be using Apache Commons for this approach, let's add it as a dependency:
<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;3.11&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or, if you're using Gradle:
<pre><code class="hljs">compile group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: &#x27;3.11&#x27;
</code></pre>
One of the key differences between <code>StingUtils</code> and <code>String</code> methods is that all methods from the <code>StringUtils</code> class are null-safe. It additionally provides a few methods that we can leverage for this, including <code>StringUtils.isEmpty()</code> and <code>StringUtils.isBlank()</code>:
<pre><code class="hljs">String nullString = null;

if (nullString == null) {
 System.out.println(&quot;String is null&quot;);
}
else if (StringUtils.isEmpty(nullString)) {
 System.out.println(&quot;String is empty&quot;);
}
else if (StringUtils.isBlank(nullString)) {
 System.out.println(&quot;String is blank&quot;);
}
</code></pre>
The output will be:
<pre><code class="hljs">String is null
</code></pre>
In addition to these, their inverse methods also exist: <code>StringUtils.isNotEmpty()</code> and <code>StringUtils.isNotBlank()</code>, though, you can achieve the same functionality by using the NOT (<code>!</code>) operator:
<pre><code class="hljs">if (StringUtils.isNotEmpty(&quot;&quot;))
 System.out.println(&quot;String is not empty&quot;);
 
// Equivalent to

if (!StringUtils.isEmpty(&quot;&quot;))
 System.out.println(&quot;String is not empty&quot;);
</code></pre>
<h2 id="conclusion">Conclusion</h2>
A string is an object that represents a sequence of characters. Java provides many different methods for string manipulation. In this article, we have used some of these methods such as <code>isEmpty()</code>, <code>equals()</code>, <code>StringUtils.isEmpty()</code> and <code>length()</code> to check if the <code>String</code> is <code>null</code>, empty or blank.

Selena Hocevar

In this tutorial, we'll take a look at how to check if a String is null, empty or blank in Java, using String.isEmpty(), String.equals() and Apache Commons, with examples.

Java: Check if String is Null, Empty or Blank

<h2 id="introduction">Introduction</h2>
Bash utilities make so many tasks simple, but not all tasks have a straightforward command or operator. A very common and usual task in many scripting scenarios is concatenating string variables.
Bash doesn't have a built-in function or command-line utility to concatenate two strings together. However, there are many ways you can accomplish this.
<h2 id="concatenatingstringsinbash">Concatenating Strings in Bash</h2>
The following are the steps by which the strings can be concatenated, ordered by the level of complication:
<ol>
<li><code>echo</code> both variables</li>
<li>Format using <code>printf</code></li>
<li>Format using <code>awk</code></li>
<li>Concat string files using <code>join</code></li>
</ol>
Throughout the article, we will be using the variables - <code>string1</code> and <code>string2</code> which you can create in your shell by entering:
<pre><code class="hljs">$ string1=&quot;Stuck&quot;
$ string2=&quot;Together&quot;
</code></pre>
<h3 id="concatenatestringsinbashwithecho">Concatenate Strings in Bash with echo</h3>
Perhaps the simplest of all the hacks is to simply echo both variables formatted next to each other:
<pre><code class="hljs">$ echo &quot;${string1}&quot; &quot;${string2}&quot;
</code></pre>
Notice that we have a blank between both the strings. The snippet can also be written as:
<pre><code class="hljs">$ echo &quot;${string1} ${string2}&quot;
</code></pre>
Both of the snippets will give the same output:
<pre><code class="hljs">Stuck Together
</code></pre>
<h3 id="concatenatestringsinbashwithprintf">Concatenate Strings in Bash with printf</h3>
Let's try concatenating the strings by printing a formatted output on the teletypewriter i.e. terminal. Consider the following snippet, where two string format tags (<code>%s</code>) are split by an empty space that is ready to be substituted by the two variables - <code>$string1</code> and <code>$string2</code>:
<pre><code class="hljs">$ printf &quot;%s %s\n&quot; &quot;$string1&quot; &quot;$string2&quot;
</code></pre>
The two format tags, when substituted with our string variables output:
<pre><code class="hljs">Stuck Together
</code></pre>
String formatting may sound familiar if you are familiar with programming languages. If this sounds overwhelming to you, it's good to learn about what the different tags do (such as <code>%s</code> and <code>%d</code>), which could come in quite handy.
<h3 id="concatenatestringsinbashwithawk">Concatenate Strings in Bash with awk</h3>
A slightly less known command - the <code>awk</code> command, invokes AWK - a scripting language specifically designed for manipulating text and extract strings from them. It doesn't come as a surprise that a scripting language dedicated to manipulating strings also has the ability to concatenate them:
<pre><code class="hljs">$ echo &quot;$string1&quot; &quot;$string2&quot; | awk &#x27;{printf &quot;%s~%s\n&quot;,$1,$2}&#x27;
</code></pre>
Let's break up the command above. We have two snippets chained to each other (hence the <code>|</code> chaining operator). We are sending both the variables <code>string1</code> and <code>string2</code> as inputs to the <code>awk</code> command.
<blockquote>
The syntax of the <code>awk</code> command is: <code>awk '{some_operation}'</code>.
</blockquote>
In our case, we are performing a <code>printf</code> operation inside. We refer to the variables as <code>$1</code> and <code>$2</code>; these refer to the variables passed as arguments from the <code>echo</code>.
Just to show a variation here, we are using a tilde(<code>~</code>) separating the format tags. Thus, it gives the following output:
<pre><code class="hljs">Stuck~Together
</code></pre>
<h3 id="concatenatestringsinbashwithjoin">Concatenate Strings in Bash with join</h3>
Now that the bars have been raised, let's try one final method. Let's try storing our strings in two separate files with one column each. The file <code>string1.txt</code> contains the word <code>&quot;Stuck&quot;</code> written two times in three lines. Same as before, <code>string2.txt</code> will contain the word <code>&quot;Together&quot;</code> written two times in three lines and the following commands create the files for us:
<pre><code class="hljs">$ echo &quot;1 Stuck&quot; &gt; &quot;string1.txt&quot;
$ echo &quot;2 Stuck&quot; &gt;&gt; &quot;string1.txt&quot;
$ echo &quot;1 Together&quot; &gt; &quot;string2.txt&quot;
$ echo &quot;2 Together&quot; &gt;&gt; &quot;string2.txt&quot;
</code></pre>
Both the files can be concatenated by using the following command:
<pre><code class="hljs">$ join string1.txt string2.txt
</code></pre>
For the join command to work, both the files should have a matching column. In our case, we have the matching index column and we get the concatenated output as shown below:
<pre><code class="hljs">1 Stuck Together
2 Stuck Together
</code></pre>
<h2 id="conclusion">Conclusion</h2>
There are multiple ways to perform the concatenation of strings in bash scripting. The choice of the method depends on the level of complexity and the nature of the problem. Which one will you choose?

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Bash does not have a direct command to concatenate strings. However, Bash gives us multiple ways to join them still. Let's find out what they are!

How to Concatenate String Variables in Bash

Dimitrije Stamenic

In this tutorial, we'll take a look at the theory and implementation of Radix Sort in Python, as well as Counting Sort as its main subroutine, with illustrated examples.

Radix Sort in Python

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to generate random integers in a specific range in Java.
We'll be taking a look at several approaches, including core Java and third-party solutions:
<ul>
<li><a href="#randomints">Random.ints()</a></li>
<li><a href="#randomnextint">Random.nextInt()</a></li>
<li><a href="#mathrandom">Math.random()</a></li>
<li><a href="#securerandomnextint">SecureRandom.nextInt()</a></li>
<li><a href="#threadlocalrandomnextint">ThreadLocalRandom.nextInt()</a></li>
<li><a href="#splittablerandomints">SplittableRandom.ints()</a></li>
</ul>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: For each approach, we'll cover how to generate one random integer as well as how to generate a sequence of random integers.

 </div>
 </div>
 </div>
 All of these methods are lower-bound inclusive, and upper-bound exclusive.
<h2 id="randomints">Random.ints()</h2>
We're starting off with <code>Random.ints()</code> which was added to the <code>Random</code> class in Java 8, exactly for this purpose. Java originally didn't have a fully intuitive solution for this task, built-in.
The <code>ints()</code> method returns a sequence of random values, in the form of an <code>IntStream</code>. Being a <code>Stream</code> implementation, it's unbounded:
<pre><code class="hljs">Random random = new Random();
random.ints().forEach(System.out::println);
</code></pre>
This results in:
<pre><code class="hljs">-526320702
-744603161
474879020
1864311422
406782252
...
</code></pre>
This is an unbounded <code>IntStream</code>, which will generate any value from <code>Integer.MIN_VALUE</code> to <code>Integer.MAX_VALUE</code>. However, you can specify a range, as well as the number of elements you'd like to generate.
Additionally, the first argument is the number of elements you'd like to generate - otherwise, the stream will be generate an unlimited number of elements, until your Heap Memory space runs out:
<pre><code class="hljs">List&lt;Integer&gt; intList = new Random().ints(5, 1, 11)
 .boxed()
 .collect(Collectors.toList());

System.out.println(intList);
</code></pre>
Before collecting the <code>IntStream</code>, we'll have to box it via the <code>boxed()</code> method, which returns a stream consisting of the elements of the <code>IntStream</code>, boxed to an <code>Integer</code>. Then, we run <code>collect()</code> on the returned stream - not the original one.
The <code>collect()</code> method of the <code>IntStream</code> doesn't return a collection - it runs a <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#MutableReduction">mutable reduction operation</a>.
Running this code results in:
<pre><code class="hljs">[1, 9, 9, 6, 2]
</code></pre>
To generate a single random integer, you can simply tweak the first argument of the <code>ints()</code> method, or use the <code>findFirst()</code> and <code>getAsInt()</code> methods to extract it from the <code>IntStream</code>:
<pre><code class="hljs">int randomInt = new Random().ints(1, 1, 11).findFirst().getAsInt();
System.out.println(randomInt);
</code></pre>
This results in a random integer in the range between <code>1..10</code> (second argument is exclusive):
<pre><code class="hljs">5
</code></pre>
<h2 id="randomnextint">Random.nextInt()</h2>
A more classic example that you'll often see people using is simply utilizing the <code>Random.nextInt()</code> method. It accepts a <code>bound</code> parameter, which sets the upper bound, and sets the lower bound to <code>0</code> by default.
Unfortunately, it doesn't allow you to change this - so a quick and simple &quot;hack&quot; can be used to specify the boundaries:
<pre><code class="hljs">int min = 10;
int max = 100;

System.out.println(new Random().nextInt(max - min) + min);
</code></pre>
This results in a random integer in the range between <code>min</code> and <code>max</code>:
<pre><code class="hljs">53
</code></pre>
Generating a sequence of this would require us to call the method multiple times:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 Random random = new Random();
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound);
 }
 return result;
}
</code></pre>
This is a <code>List</code>-limited recreation of the <code>Random.ints()</code> functionality, which simply returns a list of randomly generated integers in a range, with a given size:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange(5, 0, 10);
System.out.println(integerList);
</code></pre>
Running this code would result in something along the lines of:
<pre><code class="hljs">[3, 8, 2, 2, 9]
</code></pre>
<h2 id="securerandomnextint">SecureRandom.nextInt()</h2>
The <code>SecureRandom</code> class is an alternative to the classic <code>Random</code> class, but provides a cryptographically strong random number generator. <code>Random</code> internally relies on the system's clock to generate number seeds, which isn't truly random.
On the other hand, <code>SecureRandom</code> takes much more random data from the environment to generate a much more random seed.
If cryptographic safety is a thing you're concerned with, you may opt to use <code>SecureRandom</code> instead - which behaves in much the same way as <code>Random</code> from the developer's point of view:
<pre><code class="hljs">int max = 100;
int min = 10;

int randomInt = new SecureRandom().nextInt(max - min) + min;
System.out.println(randomInt);
</code></pre>
Which results in a random integer in the range between <code>min</code> and <code>max</code>:
<pre><code class="hljs">95
</code></pre>
And if you'd like to generate sequences, a helper method can be crafted:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 SecureRandom random = new SecureRandom();
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound);
 }
 return result;
}
</code></pre>
Which you can use as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange3(5, 0, 10);
System.out.println(integerList);
</code></pre>
And which results in:
<pre><code class="hljs">[0, 9, 5, 6, 5]
</code></pre>
<h2 id="mathrandom">Math.random()</h2>
The <code>Math</code> class provides us with great math-related helper methods. One of them is the <code>Math.random()</code> method, which returns a random value between <code>0..1</code>. Typically, it's used to generate random percentile values.
However, in a similar vein to the <code>Random.nextInt()</code> hack - you can utilize this functionality to generate any integer in a certain range:
<pre><code class="hljs">int min = 10;
int max = 100;

int randomNumber = (int)(Math.random() * (max + 1 - min) + min);
System.out.println(randomNumber);
</code></pre>
Though, this one is even less intuitive than the previous approach. Running this code results in something along the lines of:
<pre><code class="hljs">43
</code></pre>
If you'd like to work with a sequence, we'd create a helper method to append each generated value to a list:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add((int)(Math.random() * (upperBound + 1 - lowerBound) + lowerBound));
 }
 return result;
}
</code></pre>
And then we can call it as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange(5, 0, 10);
System.out.println(integerList);
</code></pre>
Which produces:
<pre><code class="hljs">[9, 0, 3, 2, 0]
</code></pre>
<h2 id="threadlocalrandomnextint">ThreadLocalRandom.nextInt()</h2>
If you're working in a multi-threaded environment, the <code>ThreadLocalRandom</code> class is meant to be used as a thread-safe equivalent to <code>Random</code>. Fortunately, it does offer a <code>nextInt()</code> method with both an upper and lower bound:
<pre><code class="hljs">int randomInt = ThreadLocalRandom.current().nextInt(0, 10);
System.out.println(randomInt);
</code></pre>
As usual, the lower bound is included, while the upper bound isn't:
<pre><code class="hljs">3
</code></pre>
Similarly, you can create a helper function to generate a sequence of these:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(ThreadLocalRandom.current().nextInt(lowerBound, upperBound));
 }
 return result;
}
</code></pre>
Which you can use as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange4(5, 0, 10);
System.out.println(integerList);
</code></pre>
<pre><code class="hljs">[1, 9, 1, 9, 7]
</code></pre>
<h2 id="splittablerandomints">SplittableRandom.ints()</h2>
A less-known class in the Java API is the <code>SplittableRandom</code> class - which is used as a generator of pseudo-random values. As the name implies, it's splittable and runs in parallel, and is really only used when you have tasks that could split again into smaller sub-tasks.
It's worth noting that this class is also based on non-secure seed generation - if you're looking for a safe seed generation, use <code>SecureRandom</code>.
The class offers an <code>ints()</code> method, which from our perspective, works in the same way as <code>Random.ints()</code>:
<pre><code class="hljs">List&lt;Integer&gt; intList = new SplittableRandom().ints(5, 1, 11)
 .boxed()
 .collect(Collectors.toList());

System.out.println(intList);
</code></pre>
Which results in:
<pre><code class="hljs">[3, 2, 8, 10, 3]
</code></pre>
And, if you'd like to generate only one random number, you can ditch the collector and use <code>findFirst()</code> with <code>getAsInt()</code>:
<pre><code class="hljs">int randomInt = new SplittableRandom().ints(1, 1, 11).findFirst().getAsInt();
System.out.println(randomInt);
</code></pre>
Which results in:
<pre><code class="hljs">4
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken an exhaustive look at how to generate random integers in range in Java.
We've gone over the newest and most useful method, as well as some other popular methods of finishing this task. Most of the approaches rely on the <code>Random</code> or <code>Random</code>-equivalent classes, used for more specific contexts.

In this tutorial, we'll go over how to generate random integer(s) in a specific range in Java - single and multiple values, in a wide variety of ways, with examples.

Java: Generate Random Integers in Range

<h2 id="introduction">Introduction</h2>
Plotly is a JavaScript-based, Python data visualization library, focused on interactive and web-based visualizations. It has the simplicity of Seaborn, with a high-level API, but also the interactivity of Bokeh.
In addition to the core library's functionality, using the built-in Plotly Express with Dash, makes it an amazing choice for web-based applications and interactive, data-driven dashboards, usually written in Flask.
In this guide, we'll take a look at how to plot a Scatter Plot with Plotly.
<blockquote>
Scatter Plots explore the relationship between two numerical variables (features) of a dataset.
</blockquote>
<h2 id="importdata">Import Data</h2>
We'll be working with the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rashikrahmanpritom/heart-attack-analysis-prediction-dataset">Heart Attack Dataset</a> from Kaggle, which contains data on various bodily metrics that we could use as indicators of a heart attack possibility.
Let's import the dataset and print the <code>head()</code> to take a peek:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;heart.csv&#x27;)
print(df.head())
</code></pre>
This results in:
<pre><code class="hljs"> age cp trtbps chol fbs restecg thalachh exng oldpeak slp caa output
0 63 3 145 233 1 0 150 0 2.3 0 0 1
1 37 2 130 250 0 1 187 0 3.5 0 0 1
2 41 1 130 204 0 0 172 0 1.4 2 0 1
3 56 1 120 236 0 1 178 0 0.8 2 0 1
4 57 0 120 354 0 1 163 1 0.6 2 0 1
</code></pre>
Let's explore the relationships between features such as the <code>thalachh</code> (maximum recorded heart rate), <code>trtbps</code> (resting blood pressure), <code>chol</code> (amount of cholesterol) and <code>output</code> (<code>0</code> or <code>1</code>, representing lower or higher chances of experiencing a heart attack respectively).
First, let's go ahead and save our features separately for brevity's sake:
<pre><code class="hljs">max_heartrate = df[&#x27;thalachh&#x27;]
resting_blood_pressure = df[&#x27;trtbps&#x27;]
cholesterol_level = df[&#x27;chol&#x27;]
output = df[&#x27;output&#x27;]
</code></pre>
<h2 id="plotascatterplotwithplotly">Plot a Scatter Plot with Plotly</h2>
Finally, we can go ahead and plot a Scatter Plot. Let's go ahead and first explore the relationship between <code>max_heartrate</code> and <code>cholesterol_level</code>. To plot a Scatter Plot with Plotly, we'll use the <code>scatter()</code> function of the Plotly Express (<code>px</code>) instance:
<pre><code class="hljs">fig = px.scatter(x=cholesterol_level, y=max_heartrate)
fig.show()
</code></pre>
The only required arguments are the <code>x</code> and <code>y</code> features, which will plot a Scatter Plot (without axis labels) in a spun-up server on your browser of choice:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-1.png" alt="simple plotly scatter plot">
Alternatively, if you don't want to define your variables beforehand, Plotly offers the exact same syntax as Seaborn - you specify the data source, and the names of the features you'd like to visualize. This will map the features to labels, and plot them directly without having to specify the features like we did before:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, y=&#x27;thalachh&#x27;)
fig.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-2.png" alt="plotly scatter plot with labels">
Note: You can also do a mish-mash of these approaches, where you supply your <code>DataFrame</code> as the source, but also use predefined variables instead of referencing the feature column-names in the <code>scatter()</code> call:
<pre><code class="hljs">fig = px.scatter(df, x=cholesterol_level, y=max_heartrate)
fig.show()
</code></pre>
This results in a labeled Scatter Plot as well:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-2.png" alt="labeled plotly scatter plot">
There doesn't seem to be much of a correlation between the cholesterol level and maximum heart rate of individuals in this dataset.
<h2 id="customizingaplotlyscatterplot">Customizing a Plotly Scatter Plot</h2>
Now, we rarely visualize plain plots. The point is to visualize certain characteristics of data, intuitively.
In our case, this might include coloring the markers depending on the <code>output</code> feature, or adding <code>hover_data</code>, which specifies what's shown on the markers when someone hovers over them.
Currently, the <code>hover_data</code> isn't very helpful, only showing us the <code>x</code> and <code>y</code> values, which can already be reasonably inferred from observing the resulting plot.
Let's go ahead and change a few of the parameters to make this plot a bit more intuitive:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, y=&#x27;thalachh&#x27;, color=&#x27;output&#x27;, hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])
fig.show()
</code></pre>
We've set the <code>color</code> of each marker to be mapped to the <code>output</code> feature, coloring higher and lower chances of experiencing a heart attack in different colors. We've also included the <code>sex</code> and <code>age</code> of each individual on their markers.
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-4.PNG" alt="customize plotly scatter plot">
Finally, you can also change the size of the marker, either passing it a scalar value (such as <code>5</code>) to the <code>fig.update_traces()</code> method, or by passing in a vector value (such as mapping the size to a feature) to the <code>size</code> argument.
Let's map the <code>oldpeak</code> feature with the size of each marker:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, 
 y=&#x27;thalachh&#x27;, 
 color=&#x27;output&#x27;, 
 size=&#x27;oldpeak&#x27;, 
 hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])
fig.show()
</code></pre>
Now, each marker will have a variable size, depending on the values of the <code>oldpeak</code> feature:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-5.png" alt="variable size plotly scatter plot">
Or, if you want to specifically make all markers of the same, fixed size, you can update the <code>Figure</code>'s traces:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;,
 y=&#x27;thalachh&#x27;,
 color=&#x27;output&#x27;,
 hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])

fig.update_traces(marker={&#x27;size&#x27;: 10}) 
fig.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-6.png" alt="fixed size plotly scatter plot">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to plot a Scatter Plot using Python and Plotly.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll take a look at how to plot a Scatter Plot with Plotly and Python - as well as how to customize it, with examples.

Plotly Scatter Plot - Tutorial with Examples

Mila Lukic

In this guide, we'll take a look at the theory and implementation of Borůvka's Algorithm in Python, with illustrations to make it easier to understand.

Borůvka's Algorithm in Python - Theory and Implementation

Graphs in Python: Minimum Spanning Trees - Borůvka's Algorithm

<h2 id="introduction">Introduction</h2>
<code>Map</code> implementations in Java represent structures that map keys to values. A <code>Map</code> cannot contain duplicate keys and each can at most be mapped to one value. The <code>Map&lt;K,V&gt;</code> implementations are generic and accept any <code>K</code> (key) and <code>V</code> (value) to be mapped.
The <code>Map</code> interface also includes methods for some basic operations (such as <code>put()</code>, <code>get()</code>, <code>containsKey()</code>, <code>containsValue()</code>, <code>size()</code>, etc.), bulk operations (such as <code>putAll()</code> and <code>clear()</code>) and collection views (such as <code>keySet()</code>, <code>entrySet()</code> and <code>values()</code>).
The most prominent <code>Map</code> implementations used for general purposes are: <code>HashMap</code>, <code>TreeMap</code> and <code>LinkedHashMap</code>.
In this article, we'll take a look at how to filter a Map by its keys and values:
<ul>
<li><a href="#filteramapwithenhancedforloops">Filter a Map with enhanced for-loops</a></li>
<li><a href="#filteramapbykeyswithstreamfilter">Filter a Map by Keys with Stream.filter()</a></li>
<li><a href="#filteramapbyvalueswithstreamfilter">Filter a Map by Values with Stream.filter()</a></li>
</ul>
<h2 id="filteramapwithenhancedforloops">Filter a Map with enhanced for-loops</h2>
Let's populate a <code>HashMap</code> with some key-value pairs:
<pre><code class="hljs">Map&lt;Integer, String&gt; employeeMap = new HashMap&lt;&gt;();

employeeMap.put(35, &quot;Mark&quot;);
employeeMap.put(40, &quot;John&quot;);
employeeMap.put(23, &quot;Michael&quot;);
employeeMap.put(31, &quot;Jim&quot;);
employeeMap.put(25, &quot;Kevin&quot;);
</code></pre>
The <code>Map</code> has keys of type <code>Integer</code> and values of type <code>String</code>. They represent the age and name of the employees.
We'll filter this map by keys and values and save the results in a <code>Collection</code>, such as another <code>Map</code> implementation, or even another <code>HashMap</code>.
Let's go with the <code>LinkedHashMap</code> which preserves the order of insertion:
<pre><code class="hljs">Map&lt;Integer, String&gt; linkedHashMap = new LinkedHashMap&lt;&gt;();

for (Map.Entry&lt;Integer, String&gt; employee : employeeMap.entrySet()) {
 if(employee.getKey() &gt; 30){
 linkedHashMap.put(employee.getKey(), employee.getValue());
 }
}
 
System.out.println(&quot;Filtered Map: &quot; + linkedHashMap);
</code></pre>
Here, we've gone through the <code>entrySet()</code> of the <code>employeeMap</code>, and added each employee into a <code>LinkedHashMap</code> via its <code>put()</code> method. This would work the exact same for the <code>HashMap</code> implementation, but it wouldn't preserve the order of insertion:
<pre><code class="hljs">Filtered Map: {35=Mark, 40=John, 31=Jim}
</code></pre>
Filtering out by values boils down to much the same approach, albeit, we'll be checking the value of each entry and using that in a condition:
<pre><code class="hljs">Map&lt;Integer, String&gt; linkedHashMap = new LinkedHashMap&lt;&gt;();

for (Map.Entry&lt;Integer, String&gt; employee : employeeMap.entrySet()) {
 if(employee.getValue().equals(&quot;Mark&quot;)){
 linkedHashMap.put(employee.getKey(), employee.getValue());
 }
}

System.out.println(&quot;Filtered Map: &quot; + linkedHashMap);
</code></pre>
And this would output:
<pre><code class="hljs">Filtered Map: {35=Mark}
</code></pre>
This is the manual way to filter a map - iterating and picking the desired elements. Let's now take a look at a more readable, and friendlier way - via the Stream API.
<h2 id="streamfilter">Stream.filter()</h2>
A more modern way to filter maps would be leveraging the Stream API from Java 8, which makes this process much more readable. The <code>filter()</code> method of the <code>Stream</code> class, as the name suggests, filters any <code>Collection</code> based on a given condition.
For example, given a <code>Collection</code> of names, you can filter them out based on conditions such as - containing certain characters or starting with a specific character.
<h2 id="filteramapbykeyswithstreamfilter">Filter a Map by Keys with Stream.filter()</h2>
Let's leverage the Stream API to filter out this same map given the same condition. We'll <code>stream()</code> the <code>entrySet()</code> of the map, and <code>collect()</code> it back into a <code>Map</code>:
<pre><code class="hljs">Map&lt;Integer, String&gt; filteredMap = employeeMap.entrySet()
 .stream().filter(x-&gt;x.getKey() &gt; 30)
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

System.out.println(&quot;Filtered map: &quot; + filteredMap);
</code></pre>
What this code does is much the same as what we did manually - for each element in the map's set, we check if their key's value is greater than <code>30</code> and collect the values into a new <code>Map</code>, with their respective keys and values supplied through the <code>getKey()</code> and <code>getValue()</code> method references:
<pre><code class="hljs">Filtered map: {35=Mark, 40=John, 31=Jim}
</code></pre>
<h2 id="filteramapbyvalueswithstreamfilter">Filter a Map by Values with Stream.filter()</h2>
Now, let's populate another map, and instead of a <code>&lt;Integer, String&gt;</code> key-value pair, we'll use a <code>&lt;String, String&gt;</code> pair:
<pre><code class="hljs">Map&lt;String, String&gt; cityMap = new HashMap&lt;&gt;();

cityMap.put(&quot;Tokyo&quot;, &quot;Japan&quot;);
cityMap.put(&quot;Berlin&quot;, &quot;Germany&quot;);
cityMap.put(&quot;Kyoto&quot;, &quot;Japan&quot;);
cityMap.put(&quot;Belgrade&quot;, &quot;Serbia&quot;);
cityMap.put(&quot;Madrid&quot;, &quot;Spain&quot;);
</code></pre>
This time around, we've got city-country pairs, where keys are individual cities, and the values are the countries they're located in. Values don't have to be unique. <code>Kyoto</code> and <code>Tokyo</code>, which are both unique keys can have the same value - <code>Japan</code>.
Sorting this map by values, again, boils down to much the same approach as before - we'll simply use the value, via the <code>getValue()</code> method in the filtering condition:
<pre><code class="hljs">Map&lt;String, String&gt; filteredMap = citiesMap.entrySet()
 .stream().filter(x-&gt;&quot;Japan&quot;.equals(x.getValue()))
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

System.out.println(&quot;Filtered map: &quot; + filteredMap)
</code></pre>
Now, this results in a filtered map that contains both <code>Tokyo</code> and <code>Kyoto</code>:
<pre><code class="hljs">Filtered map: {Tokyo=Japan, Kyoto=Japan}
</code></pre>
You can get creative with the outputs and results here. For example, instead of putting these elements into a new map and returning that - we can manipulate the resulting value into other structures as well. For example, we could filter out the keys what have <code>Japan</code> and <code>Serbia</code> as values, and join the keys into a single <code>String</code>:
<pre><code class="hljs">String filteredMap = citiesMap.entrySet()
 .stream().filter(x-&gt; x.getValue().equals(&quot;Japan&quot;) || 
 x.getValue().equals(&quot;Serbia&quot;))
 .map(Map.Entry::getKey).collect(Collectors.joining(&quot;, &quot;));

System.out.println(&quot;Filtered map: &quot; + filteredMap);
</code></pre>
Here, we've used a different <code>Collector</code> than before. The <code>Collectors.joining()</code> returns a new <code>Collector</code> that joins the elements into a <code>String</code>. Other than the <code>CharSequence delimiter</code> we've passed in, we could've also supplied a <code>CharSequence prefix</code> and <code>CharSequence suffix</code> for each joined element.
This results in a <code>String</code>, with all of the filtered elements, separated by a <code>,</code>:
<pre><code class="hljs">Filtered map: Belgrade, Tokyo, Kyoto
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've taken a look at how to filter a <code>Map</code> in Java. We've first gone over how to use enhanced for-loops for pre-Java 8 projects, after which we've dived into the Steam API and leveraged the <code>filter()</code> method.
Filtering maps by either values or keys is rendered into a simple, one-liner task with the help of the Stream API, and you have a wide variety of <code>Collector</code>s to format the output to your liking.

Branko Ilic

In this tutorial, we'll take a look at how to filter a Map by key or value in Java 8, using an enhanced for-loop and the Stream API's `filter()` method, with examples.